2008-04-11 12:45:31 +00:00
|
|
|
/*
|
2013-05-19 21:21:20 +00:00
|
|
|
* Copyright 2005-2012 Jacek Caban for CodeWeavers
|
2008-04-11 12:45:31 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
|
|
*/
|
|
|
|
|
2013-05-19 21:21:20 +00:00
|
|
|
/*
|
2008-04-11 12:45:31 +00:00
|
|
|
* NOTE:
|
2008-07-08 16:39:29 +00:00
|
|
|
* This file is not a typical idl file. Interfaces in this file are XPCOM
|
|
|
|
* interfaces (NOT MSCOM!), but we generate the header file with WIDL
|
|
|
|
* compatible with XPCOM, usable in C code.
|
2008-04-11 12:45:31 +00:00
|
|
|
*/
|
|
|
|
|
2014-04-26 18:30:09 +00:00
|
|
|
cpp_quote("#define GECKO_VERSION \"2.24\"")
|
2008-04-11 12:45:31 +00:00
|
|
|
cpp_quote("#define GECKO_VERSION_STRING \"Wine Gecko \" GECKO_VERSION")
|
|
|
|
|
|
|
|
import "wtypes.idl";
|
|
|
|
|
2009-02-13 18:04:38 +00:00
|
|
|
cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
|
|
|
|
cpp_quote("#undef GetForm")
|
|
|
|
cpp_quote("#undef SetPort")
|
|
|
|
cpp_quote("#endif")
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
typedef HRESULT nsresult;
|
|
|
|
typedef ULONG nsrefcnt;
|
|
|
|
|
|
|
|
typedef IID nsID;
|
|
|
|
typedef IID nsIID;
|
|
|
|
typedef nsIID nsCID;
|
|
|
|
typedef REFIID nsIIDRef;
|
|
|
|
typedef nsIIDRef nsCIDRef;
|
|
|
|
|
|
|
|
typedef WCHAR PRUnichar;
|
2013-05-19 21:21:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Mozilla uses stdint.h types for its headers. Following defines make this IDL file
|
|
|
|
* more similar to original declarations. Note that it's only a widl trick, we can't
|
|
|
|
* use stdint.h types in C.
|
|
|
|
*/
|
|
|
|
#define int16_t short
|
|
|
|
#define int32_t LONG
|
|
|
|
#define int64_t INT64
|
|
|
|
|
|
|
|
#define uint8_t UINT8
|
|
|
|
#define uint16_t UINT16
|
|
|
|
#define uint32_t UINT32
|
|
|
|
#define uint64_t UINT64
|
|
|
|
|
|
|
|
typedef uint64_t DOMTimeStamp;
|
|
|
|
typedef uint32_t nsLoadFlags;
|
|
|
|
typedef int64_t PRTime;
|
|
|
|
|
|
|
|
/* Similar trick to stdint.h types for C++ bool type */
|
|
|
|
typedef unsigned char cpp_bool;
|
|
|
|
#define bool cpp_bool
|
2008-04-11 12:45:31 +00:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
void *v;
|
|
|
|
void *d1;
|
2013-05-19 21:21:20 +00:00
|
|
|
uint32_t d2;
|
2008-04-11 12:45:31 +00:00
|
|
|
void *d3;
|
|
|
|
} nsCStringContainer;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
void *v;
|
|
|
|
void *d1;
|
2013-05-19 21:21:20 +00:00
|
|
|
uint32_t d2;
|
2008-04-11 12:45:31 +00:00
|
|
|
void *d3;
|
|
|
|
} nsStringContainer;
|
|
|
|
|
|
|
|
typedef nsCStringContainer nsACString;
|
|
|
|
typedef nsStringContainer nsAString;
|
|
|
|
|
|
|
|
interface nsIWebBrowserChrome;
|
|
|
|
interface nsILoadGroup;
|
|
|
|
interface nsIDOMNode;
|
2014-04-26 18:30:09 +00:00
|
|
|
interface nsIDOMAttr;
|
2008-04-11 12:45:31 +00:00
|
|
|
interface nsIDOMDocument;
|
|
|
|
interface nsIDOMEvent;
|
|
|
|
interface nsIEditor;
|
|
|
|
interface nsISelectionController;
|
|
|
|
interface nsITransactionManager;
|
|
|
|
interface nsITransaction;
|
|
|
|
interface nsIInlineSpellChecker;
|
|
|
|
interface nsIOutputStream;
|
|
|
|
interface nsIEditorObserver;
|
|
|
|
interface nsIEditActionListener;
|
|
|
|
interface nsIDocumentStateListener;
|
|
|
|
interface nsIDOMCSSStyleSheet;
|
2009-02-04 14:35:06 +00:00
|
|
|
interface nsIDOMDocumentView;
|
2009-11-15 23:44:20 +00:00
|
|
|
interface nsIDOMWindow;
|
2013-05-19 21:21:20 +00:00
|
|
|
interface nsIDOMElement;
|
|
|
|
interface nsIDOMRange;
|
|
|
|
interface nsIDOMEventTarget;
|
|
|
|
interface nsISelection;
|
|
|
|
interface nsIDOMHTMLSelectElement;
|
|
|
|
interface nsIFile;
|
2008-04-11 12:45:31 +00:00
|
|
|
|
|
|
|
interface IMoniker;
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(00000000-0000-0000-c000-000000000046),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult QueryInterface(nsIIDRef riid, void **result);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsrefcnt AddRef();
|
|
|
|
nsrefcnt Release();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Currently we don't need a full declaration of these interfaces */
|
|
|
|
typedef nsISupports nsISHistory;
|
|
|
|
typedef nsISupports nsIWidget;
|
|
|
|
typedef nsISupports nsIPrompt;
|
|
|
|
typedef nsISupports nsIAuthPrompt;
|
|
|
|
typedef nsISupports nsIDOMDocumentType;
|
|
|
|
typedef nsISupports nsIDOMDOMImplementation;
|
|
|
|
typedef nsISupports nsIDOMCDATASection;
|
|
|
|
typedef nsISupports nsIDOMProcessingInstruction;
|
|
|
|
typedef nsISupports nsIDOMEntityReference;
|
|
|
|
typedef nsISupports nsIWebProgressListener;
|
|
|
|
typedef nsISupports nsIDOMCSSValue;
|
|
|
|
typedef nsISupports nsIPrintSession;
|
|
|
|
typedef nsISupports nsIControllerCommandTable;
|
|
|
|
typedef nsISupports nsIPrincipal;
|
|
|
|
typedef nsISupports nsIAtom;
|
|
|
|
typedef nsISupports nsISupportsArray;
|
|
|
|
typedef nsISupports nsIContentFilter;
|
|
|
|
typedef nsISupports nsIDOMMediaList;
|
2009-02-04 14:35:06 +00:00
|
|
|
typedef nsISupports nsIDOMHTMLTableCaptionElement;
|
|
|
|
typedef nsISupports nsIDOMHTMLTableSectionElement;
|
|
|
|
typedef nsISupports nsIDOMClientRectList;
|
|
|
|
typedef nsISupports nsINode;
|
|
|
|
typedef nsISupports nsIStyleSheet;
|
|
|
|
typedef nsISupports nsIStyleRule;
|
2010-01-18 16:27:14 +00:00
|
|
|
typedef nsISupports nsIDOMUserDataHandler;
|
|
|
|
typedef nsISupports nsIDocShellLoadInfo;
|
|
|
|
typedef nsISupports nsISHEntry;
|
|
|
|
typedef nsISupports nsIPresShell;
|
|
|
|
typedef nsISupports nsIContentViewer;
|
|
|
|
typedef nsISupports nsIDocumentCharsetInfo;
|
|
|
|
typedef nsISupports nsILayoutHistoryState;
|
|
|
|
typedef nsISupports nsISecureBrowserUI;
|
|
|
|
typedef nsISupports nsIDOMStorage;
|
2013-05-19 21:21:20 +00:00
|
|
|
typedef nsISupports nsIDOMDOMTokenList;
|
|
|
|
typedef nsISupports nsITransferable;
|
|
|
|
typedef nsISupports nsIDOMFileList;
|
|
|
|
typedef nsISupports nsIDOMFile;
|
|
|
|
typedef nsISupports nsIControllers;
|
|
|
|
typedef nsISupports nsIDOMValidityState;
|
|
|
|
typedef nsISupports nsIPluginInstanceOwner;
|
|
|
|
typedef nsISupports nsIPluginStreamListener;
|
|
|
|
typedef nsISupports nsIContentSink;
|
|
|
|
typedef nsISupports nsIParserFilter;
|
|
|
|
typedef nsISupports nsIDTD;
|
|
|
|
typedef nsISupports nsIObserver;
|
|
|
|
typedef nsISupports nsIDOMNodeFilter;
|
|
|
|
typedef nsISupports nsIDOMNodeIterator;
|
|
|
|
typedef nsISupports nsIDOMTreeWalker;
|
|
|
|
typedef nsISupports nsIHttpUpgradeListener;
|
|
|
|
typedef nsISupports nsIDOMDOMStringMap;
|
|
|
|
typedef nsISupports nsIDOMDOMStringList;
|
|
|
|
typedef nsISupports nsIDOMOfflineResourceList;
|
|
|
|
typedef nsISupports nsIDOMHistory;
|
|
|
|
typedef nsISupports nsIDOMNavigator;
|
|
|
|
typedef nsISupports nsIDOMMediaQueryList;
|
|
|
|
typedef nsISupports nsIDOMScreen;
|
|
|
|
typedef nsISupports nsIAnimationFrameListener;
|
|
|
|
typedef nsISupports nsIDOMStorageList;
|
|
|
|
typedef nsISupports nsILocalFile;
|
|
|
|
typedef nsISupports nsIDOMHTMLMenuElement;
|
|
|
|
typedef nsISupports nsIDOMCaretPosition;
|
|
|
|
typedef nsISupports nsIFrameRequestCallback;
|
|
|
|
typedef nsISupports nsICycleCollectorListener;
|
|
|
|
typedef nsISupports nsIDOMHTMLCanvasElement;
|
|
|
|
typedef nsISupports nsIQueryContentEventResult;
|
|
|
|
typedef nsISupports nsIDOMBlob;
|
|
|
|
typedef nsISupports nsIPrivacyTransitionObserver;
|
|
|
|
typedef nsISupports nsIDOMHTMLPropertiesCollection;
|
|
|
|
typedef nsISupports mozIDOMApplication;
|
2013-10-07 14:22:37 +00:00
|
|
|
typedef nsISupports nsILoadGroupConnectionInfo;
|
|
|
|
typedef nsISupports nsIDOMCrypto;
|
|
|
|
typedef nsISupports nsIDOMPkcs11;
|
|
|
|
typedef nsISupports nsIDocShellTreeOwner;
|
2013-05-19 21:21:20 +00:00
|
|
|
|
|
|
|
typedef void *JSContext;
|
|
|
|
typedef void *JSObject;
|
|
|
|
typedef uint64_t jsval;
|
2008-04-11 12:45:31 +00:00
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(8bb35ed9-e332-462d-9155-4a002ab5c958),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIServiceManager : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetService(nsCIDRef aClass, nsIIDRef aIID, void **result);
|
|
|
|
nsresult GetServiceByContractID(const char *aContractID, nsIIDRef aIID, void **result);
|
|
|
|
nsresult IsServiceInstantiated(nsCIDRef aClass, nsIIDRef aIID, BOOL *_retval);
|
|
|
|
nsresult IsServiceInstantiatedByContractID(const char *aContractID, nsIIDRef aIID, BOOL *_retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(00000001-0000-0000-c000-000000000046),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIFactory : nsISupports
|
|
|
|
{
|
|
|
|
nsresult CreateInstance(nsISupports *aOuter, const nsIID *iid, void **result);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult LockFactory(bool lock);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(6aef11c4-8615-44a6-9711-98f43805693d),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIMemory : nsISupports
|
|
|
|
{
|
|
|
|
void *Alloc(/*size_t*/ int size);
|
|
|
|
void *Realloc(void *_ptr, /*size_t*/ int newSize);
|
|
|
|
void Free(void *_ptr);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult HeapMinimize(bool immediate);
|
|
|
|
nsresult IsLowMemory(bool *_retval);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult IsLowMemoryPlatform(bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(9188bc85-f92e-11d2-81ef-0060083a0bcf),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWeakReference : nsISupports
|
|
|
|
{
|
|
|
|
nsresult QueryReferent(const nsIID *riid, void **result);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(9188bc86-f92e-11d2-81ef-0060083a0bcf),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsISupportsWeakReference : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetWeakReference(nsIWeakReference **_retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(033a1470-8b2a-11d3-af88-00a024ffc08c),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIInterfaceRequestor : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetInterface(const nsIID *riid, void **result);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2009-02-04 14:35:06 +00:00
|
|
|
uuid(4a2abaf0-6886-11d3-9382-00104ba0fd40),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
2009-02-04 14:35:06 +00:00
|
|
|
interface nsIRunnable : nsISupports
|
2008-04-11 12:45:31 +00:00
|
|
|
{
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult Run();
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2009-02-04 14:35:06 +00:00
|
|
|
uuid(d1899240-f9d2-11d2-bdd6-000064657374),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
2009-02-04 14:35:06 +00:00
|
|
|
interface nsISimpleEnumerator : nsISupports
|
2008-04-11 12:45:31 +00:00
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult HasMoreElements(bool *_retval);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetNext(nsISupports **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(81e4c2de-acac-4ad6-901a-b5fb1b851a0d),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIVariant : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetDataType(uint16_t *aDataType);
|
|
|
|
nsresult GetAsInt8(uint8_t *_retval);
|
|
|
|
nsresult GetAsInt16(int16_t *_retval);
|
|
|
|
nsresult GetAsInt32(int32_t *_retval);
|
|
|
|
nsresult GetAsInt64(int64_t *_retval);
|
|
|
|
nsresult GetAsUint8(uint8_t *_retval);
|
|
|
|
nsresult GetAsUint16(uint16_t *_retval);
|
|
|
|
nsresult GetAsUint32(uint32_t *_retval);
|
|
|
|
nsresult GetAsUint64(uint64_t *_retval);
|
|
|
|
nsresult GetAsFloat(float *_retval);
|
|
|
|
nsresult GetAsDouble(double *_retval);
|
|
|
|
nsresult GetAsBool(bool *_retval);
|
|
|
|
nsresult GetAsChar(char *_retval);
|
|
|
|
nsresult GetAsWChar(PRUnichar *_retval);
|
|
|
|
nsresult GetAsID(nsID *retval);
|
|
|
|
nsresult GetAsAString(nsAString *_retval);
|
|
|
|
nsresult GetAsDOMString(nsAString *_retval);
|
|
|
|
nsresult GetAsACString(nsACString *_retval);
|
|
|
|
nsresult GetAsAUTF8String(nsACString *_retval);
|
|
|
|
nsresult GetAsString(char * *_retval);
|
|
|
|
nsresult GetAsWString(PRUnichar * *_retval);
|
|
|
|
nsresult GetAsISupports(nsISupports * *_retval);
|
|
|
|
nsresult GetAsJSVal(long /*jsval*/ *_retval);
|
|
|
|
nsresult GetAsInterface(nsIID **iid, void **iface);
|
|
|
|
nsresult GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr);
|
|
|
|
nsresult GetAsStringWithSize(uint32_t *size, char **str);
|
|
|
|
nsresult GetAsWStringWithSize(uint32_t *size, PRUnichar **str);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(5586a590-8c82-11d5-90f3-0010a4e73d9a),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWritableVariant : nsIVariant
|
|
|
|
{
|
|
|
|
nsresult GetWritable(bool *aWritable);
|
|
|
|
nsresult SetWritable(bool aWritable);
|
|
|
|
nsresult SetAsInt8(uint8_t aValue);
|
|
|
|
nsresult SetAsInt16(int16_t aValue);
|
|
|
|
nsresult SetAsInt32(int32_t aValue);
|
|
|
|
nsresult SetAsInt64(int64_t aValue);
|
|
|
|
nsresult SetAsUint8(uint8_t aValue);
|
|
|
|
nsresult SetAsUint16(uint16_t aValue);
|
|
|
|
nsresult SetAsUint32(uint32_t aValue);
|
|
|
|
nsresult SetAsUint64(uint64_t aValue);
|
|
|
|
nsresult SetAsFloat(float aValue);
|
|
|
|
nsresult SetAsDouble(double aValue);
|
|
|
|
nsresult SetAsBool(bool aValue);
|
|
|
|
nsresult SetAsChar(char aValue);
|
|
|
|
nsresult SetAsWChar(PRUnichar aValue);
|
|
|
|
nsresult SetAsID(const nsID *aValue);
|
|
|
|
nsresult SetAsAString(const nsAString *aValue);
|
|
|
|
nsresult SetAsDOMString(const nsAString *aValue);
|
|
|
|
nsresult SetAsACString(const nsACString *aValue);
|
|
|
|
nsresult SetAsAUTF8String(const nsACString *aValue);
|
|
|
|
nsresult SetAsString(const char * aValue);
|
|
|
|
nsresult SetAsWString(const PRUnichar * aValue);
|
|
|
|
nsresult SetAsISupports(nsISupports *aValue);
|
|
|
|
nsresult SetAsInterface(const nsIID *iid, void *iface);
|
|
|
|
nsresult SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr);
|
|
|
|
nsresult SetAsStringWithSize(uint32_t size, const char *str);
|
|
|
|
nsresult SetAsWStringWithSize(uint32_t size, const PRUnichar *str);
|
|
|
|
nsresult SetAsVoid();
|
|
|
|
nsresult SetAsEmpty();
|
|
|
|
nsresult SetAsEmptyArray();
|
|
|
|
nsresult SetFromVariant(nsIVariant *aValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(53cdbc97-c2d7-4e30-b2c3-45b2ee79db18),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIInputStream : nsISupports
|
|
|
|
{
|
|
|
|
nsresult Close();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Available(uint64_t *_retval);
|
|
|
|
nsresult Read(char *aBuf, uint32_t aCount, uint32_t *_retval);
|
|
|
|
nsresult ReadSegments(nsresult (*aWriter)(nsIInputStream *aInStream,
|
|
|
|
void *aClosure, const char *aFromSegment, uint32_t aToOffset,
|
|
|
|
uint32_t aCount, uint32_t *aWriteCount),
|
|
|
|
void *aClosure, uint32_t aCount, uint32_t *_retval);
|
|
|
|
nsresult IsNonBlocking(bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(395fe045-7d18-4adb-a3fd-af98c8a1af11),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIURI : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetSpec(nsACString *aSpec);
|
|
|
|
nsresult SetSpec(const nsACString *aSpec);
|
|
|
|
nsresult GetPrePath(nsACString *aPrePath);
|
|
|
|
nsresult GetScheme(nsACString *aScheme);
|
|
|
|
nsresult SetScheme(const nsACString *aScheme);
|
|
|
|
nsresult GetUserPass(nsACString *aUserPass);
|
|
|
|
nsresult SetUserPass(const nsACString *aUserPass);
|
|
|
|
nsresult GetUsername(nsACString *aUsername);
|
|
|
|
nsresult SetUsername(const nsACString *aUsername);
|
|
|
|
nsresult GetPassword(nsACString *aPassword);
|
|
|
|
nsresult SetPassword(const nsACString *aPassword);
|
|
|
|
nsresult GetHostPort(nsACString *aHostPort);
|
|
|
|
nsresult SetHostPort(const nsACString *aHostPort);
|
|
|
|
nsresult GetHost(nsACString *aHost);
|
|
|
|
nsresult SetHost(const nsACString *aHost);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPort(int32_t *aPort);
|
|
|
|
nsresult SetPort(int32_t aPort);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetPath(nsACString *aPath);
|
|
|
|
nsresult SetPath(const nsACString *aPath);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Equals(nsIURI *other, bool *_retval);
|
|
|
|
nsresult SchemeIs(const char *scheme, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Clone(nsIURI **_retval);
|
|
|
|
nsresult Resolve(const nsACString *relativePath, nsACString *_retval);
|
|
|
|
nsresult GetAsciiSpec(nsACString *aAsciiSpec);
|
|
|
|
nsresult GetAsciiHost(nsACString *aAsciiHost);
|
|
|
|
nsresult GetOriginCharset(nsACString *aOriginCharset);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetRef(nsACString *aRef);
|
|
|
|
nsresult SetRef(const nsACString *aRef);
|
|
|
|
nsresult EqualsExceptRef(nsIURI *other, bool *_retval);
|
|
|
|
nsresult CloneIgnoringRef(nsIURI **_retval);
|
|
|
|
nsresult GetSpecIgnoringRef(nsACString *aSpecIgnoringRef);
|
|
|
|
nsresult GetHasRef(bool *aHasRef);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
2009-09-05 15:02:49 +00:00
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(1419aa16-f134-4154-9886-00c7c5147a13),
|
2009-09-05 15:02:49 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIURL : nsIURI
|
|
|
|
{
|
|
|
|
nsresult GetFilePath(nsACString *aFilePath);
|
|
|
|
nsresult SetFilePath(const nsACString *aFilePath);
|
|
|
|
nsresult GetQuery(nsACString *aQuery);
|
|
|
|
nsresult SetQuery(const nsACString *aQuery);
|
|
|
|
nsresult GetDirectory(nsACString *aDirectory);
|
|
|
|
nsresult SetDirectory(const nsACString *aDirectory);
|
|
|
|
nsresult GetFileName(nsACString *aFileName);
|
|
|
|
nsresult SetFileName(const nsACString *aFileName);
|
|
|
|
nsresult GetFileBaseName(nsACString *aFileBaseName);
|
|
|
|
nsresult SetFileBaseName(const nsACString *aFileBaseName);
|
|
|
|
nsresult GetFileExtension(nsACString *aFileExtension);
|
|
|
|
nsresult SetFileExtension(const nsACString *aFileExtension);
|
|
|
|
nsresult GetCommonBaseSpec(nsIURI *aURIToCompare, nsACString *_retval);
|
|
|
|
nsresult GetRelativeSpec(nsIURI *aURIToCompare, nsACString *_retval);
|
|
|
|
}
|
|
|
|
|
2013-05-19 21:21:20 +00:00
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(7750029c-1b0a-414e-8359-a77f24a2a0a6),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIFileURL : nsIURL
|
|
|
|
{
|
|
|
|
nsresult GetFile(nsIFile **aFile);
|
|
|
|
nsresult SetFile(nsIFile *aFile);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(321578d0-03c1-4d95-8821-021ac612d18d),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIMutable : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetMutable(bool *aMutable);
|
|
|
|
nsresult SetMutable(bool aMutable);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(babd6cca-ebe7-4329-967c-d6b9e33caa81),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIStandardURL : nsIMutable
|
|
|
|
{
|
|
|
|
nsresult Init(uint32_t aUrlType, int32_t aDefaultPort, const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI);
|
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIRequest : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetName(nsACString *aName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult IsPending(bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetStatus(nsresult *aStatus);
|
|
|
|
nsresult Cancel(nsresult aStatus);
|
|
|
|
nsresult Suspend();
|
|
|
|
nsresult Resume();
|
|
|
|
nsresult GetLoadGroup(nsILoadGroup **aLoadGroup);
|
|
|
|
nsresult SetLoadGroup(nsILoadGroup *aLoadGroup);
|
|
|
|
nsresult GetLoadFlags(nsLoadFlags *aLoadFlags);
|
|
|
|
nsresult SetLoadFlags(nsLoadFlags aLoadFlags);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIRequestObserver : nsISupports
|
|
|
|
{
|
|
|
|
nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext);
|
|
|
|
nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(3b4c8a77-76ba-4610-b316-678c73a3b88c),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
2013-05-19 21:21:20 +00:00
|
|
|
]
|
2008-04-11 12:45:31 +00:00
|
|
|
interface nsIStreamListener : nsIRequestObserver
|
|
|
|
{
|
|
|
|
nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
|
2013-05-19 21:21:20 +00:00
|
|
|
nsIInputStream *aInputStream, uint64_t aOffset, uint32_t aCount);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(19501006-46e3-4634-b97d-26eff894b4d3),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsILoadGroup : nsIRequest
|
|
|
|
{
|
|
|
|
nsresult GetGroupObserver(nsIRequestObserver **aGroupObserver);
|
|
|
|
nsresult SetGroupObserver(nsIRequestObserver *aGroupObserver);
|
|
|
|
nsresult GetDefaultLoadRequest(nsIRequest **aDefaultLoadRequest);
|
|
|
|
nsresult SetDefaultLoadRequest(nsIRequest *aDefaultLoadRequest);
|
|
|
|
nsresult AddRequest(nsIRequest *aRequest, nsISupports *aContext);
|
|
|
|
nsresult RemoveRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatus);
|
|
|
|
nsresult GetRequests(nsISimpleEnumerator **aRequests);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetActiveCount(uint32_t *aActiveCount);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
|
|
|
|
nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetConnectionInfo(nsILoadGroupConnectionInfo **aConnectionInfo);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(2a8a7237-c1e2-4de7-b669-2002af29e42d),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIChannel : nsIRequest
|
|
|
|
{
|
2013-10-07 14:22:37 +00:00
|
|
|
const UINT LOAD_DOCUMENT_URI = 1 << 16;
|
|
|
|
const UINT LOAD_RETARGETED_DOCUMENT_URI = 1 << 17;
|
|
|
|
const UINT LOAD_REPLACE = 1 << 18;
|
|
|
|
const UINT LOAD_INITIAL_DOCUMENT_URI = 1 << 19;
|
|
|
|
const UINT LOAD_TARGETED = 1 << 20;
|
|
|
|
const UINT LOAD_CALL_CONTENT_SNIFFERS = 1 << 21;
|
|
|
|
const UINT LOAD_CLASSIFY_URI = 1 << 22;
|
|
|
|
const UINT LOAD_TREAT_APPLICATION_OCTET_STREAM_AS_UNKNOWN = 1 << 23;
|
|
|
|
const UINT LOAD_EXPLICIT_CREDENTIALS = 1 << 24;
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetOriginalURI(nsIURI **aOriginalURI);
|
|
|
|
nsresult SetOriginalURI(nsIURI *aOriginalURI);
|
|
|
|
nsresult GetURI(nsIURI **aURI);
|
|
|
|
nsresult GetOwner(nsISupports **aOwner);
|
|
|
|
nsresult SetOwner(nsISupports *aOwner);
|
|
|
|
nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
|
|
|
|
nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
|
|
|
|
nsresult GetSecurityInfo(nsISupports **aSecurityInfo);
|
|
|
|
nsresult GetContentType(nsACString *aContentType);
|
|
|
|
nsresult SetContentType(const nsACString *aContentType);
|
|
|
|
nsresult GetContentCharset(nsACString *aContentCharset);
|
|
|
|
nsresult SetContentCharset(const nsACString *aContentCharset);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetContentLength(int64_t *aContentLength);
|
|
|
|
nsresult SetContentLength(int64_t aContentLength);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Open(nsIInputStream **_retval);
|
|
|
|
nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetContentDisposition(uint32_t *aContentDisposition);
|
|
|
|
nsresult SetContentDisposition(uint32_t aContentDisposition);
|
|
|
|
nsresult GetContentDispositionFilename(nsAString *aContentDispositionFilename);
|
|
|
|
nsresult SetContentDispositionFilename(const nsAString *aContentDispositionFilename);
|
|
|
|
nsresult GetContentDispositionHeader(nsACString *aContentDispositionHeader);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(35412859-b9d9-423c-8866-2d4559fdd2be),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIHttpHeaderVisitor : nsISupports
|
|
|
|
{
|
|
|
|
nsresult VisitHeader(const nsACString *aHeader, const nsACString *aValue);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(a01362a0-5c45-11e2-bcfd-0800200c9a66),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIHttpChannel : nsIChannel
|
|
|
|
{
|
|
|
|
nsresult GetRequestMethod(nsACString *aRequestMethod);
|
|
|
|
nsresult SetRequestMethod(const nsACString *aRequestMethod);
|
|
|
|
nsresult GetReferrer(nsIURI **aReferrer);
|
|
|
|
nsresult SetReferrer(nsIURI *aReferrer);
|
|
|
|
nsresult GetRequestHeader(const nsACString *aHeader, nsACString *_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetRequestHeader(const nsACString *aHeader, const nsACString *aValue, bool aMerge);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAllowPipelining(bool *aAllowPipelining);
|
|
|
|
nsresult SetAllowPipelining(bool aAllowPipelining);
|
|
|
|
nsresult GetRedirectionLimit(uint32_t *aRedirectionLimit);
|
|
|
|
nsresult SetRedirectionLimit(uint32_t aRedirectionLimit);
|
|
|
|
nsresult GetResponseStatus(uint32_t *aResponseStatus);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetResponseStatusText(nsACString *aResponseStatusText);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetRequestSucceeded(bool *aRequestSucceeded);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetResponseHeader(const nsACString *header, const nsACString *value, bool merge);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult IsNoStoreResponse(bool *_retval);
|
|
|
|
nsresult IsNoCacheResponse(bool *_retval);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult RedirectTo(nsIURI *aNewURI);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
2009-09-05 15:02:49 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(2cd7f6a6-63f3-4bd6-a0f5-6e3d6dcff81b),
|
2009-09-05 15:02:49 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIHttpChannelInternal : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetDocumentURI(nsIURI **aDocumentURI);
|
|
|
|
nsresult SetDocumentURI(nsIURI *aDocumentURI);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetRequestVersion(uint32_t *major, uint32_t *minor);
|
|
|
|
nsresult GetResponseVersion(uint32_t *major, uint32_t *minor);
|
2009-09-05 15:02:49 +00:00
|
|
|
nsresult SetCookie(const char *aCookieHeader);
|
|
|
|
nsresult SetupFallbackChannel(const char *aFallbackKey);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetForceAllowThirdPartyCookie(bool *aForceAllowThirdPartyCookie);
|
|
|
|
nsresult SetForceAllowThirdPartyCookie(bool aForceAllowThirdPartyCookie);
|
|
|
|
nsresult GetCanceled(bool *aCanceled);
|
|
|
|
nsresult GetChannelIsForDownload(bool *aChannelIsForDownload);
|
|
|
|
nsresult SetChannelIsForDownload(bool aChannelIsForDownload);
|
|
|
|
nsresult GetLocalAddress(nsACString *aLocalAddress);
|
|
|
|
nsresult GetLocalPort(int32_t *aLocalPort);
|
|
|
|
nsresult GetRemoteAddress(nsACString *aRemoteAddress);
|
|
|
|
nsresult GetRemotePort(int32_t *aRemotePort);
|
|
|
|
nsresult SetCacheKeysRedirectChain(void /*nsTArray<nsCString>*/ *cacheKeys);
|
|
|
|
nsresult HTTPUpgrade(const nsACString *aProtocolName, nsIHttpUpgradeListener *aListener);
|
|
|
|
nsresult GetAllowSpdy(bool *aAllowSpdy);
|
|
|
|
nsresult SetAllowSpdy(bool aAllowSpdy);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetLoadAsBlocking(bool *aLoadAsBlocking);
|
|
|
|
nsresult SetLoadAsBlocking(bool aLoadAsBlocking);
|
|
|
|
nsresult GetLoadUnblocked(bool *aLoadUnblocked);
|
|
|
|
nsresult SetLoadUnblocked(bool aLoadUnblocked);
|
2009-09-05 15:02:49 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(5cfe15bd-5adb-4a7f-9e55-4f5a67d15794),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIUploadChannel : nsISupports
|
|
|
|
{
|
|
|
|
nsresult SetUploadStream(nsIInputStream *aStream, const nsACString *aContentType,
|
2013-05-19 21:21:20 +00:00
|
|
|
int64_t aContentLength);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetUploadStream(nsIInputStream **aUploadStream);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(8d171460-a716-41f1-92be-8c659db39b45),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIAsyncVerifyRedirectCallback : nsISupports
|
|
|
|
{
|
|
|
|
nsresult OnRedirectVerifyCallback(nsresult result);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(a430d870-df77-4502-9570-d46a8de33154),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIChannelEventSink : nsISupports
|
|
|
|
{
|
|
|
|
cpp_quote("#define REDIRECT_TEMPORARY 1")
|
|
|
|
cpp_quote("#define REDIRECT_PERMANENT 2")
|
|
|
|
cpp_quote("#define REDIRECT_INTERNAL 4")
|
|
|
|
|
|
|
|
nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, uint32_t flags,
|
|
|
|
nsIAsyncVerifyRedirectCallback *callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(79de76e5-994e-4f6b-81aa-42d9adb6e67e),
|
2013-05-19 21:21:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMLocation : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetHash(nsAString *aHash);
|
|
|
|
nsresult SetHash(const nsAString *aHash);
|
|
|
|
nsresult GetHost(nsAString *aHost);
|
|
|
|
nsresult SetHost(const nsAString *aHost);
|
|
|
|
nsresult GetHostname(nsAString *aHostname);
|
|
|
|
nsresult SetHostname(const nsAString *aHostname);
|
|
|
|
nsresult GetHref(nsAString *aHref);
|
|
|
|
nsresult SetHref(const nsAString *aHref);
|
|
|
|
nsresult GetPathname(nsAString *aPathname);
|
|
|
|
nsresult SetPathname(const nsAString *aPathname);
|
|
|
|
nsresult GetPort(nsAString *aPort);
|
|
|
|
nsresult SetPort(const nsAString *aPort);
|
|
|
|
nsresult GetProtocol(nsAString *aProtocol);
|
|
|
|
nsresult SetProtocol(const nsAString *aProtocol);
|
|
|
|
nsresult GetSearch(nsAString *aSearch);
|
|
|
|
nsresult SetSearch(const nsAString *aSearch);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetOrigin(nsAString *aOrigin);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Reload(bool forceget);
|
|
|
|
nsresult Replace(const nsAString *url);
|
|
|
|
nsresult Assign(const nsAString *url);
|
|
|
|
nsresult ToString(nsAString *_retval);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult ValueOf(nsIDOMLocation **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(2938307a-9d70-4b63-8afc-0197e82318ad),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMCSSRule : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetType(uint16_t *aType);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetCssText(nsAString *aCssText);
|
|
|
|
nsresult SetCssText(const nsAString *aCssText);
|
|
|
|
nsresult GetParentStyleSheet(nsIDOMCSSStyleSheet **aParentStyleSheet);
|
|
|
|
nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(a6cf90be-15b3-11d2-932e-00805f8add32),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMCSSStyleDeclaration : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetCssText(nsAString *aCssText);
|
|
|
|
nsresult SetCssText(const nsAString *aCssText);
|
|
|
|
nsresult GetPropertyValue(const nsAString *propertyName, nsAString *_retval);
|
|
|
|
nsresult GetPropertyCSSValue(const nsAString *propertyName, nsIDOMCSSValue **_retval);
|
|
|
|
nsresult RemoveProperty(const nsAString *propertyName, nsAString *_retval);
|
|
|
|
nsresult GetPropertyPriority(const nsAString *propertyName, nsAString *_retval);
|
|
|
|
nsresult SetProperty(const nsAString *propertyName, const nsAString *value,
|
|
|
|
const nsAString *priority);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult Item(uint32_t index, nsAString *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(a6cf90c0-15b3-11d2-932e-00805f8add32),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMCSSRuleList : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult Item(uint32_t index, nsIDOMCSSRule **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(a6cf9080-15b3-11d2-932e-00805f8add32),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMStyleSheet : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetType(nsAString *aType);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDisabled(bool *aDisabled);
|
|
|
|
nsresult SetDisabled(bool aDisabled);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetOwnerNode(nsIDOMNode **aOwnerNode);
|
|
|
|
nsresult GetParentStyleSheet(nsIDOMStyleSheet **aParentStyleSheet);
|
|
|
|
nsresult GetHref(nsAString *aHref);
|
|
|
|
nsresult GetTitle(nsAString *aTitle);
|
|
|
|
nsresult GetMedia(nsIDOMMediaList **aMedia);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(a6cf90c2-15b3-11d2-932e-00805f8add32),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMCSSStyleSheet : nsIDOMStyleSheet
|
|
|
|
{
|
|
|
|
nsresult GetOwnerRule(nsIDOMCSSRule **aOwnerRule);
|
|
|
|
nsresult GetCssRules(nsIDOMCSSRuleList **aCssRules);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InsertRule(const nsAString *rule, uint32_t index, uint32_t *_retval);
|
|
|
|
nsresult DeleteRule(uint32_t index);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(a6cf9081-15b3-11d2-932e-00805f8add32),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMStyleSheetList : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult Item(uint32_t index, nsIDOMStyleSheet **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(450cf0ba-de90-4f86-85bf-e10cc8b8713f),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMNodeList : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Item(uint32_t index, nsIDOMNode **_retval);
|
|
|
|
nsresult GetLength(uint32_t *aLength);
|
2013-10-07 14:22:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(bb07f567-5b37-4172-92aa-7d00ceed4809),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLCollection : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult Item(uint32_t index, nsIDOMNode **_retval);
|
|
|
|
nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 16:27:14 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(cb5564cd-26ec-418f-a6d6-1d57cd2c971c),
|
2010-01-18 16:27:14 +00:00
|
|
|
local
|
|
|
|
]
|
2014-04-26 18:30:09 +00:00
|
|
|
interface nsIDOMMozNamedAttrMap : nsISupports
|
2010-01-18 16:27:14 +00:00
|
|
|
{
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetNamedItem(const nsAString *name, nsIDOMAttr **_retval);
|
|
|
|
nsresult SetNamedItem(nsIDOMAttr *arg, nsIDOMAttr **_retval);
|
|
|
|
nsresult RemoveNamedItem(const nsAString *name, nsIDOMAttr **_retval);
|
|
|
|
nsresult Item(uint32_t index, nsIDOMAttr **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetLength(uint32_t *aLength);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
|
|
|
|
nsresult SetNamedItemNS(nsIDOMAttr *arg, nsIDOMAttr **_retval);
|
|
|
|
nsresult RemoveNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
|
2010-01-18 16:27:14 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(56545150-a001-484e-9ed4-cb319eebd7b3),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMNode : nsISupports
|
|
|
|
{
|
|
|
|
enum NSNODETYPE {
|
|
|
|
ELEMENT_NODE = 1,
|
|
|
|
ATTRIBUTE_NODE = 2,
|
|
|
|
TEXT_NODE = 3,
|
|
|
|
CDATA_SELECTION_NODE = 4,
|
|
|
|
ENTITY_REFERENCE_NODE = 5,
|
|
|
|
ENTITY_NODE = 6,
|
|
|
|
PROCESSING_INSTRUCTION_NODE = 7,
|
|
|
|
COMMENT_NODE = 8,
|
|
|
|
DOCUMENT_NODE = 9,
|
|
|
|
DOCUMENT_TYPE_NODE = 10,
|
|
|
|
DOCUMENT_FRAGMENT_NODE = 11,
|
|
|
|
NOTATION_NODE = 12
|
|
|
|
};
|
|
|
|
|
2013-05-19 21:21:20 +00:00
|
|
|
enum {
|
|
|
|
DOCUMENT_POSITION_DISCONNECTED = 1,
|
|
|
|
DOCUMENT_POSITION_PRECEDING = 2,
|
|
|
|
DOCUMENT_POSITION_FOLLOWING = 4,
|
|
|
|
DOCUMENT_POSITION_CONTAINS = 8,
|
|
|
|
DOCUMENT_POSITION_CONTAINED_BY = 16,
|
|
|
|
DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32
|
|
|
|
};
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetNodeName(nsAString *aNodeName);
|
|
|
|
nsresult GetNodeValue(nsAString *aNodeValue);
|
|
|
|
nsresult SetNodeValue(const nsAString *aNodeValue);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetNodeType(uint16_t *aNodeType);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetParentNode(nsIDOMNode **aParentNode);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetParentElement(nsIDOMElement **aParentElement);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetChildNodes(nsIDOMNodeList **aChildNodes);
|
|
|
|
nsresult GetFirstChild(nsIDOMNode **aFirstChild);
|
|
|
|
nsresult GetLastChild(nsIDOMNode **aLastChild);
|
|
|
|
nsresult GetPreviousSibling(nsIDOMNode **aPreviousSibling);
|
|
|
|
nsresult GetNextSibling(nsIDOMNode **aNextSibling);
|
|
|
|
nsresult GetOwnerDocument(nsIDOMDocument **aOwnerDocument);
|
|
|
|
nsresult InsertBefore(nsIDOMNode *newChild, nsIDOMNode *refChild, nsIDOMNode **_retval);
|
|
|
|
nsresult ReplaceChild(nsIDOMNode *newChild, nsIDOMNode *oldChild, nsIDOMNode **_retval);
|
|
|
|
nsresult RemoveChild(nsIDOMNode *oldChild, nsIDOMNode **_retval);
|
|
|
|
nsresult AppendChild(nsIDOMNode *newChild, nsIDOMNode **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult HasChildNodes(bool *_retval);
|
|
|
|
nsresult CloneNode(bool deep, uint8_t _argc, nsIDOMNode **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Normalize();
|
|
|
|
nsresult GetNamespaceURI(nsAString *aNamespaceURI);
|
|
|
|
nsresult GetPrefix(nsAString *aPrefix);
|
|
|
|
nsresult GetLocalName(nsAString *aLocalName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult HasAttributes(bool *_retval);
|
|
|
|
nsresult GetDOMBaseURI(nsAString *aBaseURI);
|
|
|
|
nsresult CompareDocumentPosition(nsIDOMNode *other, uint16_t *_retval);
|
|
|
|
nsresult GetTextContent(nsAString *aTextContent);
|
|
|
|
nsresult SetTextContent(const nsAString *aTextContent);
|
|
|
|
nsresult LookupPrefix(const nsAString *namespaceURI, nsAString *_retval);
|
|
|
|
nsresult IsDefaultNamespace(const nsAString *namespaceURI, bool *_retval);
|
|
|
|
nsresult LookupNamespaceURI(const nsAString *prefix, nsAString *_retval);
|
|
|
|
nsresult IsEqualNode(nsIDOMNode *arg, bool *_retval);
|
|
|
|
nsresult SetUserData(const nsAString *key, nsIVariant *data, nsIDOMUserDataHandler *handler, nsIVariant **_retval);
|
|
|
|
nsresult GetUserData(const nsAString *key, nsIVariant **_retval);
|
|
|
|
nsresult Contains(nsIDOMNode *aOther, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetMshtmlNode(nsISupports **aMshtmlNode);
|
|
|
|
nsresult SetMshtmlNode(nsISupports *aMshtmlNode);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(a974a4d3-2ff1-445b-8b8e-0aada5d4eedc),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
2013-05-19 21:21:20 +00:00
|
|
|
interface nsIDOMAttr : nsIDOMNode
|
2008-04-11 12:45:31 +00:00
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult GetSpecified(bool *aSpecified);
|
|
|
|
nsresult GetValue(nsAString *aValue);
|
|
|
|
nsresult SetValue(const nsAString *aValue);
|
|
|
|
nsresult GetOwnerElement(nsIDOMElement **aOwnerElement);
|
|
|
|
nsresult GetIsId(bool *aIsId);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(b2f824c4-d9d3-499b-8d3b-45c8245497c6),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMClientRect : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetLeft(float *aLeft);
|
|
|
|
nsresult GetTop(float *aTop);
|
|
|
|
nsresult GetRight(float *aRight);
|
|
|
|
nsresult GetBottom(float *aBottom);
|
|
|
|
nsresult GetWidth(float *aWidth);
|
|
|
|
nsresult GetHeight(float *aHeight);
|
|
|
|
}
|
|
|
|
|
2009-02-04 14:35:06 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(43d985da-b7ee-4d1f-a26f-348ccd9506f3),
|
2009-02-04 14:35:06 +00:00
|
|
|
local
|
|
|
|
]
|
2013-05-19 21:21:20 +00:00
|
|
|
interface nsIDOMElement : nsIDOMNode
|
2009-02-04 14:35:06 +00:00
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetTagName(nsAString *aTagName);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetClassList(nsISupports **aClassList);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetAttributes(nsIDOMMozNamedAttrMap **aAttributes);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAttribute(const nsAString *name, nsAString *_retval);
|
|
|
|
nsresult GetAttributeNS(const nsAString *namespaceURI, const nsAString *localName, nsAString *_retval);
|
|
|
|
nsresult SetAttribute(const nsAString *name, const nsAString *value);
|
|
|
|
nsresult SetAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName, const nsAString *value);
|
|
|
|
nsresult RemoveAttribute(const nsAString *name);
|
|
|
|
nsresult RemoveAttributeNS(const nsAString *namespaceURI, const nsAString *localName);
|
|
|
|
nsresult HasAttribute(const nsAString *name, bool *_retval);
|
|
|
|
nsresult HasAttributeNS(const nsAString *namespaceURI, const nsAString *localName, bool *_retval);
|
|
|
|
nsresult GetAttributeNode(const nsAString *name, nsIDOMAttr **_retval);
|
|
|
|
nsresult SetAttributeNode(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
|
|
|
|
nsresult RemoveAttributeNode(nsIDOMAttr *oldAttr, nsIDOMAttr **_retval);
|
|
|
|
nsresult GetAttributeNodeNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
|
|
|
|
nsresult SetAttributeNodeNS(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetElementsByTagName(const nsAString *name, nsIDOMHTMLCollection **_retval);
|
|
|
|
nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMHTMLCollection **_retval);
|
|
|
|
nsresult GetElementsByClassName(const nsAString *classes, nsIDOMHTMLCollection **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetChildElements(nsIDOMNodeList **aChildren);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetFirstElementChild(nsIDOMElement **aFirstElementChild);
|
|
|
|
nsresult GetLastElementChild(nsIDOMElement **aLastElementChild);
|
|
|
|
nsresult GetPreviousElementSibling(nsIDOMElement **aPreviousElementSibling);
|
|
|
|
nsresult GetNextElementSibling(nsIDOMElement **aNextElementSibling);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetChildElementCount(uint32_t *aChildElementCount);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult Remove();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetOnmouseenter(JSContext *cx, jsval *aOnmouseenter);
|
|
|
|
nsresult SetOnmouseenter(JSContext *cx, const jsval *aOnmouseenter);
|
|
|
|
nsresult GetOnmouseleave(JSContext *cx, jsval *aOnmouseleave);
|
|
|
|
nsresult SetOnmouseleave(JSContext *cx, const jsval *aOnmouseleave);
|
|
|
|
nsresult GetClientRects(nsIDOMClientRectList **_retval);
|
|
|
|
nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
|
|
|
|
nsresult GetScrollTop(int32_t *aScrollTop);
|
|
|
|
nsresult SetScrollTop(int32_t aScrollTop);
|
|
|
|
nsresult GetScrollLeft(int32_t *aScrollLeft);
|
|
|
|
nsresult SetScrollLeft(int32_t aScrollLeft);
|
|
|
|
nsresult GetScrollWidth(int32_t *aScrollWidth);
|
|
|
|
nsresult GetScrollHeight(int32_t *aScrollHeight);
|
|
|
|
nsresult GetClientTop(int32_t *aClientTop);
|
|
|
|
nsresult GetClientLeft(int32_t *aClientLeft);
|
|
|
|
nsresult GetClientWidth(int32_t *aClientWidth);
|
|
|
|
nsresult GetClientHeight(int32_t *aClientHeight);
|
|
|
|
nsresult GetScrollLeftMax(int32_t *aScrollLeftMax);
|
|
|
|
nsresult GetScrollTopMax(int32_t *aScrollTopMax);
|
|
|
|
nsresult MozMatchesSelector(const nsAString *selector, bool *_retval);
|
|
|
|
nsresult SetCapture(bool retargetToElement);
|
|
|
|
nsresult ReleaseCapture();
|
|
|
|
nsresult MozRequestFullScreen();
|
|
|
|
nsresult MozRequestPointerLock();
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(99715845-95fc-4a56-aa53-214b65c26e22),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMElementCSSInlineStyle : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetStyle(nsIDOMCSSStyleDeclaration **aStyle);
|
2009-02-04 14:35:06 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
cpp_quote("#undef GetClassName")
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(e29ddc73-ac40-40fe-8bbd-14bf2d52c53a),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLElement : nsIDOMElement
|
|
|
|
{
|
|
|
|
nsresult GetId(nsAString *aId);
|
|
|
|
nsresult SetId(const nsAString *aId);
|
|
|
|
nsresult GetTitle(nsAString *aTitle);
|
|
|
|
nsresult SetTitle(const nsAString *aTitle);
|
|
|
|
nsresult GetLang(nsAString *aLang);
|
|
|
|
nsresult SetLang(const nsAString *aLang);
|
|
|
|
nsresult GetDir(nsAString *aDir);
|
|
|
|
nsresult SetDir(const nsAString *aDir);
|
|
|
|
nsresult GetClassName(nsAString *aClassName);
|
|
|
|
nsresult SetClassName(const nsAString *aClassName);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetDataset(nsISupports **aDataset);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetItemScope(bool *aItemScope);
|
|
|
|
nsresult SetItemScope(bool aItemScope);
|
|
|
|
nsresult GetItemType(nsIVariant **aItemType);
|
|
|
|
nsresult SetItemType(nsIVariant *aItemType);
|
|
|
|
nsresult GetItemId(nsAString *aItemId);
|
|
|
|
nsresult SetItemId(const nsAString *aItemId);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetProperties(nsISupports **aProperties);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetItemValue(nsIVariant **aItemValue);
|
|
|
|
nsresult SetItemValue(nsIVariant *aItemValue);
|
|
|
|
nsresult GetItemProp(nsIVariant **aItemProp);
|
|
|
|
nsresult SetItemProp(nsIVariant *aItemProp);
|
|
|
|
nsresult GetItemRef(nsIVariant **aItemRef);
|
|
|
|
nsresult SetItemRef(nsIVariant *aItemRef);
|
|
|
|
nsresult GetHidden(bool *aHidden);
|
|
|
|
nsresult SetHidden(bool aHidden);
|
|
|
|
nsresult Click();
|
|
|
|
nsresult GetTabIndex(int32_t *aTabIndex);
|
|
|
|
nsresult SetTabIndex(int32_t aTabIndex);
|
|
|
|
nsresult Focus();
|
|
|
|
nsresult Blur();
|
|
|
|
nsresult GetAccessKey(nsAString *aAccessKey);
|
|
|
|
nsresult SetAccessKey(const nsAString *aAccessKey);
|
|
|
|
nsresult GetAccessKeyLabel(nsAString *aAccessKeyLabel);
|
|
|
|
nsresult GetDraggable(bool *aDraggable);
|
|
|
|
nsresult SetDraggable(bool aDraggable);
|
|
|
|
nsresult GetContentEditable(nsAString *aContentEditable);
|
|
|
|
nsresult SetContentEditable(const nsAString *aContentEditable);
|
|
|
|
nsresult GetIsContentEditable(bool *aIsContentEditable);
|
|
|
|
nsresult GetContextMenu(nsIDOMHTMLMenuElement **aContextMenu);
|
|
|
|
nsresult GetSpellcheck(bool *aSpellcheck);
|
|
|
|
nsresult SetSpellcheck(bool aSpellcheck);
|
|
|
|
nsresult GetInnerHTML(nsAString *aInnerHTML);
|
|
|
|
nsresult SetInnerHTML(const nsAString *aInnerHTML);
|
|
|
|
nsresult GetOuterHTML(nsAString *aInnerHTML);
|
|
|
|
nsresult SetOuterHTML(const nsAString *aInnerHTML);
|
|
|
|
nsresult InsertAdjacentHTML(const nsAString *position, const nsAString *text);
|
|
|
|
nsresult ScrollIntoView(bool top, uint8_t _argc);
|
|
|
|
nsresult GetOffsetParent(nsIDOMElement * *aOffsetParent);
|
|
|
|
nsresult GetOffsetTop(int32_t *aOffsetTop);
|
|
|
|
nsresult GetOffsetLeft(int32_t *aOffsetLeft);
|
|
|
|
nsresult GetOffsetWidth(int32_t *aOffsetWidth);
|
|
|
|
nsresult GetOffsetHeight(int32_t *aOffsetHeight);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(889602bb-4681-4b01-8582-4fad1fbb8325),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
2013-05-19 21:21:20 +00:00
|
|
|
interface nsIDOMHTMLHeadElement : nsIDOMHTMLElement
|
2008-04-11 12:45:31 +00:00
|
|
|
{
|
2009-02-04 14:35:06 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(84f72a38-1873-46f8-937c-1df22d7e7cae),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMCharacterData : nsIDOMNode
|
|
|
|
{
|
|
|
|
nsresult GetData(nsAString *aData);
|
|
|
|
nsresult SetData(const nsAString *aData);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult SubstringData(uint32_t offset, uint32_t count, nsAString *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult AppendData(const nsAString *arg);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InsertData(uint32_t offset, const nsAString *arg);
|
|
|
|
nsresult DeleteData(uint32_t offset, uint32_t count);
|
|
|
|
nsresult ReplaceData(uint32_t offset, uint32_t count, const nsAString *arg);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult Remove();
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(d14d13b4-21d5-49e2-8d59-76a24156db54),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMText : nsIDOMCharacterData
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SplitText(uint32_t offset, nsIDOMText **_retval);
|
|
|
|
nsresult GetWholeText(nsAString *aWholeText);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(e702a5d2-3aa8-4788-b048-2d3b3e6d16f2),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMComment : nsIDOMCharacterData
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(33127aed-9d6a-4b0d-95aa-0529f51bcb9c),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMDocumentFragment : nsIDOMNode
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-02-04 14:35:06 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(75996de6-6b0f-43e5-ae79-c98fa669da9a),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMDocument : nsIDOMNode
|
|
|
|
{
|
|
|
|
nsresult GetDoctype(nsIDOMDocumentType **aDoctype);
|
|
|
|
nsresult GetImplementation(nsIDOMDOMImplementation **aImplementation);
|
|
|
|
nsresult GetDocumentElement(nsIDOMElement **aDocumentElement);
|
|
|
|
nsresult CreateElement(const nsAString *tagName, nsIDOMElement **_retval);
|
|
|
|
nsresult CreateDocumentFragment(nsIDOMDocumentFragment **_retval);
|
|
|
|
nsresult CreateTextNode(const nsAString *data, nsIDOMText **_retval);
|
|
|
|
nsresult CreateComment(const nsAString *data, nsIDOMComment **_retval);
|
|
|
|
nsresult CreateCDATASection(const nsAString *data, nsIDOMCDATASection **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult CreateProcessingInstruction(const nsAString *target, const nsAString *data, nsIDOMProcessingInstruction **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult CreateAttribute(const nsAString *name, nsIDOMAttr **_retval);
|
|
|
|
nsresult GetElementsByTagName(const nsAString *tagname, nsIDOMNodeList **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult ImportNode(nsIDOMNode *importedNode, bool deep, uint8_t _argc, nsIDOMNode **_retval);
|
|
|
|
nsresult CreateElementNS(const nsAString *namespaceURI, const nsAString *qualifiedName, nsIDOMElement **_retval);
|
|
|
|
nsresult CreateAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName, nsIDOMAttr **_retval);
|
|
|
|
nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMNodeList **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetElementById(const nsAString *elementId, nsIDOMElement **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetInputEncoding(nsAString *aInputEncoding);
|
|
|
|
nsresult GetDocumentURI(nsAString *aDocumentURI);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetURL(nsAString *aURL);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult AdoptNode(nsIDOMNode *source, nsIDOMNode **_retval);
|
|
|
|
nsresult CreateRange(nsIDOMRange **_retval);
|
|
|
|
nsresult CreateNodeIterator(nsIDOMNode *root, uint32_t whatToShow, nsIDOMNodeFilter *filter, uint8_t _argc,
|
|
|
|
nsIDOMNodeIterator **_retval);
|
|
|
|
nsresult CreateTreeWalker(nsIDOMNode *root, uint32_t whatToShow, nsIDOMNodeFilter *filter, uint8_t _argc,
|
|
|
|
nsIDOMTreeWalker **_retval);
|
|
|
|
cpp_quote("#undef CreateEvent")
|
|
|
|
nsresult CreateEvent(const nsAString *eventType, nsIDOMEvent **_retval);
|
|
|
|
nsresult GetDefaultView(nsIDOMWindow **aDefaultView);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetCharacterSet(nsAString *aCharacterSet);
|
|
|
|
nsresult GetDir(nsAString *aDir);
|
|
|
|
nsresult SetDir(const nsAString *aDir);
|
|
|
|
nsresult GetLocation(nsIDOMLocation **aLocation);
|
|
|
|
nsresult GetTitle(nsAString *aTitle);
|
|
|
|
nsresult SetTitle(const nsAString *aTitle);
|
2009-08-09 12:00:11 +00:00
|
|
|
nsresult GetReadyState(nsAString *aReadyState);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetLastModified(nsAString *aLastModified);
|
|
|
|
nsresult GetReferrer(nsAString *aReferrer);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult HasFocus(bool *_retval);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetActiveElement(nsIDOMElement **aActiveElement);
|
|
|
|
nsresult GetElementsByClassName(const nsAString *classes, nsIDOMNodeList **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetStyleSheets(nsIDOMStyleSheetList **aStyleSheets);
|
|
|
|
nsresult GetPreferredStyleSheetSet(nsAString *aPreferredStyleSheetSet);
|
|
|
|
nsresult GetSelectedStyleSheetSet(nsAString *aSelectedStyleSheetSet);
|
|
|
|
nsresult SetSelectedStyleSheetSet(const nsAString *aSelectedStyleSheetSet);
|
|
|
|
nsresult GetLastStyleSheetSet(nsAString *aLastStyleSheetSet);
|
|
|
|
nsresult GetStyleSheetSets(nsIDOMDOMStringList **aStyleSheetSets);
|
|
|
|
nsresult EnableStyleSheetsForSet(const nsAString *name);
|
|
|
|
nsresult ElementFromPoint(float x, float y, nsIDOMElement **_retval);
|
|
|
|
nsresult GetContentType(nsAString *aContentType);
|
|
|
|
nsresult GetMozSyntheticDocument(bool *aMozSyntheticDocument);
|
|
|
|
nsresult GetCurrentScript(nsIDOMElement **aCurrentScript);
|
|
|
|
nsresult ReleaseCapture();
|
|
|
|
nsresult MozSetImageElement(const nsAString *aImageElementId, nsIDOMElement *aImageElement);
|
|
|
|
nsresult GetMozFullScreenElement(nsIDOMElement **aMozFullScreenElement);
|
|
|
|
nsresult MozCancelFullScreen();
|
|
|
|
nsresult GetMozFullScreen(bool *aMozFullScreen);
|
|
|
|
nsresult GetMozFullScreenEnabled(bool *aMozFullScreenEnabled);
|
|
|
|
nsresult GetMozPointerLockElement(nsIDOMElement **aMozPointerLockElement);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult CaretPositionFromPoint(float x, float y, nsISupports **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult MozExitPointerLock();
|
|
|
|
nsresult GetOnreadystatechange(JSContext* cx, jsval aOnreadystatechange);
|
|
|
|
nsresult SetOnreadystatechange(JSContext* cx, const jsval *aOnreadystatechange);
|
|
|
|
nsresult GetOnmouseenter(JSContext* cx, jsval *aOnmouseenter);
|
|
|
|
nsresult SetOnmouseenter(JSContext* cx, const jsval *aOnmouseenter);
|
|
|
|
nsresult GetOnmouseleave(JSContext* cx, jsval *aOnmouseleave) = 0;
|
|
|
|
nsresult SetOnmouseleave(JSContext* cx, const jsval *aOnmouseleave);
|
|
|
|
nsresult GetHidden(bool *aHidden);
|
|
|
|
nsresult GetMozHidden(bool *aMozHidden);
|
|
|
|
nsresult GetVisibilityState(nsAString *aVisibilityState);
|
|
|
|
nsresult GetMozVisibilityState(nsAString *aMozVisibilityState);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetCompatMode(nsAString *aCompatMode);
|
2009-02-04 14:35:06 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(fd76e045-8d97-4a97-ad75-eac5ae2f3ea4),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLDocument : nsIDOMDocument
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDomain(nsAString *aDomain);
|
|
|
|
nsresult SetDomain(const nsAString *aDomain);
|
|
|
|
nsresult GetCookie(nsAString *aCookie);
|
|
|
|
nsresult SetCookie(const nsAString *aCookie);
|
|
|
|
nsresult GetHead(nsIDOMHTMLHeadElement **aHead);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetBody(nsIDOMHTMLElement **aBody);
|
|
|
|
nsresult SetBody(nsIDOMHTMLElement *aBody);
|
|
|
|
nsresult GetImages(nsIDOMHTMLCollection **aImages);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetEmbeds(nsIDOMHTMLCollection **aEmbeds);
|
|
|
|
nsresult GetPlugins(nsIDOMHTMLCollection **aPlugins);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetLinks(nsIDOMHTMLCollection **aLinks);
|
|
|
|
nsresult GetForms(nsIDOMHTMLCollection **aForms);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetScripts(nsIDOMHTMLCollection **aScripts);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetElementsByName(const nsAString *elementName, nsIDOMNodeList **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetItems(const nsAString *types, nsIDOMNodeList **_retval);
|
|
|
|
nsresult Open(const nsAString *aContentTypeOrUrl, const nsAString *aReplaceOrName, const nsAString *aFeatures,
|
|
|
|
JSContext *cx, uint8_t _argc, nsISupports **_retval);
|
|
|
|
nsresult Close();
|
|
|
|
nsresult Write(const nsAString *text, JSContext *cx);
|
|
|
|
nsresult Writeln(const nsAString *text, JSContext *cx);
|
|
|
|
nsresult GetDesignMode(nsAString *aDesignMode);
|
|
|
|
nsresult SetDesignMode(const nsAString *aDesignMode);
|
|
|
|
nsresult ExecCommand(const nsAString *commandID, bool doShowUI, const nsAString *value, bool *_retval);
|
|
|
|
nsresult QueryCommandEnabled(const nsAString *commandID, bool *_retval);
|
|
|
|
nsresult QueryCommandIndeterm(const nsAString *commandID, bool *_retval);
|
|
|
|
nsresult QueryCommandState(const nsAString *commandID, bool *_retval);
|
|
|
|
nsresult QueryCommandSupported(const nsAString *commandID, bool *_retval);
|
|
|
|
nsresult QueryCommandValue(const nsAString *commandID, nsAString *_retval);
|
|
|
|
nsresult GetFgColor(nsAString *aFgColor);
|
|
|
|
nsresult SetFgColor(const nsAString *aFgColor);
|
|
|
|
nsresult GetBgColor(nsAString *aBgColor);
|
|
|
|
nsresult SetBgColor(const nsAString *aBgColor);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetLinkColor(nsAString *aLinkColor);
|
|
|
|
nsresult SetLinkColor(const nsAString *aLinkColor);
|
|
|
|
nsresult GetVlinkColor(nsAString *aVlinkColor);
|
|
|
|
nsresult SetVlinkColor(const nsAString *aVlinkColor);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAlinkColor(nsAString *aAlinkColor);
|
|
|
|
nsresult SetAlinkColor(const nsAString *aAlinkColor);
|
|
|
|
nsresult GetAnchors(nsIDOMHTMLCollection **aAnchors);
|
|
|
|
nsresult GetApplets(nsIDOMHTMLCollection **aApplets);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Clear();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetSelection(nsISelection **_retval);
|
|
|
|
nsresult CaptureEvents(int32_t eventFlags);
|
|
|
|
nsresult ReleaseEvents(int32_t eventFlags);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult RouteEvent(nsIDOMEvent *evt);
|
2009-11-15 23:44:20 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(1f94055c-42e7-4a30-96a1-6a804f1c2d1e),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMRange : nsISupports
|
|
|
|
{
|
|
|
|
enum {
|
|
|
|
NS_START_TO_START,
|
|
|
|
NS_START_TO_END,
|
|
|
|
NS_END_TO_END,
|
|
|
|
NS_END_TO_START
|
|
|
|
};
|
|
|
|
|
|
|
|
nsresult GetStartContainer(nsIDOMNode **aStartContainer);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetStartOffset(int32_t *aStartOffset);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetEndContainer(nsIDOMNode **aEndContainer);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetEndOffset(int32_t *aEndOffset);
|
|
|
|
nsresult GetCollapsed(bool *aCollapsed);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetCommonAncestorContainer(nsIDOMNode **aCommonAncestorContainer);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetStart(nsIDOMNode *refNode, int32_t offset);
|
|
|
|
nsresult SetEnd(nsIDOMNode *refNode, int32_t offset);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SetStartBefore(nsIDOMNode *refNode);
|
|
|
|
nsresult SetStartAfter(nsIDOMNode *refNode);
|
|
|
|
nsresult SetEndBefore(nsIDOMNode *refNode);
|
|
|
|
nsresult SetEndAfter(nsIDOMNode *refNode);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Collapse(bool toStart);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SelectNode(nsIDOMNode *refNode);
|
|
|
|
nsresult SelectNodeContents(nsIDOMNode *refNode);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult CompareBoundaryPoints(uint16_t how, nsIDOMRange *sourceRange, int16_t *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult DeleteContents();
|
|
|
|
nsresult ExtractContents(nsIDOMDocumentFragment **_retval);
|
|
|
|
nsresult CloneContents(nsIDOMDocumentFragment **_retval);
|
|
|
|
nsresult InsertNode(nsIDOMNode *newNode);
|
|
|
|
nsresult SurroundContents(nsIDOMNode *newParent);
|
|
|
|
nsresult CloneRange(nsIDOMRange **_retval);
|
|
|
|
nsresult ToString(nsAString *_retval);
|
|
|
|
nsresult Detach();
|
|
|
|
nsresult CreateContextualFragment([in] const nsAString *fragment, [out] nsIDOMDocumentFragment **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult IsPointInRange([in] nsIDOMNode *parent, [in] int32_t offset, [out] bool *_retval);
|
|
|
|
nsresult ComparePoint([in] nsIDOMNode *parent, [in] int32_t offset, [out] int16_t *_retval);
|
|
|
|
nsresult IntersectsNode(nsIDOMNode *node, bool *_retval);
|
|
|
|
nsresult GetClientRects(nsIDOMClientRectList **_retval);
|
|
|
|
nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(12cf5a4d-fffb-4f2f-9cec-c65195661d76),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsISelection : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetAnchorNode(nsIDOMNode **aAnchorNode);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAnchorOffset(int32_t *aAnchorOffset);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetFocusNode(nsIDOMNode **aFocusNode);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetFocusOffset(int32_t *aFocusOffset);
|
|
|
|
nsresult GetIsCollapsed(bool *aIsCollapsed);
|
|
|
|
bool /* don't use */ Collapsed();
|
|
|
|
nsresult GetRangeCount(int32_t *aRangeCount);
|
|
|
|
nsresult GetRangeAt(int32_t index, nsIDOMRange **_retval);
|
|
|
|
nsresult Collapse(nsIDOMNode *parentNode, int32_t offset);
|
|
|
|
nsresult CollapseNative(nsINode *parentNode, int32_t offset);
|
|
|
|
nsresult Extend(nsIDOMNode *parentNode, int32_t offset);
|
|
|
|
nsresult ExtendNative(nsINode *parentNode, int32_t offset);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult CollapseToStart();
|
|
|
|
nsresult CollapseToEnd();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult ContainsNode(nsIDOMNode *node, bool entirelyContained, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SelectAllChildren(nsIDOMNode *parentNode);
|
|
|
|
nsresult AddRange(nsIDOMRange *range);
|
|
|
|
nsresult RemoveRange(nsIDOMRange *range);
|
|
|
|
nsresult RemoveAllRanges();
|
|
|
|
nsresult DeleteFromDocument();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SelectionLanguageChange(bool langRTL);
|
|
|
|
nsresult ToString(nsAString *_retval);
|
|
|
|
nsresult Modify(const nsAString *alter, const nsAString *direction, const nsAString *granularity);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
2009-11-15 23:44:20 +00:00
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(a6cf906f-15b3-11d2-932e-00805f8add32),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMWindowCollection : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult Item(uint32_t index, nsIDOMWindow **_retval);
|
2009-11-15 23:44:20 +00:00
|
|
|
nsresult NamedItem(const nsAString *name, nsIDOMWindow **_retval);
|
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(be62660a-e3f6-409c-a4a9-378364a9526f),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMWindow : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetWindow(nsIDOMWindow **aWindow);
|
|
|
|
nsresult GetSelf(nsIDOMWindow **aSelf);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetDocument(nsIDOMDocument **aDocument);
|
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetLocation(nsIDOMLocation **aLocation);
|
|
|
|
nsresult GetHistory(nsIDOMHistory **aHistory);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetLocationbar(nsISupports **aLocationbar);
|
|
|
|
nsresult GetMenubar(nsISupports **aMenubar);
|
|
|
|
nsresult GetPersonalbar(nsISupports **aPersonalbar);
|
|
|
|
nsresult GetScrollbars(nsISupports **aScrollbars);
|
|
|
|
nsresult GetStatusbar(nsISupports **aStatusbar);
|
|
|
|
nsresult GetToolbar(nsISupports **aToolbar);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetStatus(nsAString *aStatus);
|
|
|
|
nsresult SetStatus(const nsAString *aStatus);
|
|
|
|
nsresult Close();
|
|
|
|
nsresult Stop();
|
|
|
|
nsresult Focus();
|
|
|
|
nsresult Blur();
|
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult GetScriptableTop(nsIDOMWindow **aTop);
|
|
|
|
nsresult GetRealTop(nsIDOMWindow **aTop);
|
|
|
|
nsresult GetScriptableParent(nsIDOMWindow **aParent);
|
|
|
|
nsresult GetRealParent(nsIDOMWindow **aParent);
|
|
|
|
nsresult GetOpener(nsIDOMWindow **aOpener);
|
|
|
|
nsresult SetOpener(nsIDOMWindow *aOpener);
|
|
|
|
nsresult GetScriptableFrameElement(nsIDOMElement **aFrameElement);
|
|
|
|
nsresult GetRealFrameElement(nsIDOMElement **aFrameElement);
|
|
|
|
nsresult GetNavigator(nsIDOMNavigator **aNavigator);
|
|
|
|
nsresult GetApplicationCache(nsIDOMOfflineResourceList **aApplicationCache);
|
|
|
|
nsresult Alert(const nsAString *text);
|
|
|
|
nsresult Confirm(const nsAString *text, bool *_retval);
|
|
|
|
nsresult Prompt(const nsAString *aMessage, const nsAString *aInitial, nsAString *_retval);
|
|
|
|
nsresult Print();
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult ShowModalDialog(const nsAString *aURI, nsIVariant *aArgs, const nsAString *aOptions, uint8_t _argc, nsIVariant **_retval);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult PostMessageMoz(const long /*jsval*/ *message, const nsAString *targetOrigin, const /*JS::Value*/ void *transfer, JSContext *cx);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Atob(const nsAString *aAsciiString, nsAString *_retval);
|
|
|
|
nsresult Btoa(const nsAString *aBase64Data, nsAString *_retval);
|
|
|
|
nsresult GetSessionStorage(nsIDOMStorage **aSessionStorage);
|
|
|
|
nsresult GetLocalStorage(nsIDOMStorage **aLocalStorage);
|
|
|
|
nsresult GetSelection(nsISelection **_retval);
|
|
|
|
nsresult MatchMedia(const nsAString *media_query_list, nsIDOMMediaQueryList **_retval);
|
|
|
|
nsresult GetScreen(nsIDOMScreen **aScreen);
|
|
|
|
nsresult GetInnerWidth(int32_t *aInnerWidth);
|
|
|
|
nsresult SetInnerWidth(int32_t aInnerWidth);
|
|
|
|
nsresult GetInnerHeight(int32_t *aInnerHeight);
|
|
|
|
nsresult SetInnerHeight(int32_t aInnerHeight);
|
|
|
|
nsresult GetScrollX(int32_t *aScrollX);
|
|
|
|
nsresult GetPageXOffset(int32_t *aPageXOffset);
|
|
|
|
nsresult GetScrollY(int32_t *aScrollY);
|
|
|
|
nsresult GetPageYOffset(int32_t *aPageYOffset);
|
|
|
|
nsresult Scroll(int32_t xScroll, int32_t yScroll);
|
|
|
|
nsresult ScrollTo(int32_t xScroll, int32_t yScroll);
|
|
|
|
nsresult ScrollBy(int32_t xScrollDif, int32_t yScrollDif);
|
|
|
|
nsresult GetScreenX(int32_t *aScreenX);
|
|
|
|
nsresult SetScreenX(int32_t aScreenX);
|
|
|
|
nsresult GetScreenY(int32_t *aScreenY);
|
|
|
|
nsresult SetScreenY(int32_t aScreenY);
|
|
|
|
nsresult GetOuterWidth(int32_t *aOuterWidth);
|
|
|
|
nsresult SetOuterWidth(int32_t aOuterWidth);
|
|
|
|
nsresult GetOuterHeight(int32_t *aOuterHeight);
|
|
|
|
nsresult SetOuterHeight(int32_t aOuterHeight);
|
|
|
|
nsresult GetComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetDefaultComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetWindowRoot(nsIDOMEventTarget **aWindowRoot);
|
|
|
|
nsresult GetFrames(nsIDOMWindowCollection **aFrames);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetTextZoom(float *aTextZoom);
|
|
|
|
nsresult SetTextZoom(float aTextZoom);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult ScrollByLines(int32_t numLines);
|
|
|
|
nsresult ScrollByPages(int32_t numPages);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SizeToContent();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetContent(nsIDOMWindow **aContent);
|
|
|
|
nsresult GetPrompter(nsIPrompt **aPrompter);
|
|
|
|
nsresult GetClosed(bool *aClosed);
|
|
|
|
nsresult GetCrypto(nsIDOMCrypto **aCrypto);
|
|
|
|
nsresult GetPkcs11(nsIDOMPkcs11 **aPkcs11);
|
|
|
|
nsresult GetControllers(nsIControllers **aControllers);
|
|
|
|
nsresult GetMozInnerScreenX(float *aMozInnerScreenX);
|
|
|
|
nsresult GetMozInnerScreenY(float *aMozInnerScreenY);
|
|
|
|
nsresult GetDevicePixelRatio(float *aDevicePixelRatio);
|
|
|
|
nsresult GetScrollMaxX(int32_t *aScrollMaxX);
|
|
|
|
nsresult GetScrollMaxY(int32_t *aScrollMaxY);
|
|
|
|
nsresult GetFullScreen(bool *aFullScreen);
|
|
|
|
nsresult SetFullScreen(bool aFullScreen);
|
|
|
|
nsresult Back();
|
|
|
|
nsresult Forward();
|
|
|
|
nsresult Home();
|
|
|
|
nsresult MoveTo(int32_t xPos, int32_t yPos);
|
|
|
|
nsresult MoveBy(int32_t xDif, int32_t yDif);
|
|
|
|
nsresult ResizeTo(int32_t width, int32_t height);
|
|
|
|
nsresult ResizeBy(int32_t widthDif, int32_t heightDif);
|
|
|
|
nsresult Open(const nsAString *url, const nsAString *name, const nsAString *options, nsIDOMWindow **_retval);
|
|
|
|
nsresult OpenDialog(const nsAString *url, const nsAString *name, const nsAString *options, nsISupports *aExtraArgument,
|
|
|
|
nsIDOMWindow **_retval);
|
|
|
|
nsresult UpdateCommands(const nsAString *action);
|
|
|
|
nsresult Find(const nsAString *str, bool caseSensitive, bool backwards, bool wrapAround, bool wholeWord,
|
|
|
|
bool searchInFrames, bool showDialog, bool *_retval);
|
|
|
|
nsresult GetMozPaintCount(uint64_t *aMozPaintCount);
|
|
|
|
nsresult MozRequestAnimationFrame(nsIFrameRequestCallback *aCallback, int32_t *_retval);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult RequestAnimationFrame(void /*const JS::Value*/ *aCallback, JSContext* cx, int32_t *_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult MozCancelAnimationFrame(int32_t aHandle);
|
|
|
|
nsresult MozCancelRequestAnimationFrame(int32_t aHandle);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult CancelAnimationFrame(int32_t aHandle);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetMozAnimationStartTime(int64_t *aMozAnimationStartTime);
|
|
|
|
nsresult GetOnafterprint(JSContext *cx, jsval *aOnafterprint);
|
|
|
|
nsresult SetOnafterprint(JSContext *cx, const jsval *aOnafterprint);
|
|
|
|
nsresult GetOnbeforeprint(JSContext *cx, jsval *aOnbeforeprint);
|
|
|
|
nsresult SetOnbeforeprint(JSContext *cx, const jsval *aOnbeforeprint);
|
|
|
|
nsresult GetOnbeforeunload(JSContext *cx, jsval *aOnbeforeunload);
|
|
|
|
nsresult SetOnbeforeunload(JSContext *cx, const jsval *aOnbeforeunload);
|
|
|
|
nsresult GetOnhashchange(JSContext *cx, jsval *aOnhashchange);
|
|
|
|
nsresult SetOnhashchange(JSContext *cx, const jsval *aOnhashchange);
|
|
|
|
nsresult GetOnmessage(JSContext *cx, jsval *aOnmessage);
|
|
|
|
nsresult SetOnmessage(JSContext *cx, const jsval *aOnmessage);
|
|
|
|
nsresult GetOnoffline(JSContext *cx, jsval *aOnoffline);
|
|
|
|
nsresult SetOnoffline(JSContext *cx, const jsval *aOnoffline);
|
|
|
|
nsresult GetOnonline(JSContext *cx, jsval *aOnonline);
|
|
|
|
nsresult SetOnonline(JSContext *cx, const jsval *aOnonline);
|
|
|
|
nsresult GetOnpopstate(JSContext *cx, jsval *aOnpopstate);
|
|
|
|
nsresult SetOnpopstate(JSContext *cx, const jsval *aOnpopstate);
|
|
|
|
nsresult GetOnpagehide(JSContext *cx, jsval *aOnpagehide);
|
|
|
|
nsresult SetOnpagehide(JSContext *cx, const jsval *aOnpagehide);
|
|
|
|
nsresult GetOnpageshow(JSContext *cx, jsval *aOnpageshow);
|
|
|
|
nsresult SetOnpageshow(JSContext *cx, const jsval *aOnpageshow);
|
|
|
|
nsresult GetOnresize(JSContext *cx, jsval *aOnresize);
|
|
|
|
nsresult SetOnresize(JSContext *cx, const jsval *aOnresize);
|
|
|
|
nsresult GetOnunload(JSContext *cx, jsval *aOnunload);
|
|
|
|
nsresult SetOnunload(JSContext *cx, const jsval *aOnunload);
|
|
|
|
nsresult GetOndevicemotion(JSContext *cx, jsval *aOndevicemotion);
|
|
|
|
nsresult SetOndevicemotion(JSContext *cx, const jsval *aOndevicemotion);
|
|
|
|
nsresult GetOndeviceorientation(JSContext *cx, jsval *aOndeviceorientation);
|
|
|
|
nsresult SetOndeviceorientation(JSContext *cx, const jsval *aOndeviceorientation);
|
|
|
|
nsresult GetOndeviceproximity(JSContext* cx, jsval *aOndeviceproximity);
|
|
|
|
nsresult SetOndeviceproximity(JSContext* cx, const jsval *aOndeviceproximity);
|
|
|
|
nsresult GetOnuserproximity(JSContext* cx, jsval *aOndeviceproximity);
|
|
|
|
nsresult SetOnuserproximity(JSContext* cx, const jsval *aOndeviceproximity);
|
|
|
|
nsresult GetOndevicelight(JSContext* cx, jsval *aOndevicelight);
|
|
|
|
nsresult SetOndevicelight(JSContext* cx, const jsval *aOndevicelight);
|
|
|
|
nsresult GetOnmouseenter(JSContext* cx, jsval *aOnmouseenter);
|
|
|
|
nsresult SetOnmouseenter(JSContext* cx, const jsval *aOnmouseenter);
|
|
|
|
nsresult GetOnmouseleave(JSContext* cx, jsval *aOnmouseleave);
|
|
|
|
nsresult SetOnmouseleave(JSContext* cx, const jsval *aOnmouseleave);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(8b29a62f-b448-49f3-9242-241d5cf94ea9),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLBodyElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetALink(nsAString *aALink);
|
|
|
|
nsresult SetALink(const nsAString *aALink);
|
|
|
|
nsresult GetBackground(nsAString *aBackground);
|
|
|
|
nsresult SetBackground(const nsAString *aBackground);
|
|
|
|
nsresult GetBgColor(nsAString *aBgColor);
|
|
|
|
nsresult SetBgColor(const nsAString *aBgColor);
|
|
|
|
nsresult GetLink(nsAString *aLink);
|
|
|
|
nsresult SetLink(const nsAString *aLink);
|
|
|
|
nsresult GetText(nsAString *aText);
|
|
|
|
nsresult SetText(const nsAString *aText);
|
|
|
|
nsresult GetVLink(nsAString *aVLink);
|
|
|
|
nsresult SetVLink(const nsAString *aVLink);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetOnafterprint(JSContext *cx, jsval *aOnafterprint);
|
|
|
|
nsresult SetOnafterprint(JSContext *cx, const jsval *aOnafterprint);
|
|
|
|
nsresult GetOnbeforeprint(JSContext *cx, jsval *aOnbeforeprint);
|
|
|
|
nsresult SetOnbeforeprint(JSContext *cx, const jsval *aOnbeforeprint);
|
|
|
|
nsresult GetOnbeforeunload(JSContext *cx, jsval *aOnbeforeunload);
|
|
|
|
nsresult SetOnbeforeunload(JSContext *cx, const jsval *aOnbeforeunload);
|
|
|
|
nsresult GetOnhashchange(JSContext *cx, jsval *aOnhashchange);
|
|
|
|
nsresult SetOnhashchange(JSContext *cx, const jsval *aOnhashchange);
|
|
|
|
nsresult GetOnmessage(JSContext *cx, jsval *aOnmessage);
|
|
|
|
nsresult SetOnmessage(JSContext *cx, const jsval *aOnmessage);
|
|
|
|
nsresult GetOnoffline(JSContext *cx, jsval *aOnoffline);
|
|
|
|
nsresult SetOnoffline(JSContext *cx, const jsval *aOnoffline);
|
|
|
|
nsresult GetOnonline(JSContext *cx, jsval *aOnonline);
|
|
|
|
nsresult SetOnonline(JSContext *cx, const jsval *aOnonline);
|
|
|
|
nsresult GetOnpagehide(JSContext *cx, jsval *aOnpagehide);
|
|
|
|
nsresult SetOnpagehide(JSContext *cx, const jsval *aOnpagehide);
|
|
|
|
nsresult GetOnpageshow(JSContext *cx, jsval *aOnpageshow);
|
|
|
|
nsresult SetOnpageshow(JSContext *cx, const jsval *aOnpageshow);
|
|
|
|
nsresult GetOnpopstate(JSContext *cx, jsval *aOnpopstate);
|
|
|
|
nsresult SetOnpopstate(JSContext *cx, const jsval *aOnpopstate);
|
|
|
|
nsresult GetOnresize(JSContext *cx, jsval *aOnresize);
|
|
|
|
nsresult SetOnresize(JSContext *cx, const jsval *aOnresize);
|
|
|
|
nsresult GetOnunload(JSContext *cx, jsval *aOnunload);
|
|
|
|
nsresult SetOnunload(JSContext *cx, const jsval *aOnunload);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(5e49bff8-fb61-41e3-b6a9-2017865a6d74),
|
2010-01-18 16:27:14 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLFormElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetAcceptCharset(nsAString *aAcceptCharset);
|
|
|
|
nsresult SetAcceptCharset(const nsAString *aAcceptCharset);
|
|
|
|
nsresult GetAction(nsAString *aAction);
|
|
|
|
nsresult SetAction(const nsAString *aAction);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAutocomplete(nsAString *aAutocomplete);
|
|
|
|
nsresult SetAutocomplete(const nsAString *aAutocomplete);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetEnctype(nsAString *aEnctype);
|
|
|
|
nsresult SetEnctype(const nsAString *aEnctype);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetEncoding(nsAString *aEncoding);
|
|
|
|
nsresult SetEncoding(const nsAString *aEncoding);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetMethod(nsAString *aMethod);
|
|
|
|
nsresult SetMethod(const nsAString *aMethod);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
|
|
|
nsresult GetNoValidate(bool *aNoValidate);
|
|
|
|
nsresult SetNoValidate(bool aNoValidate);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetTarget(nsAString *aTarget);
|
|
|
|
nsresult SetTarget(const nsAString *aTarget);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetElements(nsIDOMHTMLCollection **aElements);
|
|
|
|
nsresult GetLength(int32_t *aLength);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult Submit();
|
|
|
|
nsresult Reset();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult CheckValidity(bool *_retval);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetFormData(nsIDOMHTMLElement *aOriginatingElement, nsAString *aActionURI, nsIInputStream **aPostDataStream);
|
2010-01-18 16:27:14 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(d57537ed-39d0-46ea-8516-0ce0a5bfb805),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLInputElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetAccept(nsAString *aAccept);
|
|
|
|
nsresult SetAccept(const nsAString *aAccept);
|
|
|
|
nsresult GetAlt(nsAString *aAlt);
|
|
|
|
nsresult SetAlt(const nsAString *aAlt);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAutocomplete(nsAString *aAutocomplete);
|
|
|
|
nsresult SetAutocomplete(const nsAString *aAutocomplete);
|
|
|
|
nsresult GetAutofocus(bool *aAutofocus);
|
|
|
|
nsresult SetAutofocus(bool aAutofocus);
|
|
|
|
nsresult GetDefaultChecked(bool *aDefaultChecked);
|
|
|
|
nsresult SetDefaultChecked(bool aDefaultChecked);
|
|
|
|
nsresult GetChecked(bool *aChecked);
|
|
|
|
nsresult SetChecked(bool aChecked);
|
|
|
|
nsresult GetDisabled(bool *aDisabled);
|
|
|
|
nsresult SetDisabled(bool aDisabled);
|
|
|
|
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
|
|
|
|
nsresult GetFormAction(nsAString *aFormAction);
|
|
|
|
nsresult SetFormAction(const nsAString *aFormAction);
|
|
|
|
nsresult GetFormEnctype(nsAString *aFormEnctype);
|
|
|
|
nsresult SetFormEnctype(const nsAString *aFormEnctype);
|
|
|
|
nsresult GetFormMethod(nsAString *aFormMethod);
|
|
|
|
nsresult SetFormMethod(const nsAString *aFormMethod);
|
|
|
|
nsresult GetFormNoValidate(bool *aFormNoValidate);
|
|
|
|
nsresult SetFormNoValidate(bool aFormNoValidate);
|
|
|
|
nsresult GetFormTarget(nsAString *aFormTarget);
|
|
|
|
nsresult SetFormTarget(const nsAString *aFormTarget);
|
|
|
|
nsresult GetFiles(nsIDOMFileList **aFiles);
|
|
|
|
nsresult GetHeight(uint32_t *aHeight);
|
|
|
|
nsresult SetHeight(uint32_t aHeight);
|
|
|
|
nsresult GetIndeterminate(bool *aIndeterminate);
|
|
|
|
nsresult SetIndeterminate(bool aIndeterminate);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetInputMode(nsAString *aInputMode);
|
|
|
|
nsresult SetInputMode(const nsAString *aInputMode);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetList(nsIDOMHTMLElement **aList);
|
|
|
|
nsresult GetMax(nsAString *aMax);
|
|
|
|
nsresult SetMax(const nsAString *aMax);
|
|
|
|
nsresult GetMaxLength(int32_t *aMaxLength);
|
|
|
|
nsresult SetMaxLength(int32_t aMaxLength);
|
|
|
|
nsresult GetMin(nsAString *aMin);
|
|
|
|
nsresult SetMin(const nsAString *aMin);
|
|
|
|
nsresult GetMultiple(bool *aMultiple);
|
|
|
|
nsresult SetMultiple(bool aMultiple);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPattern(nsAString *aPattern);
|
|
|
|
nsresult SetPattern(const nsAString *aPattern);
|
|
|
|
nsresult GetPlaceholder(nsAString *aPlaceholder);
|
|
|
|
nsresult SetPlaceholder(const nsAString *aPlaceholder);
|
|
|
|
nsresult GetReadOnly(bool *aReadOnly);
|
|
|
|
nsresult SetReadOnly(bool aReadOnly);
|
|
|
|
nsresult GetRequired(bool *aRequired);
|
|
|
|
nsresult SetRequired(bool aRequired);
|
|
|
|
nsresult GetStep(nsAString *aStep);
|
|
|
|
nsresult SetStep(const nsAString *aStep);
|
|
|
|
nsresult GetAlign(nsAString *aAlign);
|
|
|
|
nsresult SetAlign(const nsAString *aAlign);
|
|
|
|
nsresult GetSize(uint32_t *aSize);
|
|
|
|
nsresult SetSize(uint32_t aSize);
|
|
|
|
nsresult GetWidth(uint32_t *aWidth);
|
|
|
|
nsresult SetWidth(uint32_t aWidth);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetSrc(nsAString *aSrc);
|
|
|
|
nsresult SetSrc(const nsAString *aSrc);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult SetType(const nsAString *aType);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDefaultValue(nsAString *aDefaultValue);
|
|
|
|
nsresult SetDefaultValue(const nsAString *aDefaultValue);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetValue(nsAString *aValue);
|
|
|
|
nsresult SetValue(const nsAString *aValue);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetValueAsNumber(double *aValueAsNumber);
|
|
|
|
nsresult SetValueAsNumber(double aValueAsNumber);
|
|
|
|
nsresult StepDown(int32_t n, uint8_t _argc);
|
|
|
|
nsresult StepUp(int32_t n, uint8_t _argc);
|
|
|
|
nsresult GetWillValidate(bool *aWillValidate);
|
|
|
|
nsresult GetValidity(nsIDOMValidityState **aValidity);
|
|
|
|
nsresult GetValidationMessage(nsAString *aValidationMessage);
|
|
|
|
nsresult CheckValidity(bool *_retval);
|
|
|
|
nsresult SetCustomValidity(const nsAString *error);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Select();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetSelectionStart(int32_t *aSelectionStart);
|
|
|
|
nsresult SetSelectionStart(int32_t aSelectionStart);
|
|
|
|
nsresult GetSelectionEnd(int32_t *aSelectionEnd);
|
|
|
|
nsresult SetSelectionEnd(int32_t aSelectionEnd);
|
|
|
|
nsresult SetSelectionRange(int32_t selectionStart, int32_t selectionEnd, const nsAString *direction);
|
|
|
|
nsresult GetSelectionDirection(nsAString *aSelectionDirection);
|
|
|
|
nsresult SetSelectionDirection(const nsAString *aSelectionDirection);
|
|
|
|
nsresult GetUseMap(nsAString *aUseMap);
|
|
|
|
nsresult SetUseMap(const nsAString *aUseMap);
|
|
|
|
nsresult GetControllers(nsIControllers **aControllers);
|
|
|
|
nsresult GetTextLength(int32_t *aTextLength);
|
|
|
|
nsresult MozGetFileNameArray(uint32_t *aLength, PRUnichar ***aFileNames);
|
|
|
|
nsresult MozSetFileNameArray(const PRUnichar **aFileNames, uint32_t aLength);
|
|
|
|
nsresult MozIsTextField(bool aExcludePassword, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(09017cf4-0004-4c27-a340-7f5d2fe282e3),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLOptionElement : nsIDOMHTMLElement
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDisabled(bool *aDisabled);
|
|
|
|
nsresult SetDisabled(bool aDisabled);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
|
|
|
|
nsresult GetLabel(nsAString *aLabel);
|
|
|
|
nsresult SetLabel(const nsAString *aLabel);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDefaultSelected(bool *aDefaultSelected);
|
|
|
|
nsresult SetDefaultSelected(bool aDefaultSelected);
|
|
|
|
nsresult GetSelected(bool *aSelected);
|
|
|
|
nsresult SetSelected(bool aSelected);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetValue(nsAString *aValue);
|
|
|
|
nsresult SetValue(const nsAString *aValue);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetText(nsAString *aText);
|
|
|
|
nsresult SetText(const nsAString *aText);
|
|
|
|
nsresult GetIndex(int32_t *aIndex);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
2010-05-29 14:54:55 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(5564816e-2ab5-46ee-95a4-8f4688bdb449),
|
2013-10-07 14:22:37 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLButtonElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetAutofocus(bool *aAutofocus);
|
|
|
|
nsresult SetAutofocus(bool aAutofocus);
|
|
|
|
nsresult GetDisabled(bool *aDisabled);
|
|
|
|
nsresult SetDisabled(bool aDisabled);
|
|
|
|
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
|
|
|
|
nsresult GetFormAction(nsAString *aFormAction);
|
|
|
|
nsresult SetFormAction(const nsAString *aFormAction);
|
|
|
|
nsresult GetFormEnctype(nsAString *aFormEnctype);
|
|
|
|
nsresult SetFormEnctype(const nsAString *aFormEnctype);
|
|
|
|
nsresult GetFormMethod(nsAString *aFormMethod);
|
|
|
|
nsresult SetFormMethod(const nsAString *aFormMethod);
|
|
|
|
nsresult GetFormNoValidate(bool *aFormNoValidate);
|
|
|
|
nsresult SetFormNoValidate(bool aFormNoValidate);
|
|
|
|
nsresult GetFormTarget(nsAString *aFormTarget);
|
|
|
|
nsresult SetFormTarget(const nsAString *aFormTarget);
|
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult SetType(const nsAString *aType);
|
|
|
|
nsresult GetValue(nsAString *aValue);
|
|
|
|
nsresult SetValue(const nsAString *aValue);
|
|
|
|
nsresult GetWillValidate(bool *aWillValidate);
|
|
|
|
nsresult GetValidity(nsIDOMValidityState **aValidity);
|
|
|
|
nsresult GetValidationMessage(nsAString *aValidationMessage);
|
|
|
|
nsresult CheckValidity(bool *_retval);
|
|
|
|
nsresult SetCustomValidity(const nsAString *error);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(4173cc53-30f6-4d12-a770-981ba53164e2),
|
2010-05-29 14:54:55 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLOptionsCollection : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
typedef int nsWrapperCache;
|
|
|
|
|
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult SetLength(uint32_t aLength);
|
|
|
|
nsresult Item(uint32_t index, nsIDOMNode **_retval);
|
2010-05-29 14:54:55 +00:00
|
|
|
nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetSelectedIndex(int32_t *aSelectedIndex);
|
|
|
|
nsresult SetSelectedIndex(int32_t aSelectedIndex);
|
|
|
|
nsresult SetOption(uint32_t index, nsIDOMHTMLOptionElement *option);
|
|
|
|
nsresult GetSelect(nsIDOMHTMLSelectElement **aSelect);
|
|
|
|
nsresult Add(nsIDOMHTMLOptionElement *option, nsIVariant *before);
|
|
|
|
nsresult Remove(int32_t index);
|
2010-05-29 14:54:55 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(8af2123f-c83a-430a-a739-d103a8eaba52),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLSelectElement : nsIDOMHTMLElement
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAutofocus(bool *aAutofocus);
|
|
|
|
nsresult SetAutofocus(bool aAutofocus);
|
|
|
|
nsresult GetDisabled(bool *aDisabled);
|
|
|
|
nsresult SetDisabled(bool aDisabled);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetMultiple(bool *aMultiple);
|
|
|
|
nsresult SetMultiple(bool aMultiple);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetSize(uint32_t *aSize);
|
|
|
|
nsresult SetSize(uint32_t aSize);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult GetOptions(nsIDOMHTMLOptionsCollection **aOptions);
|
|
|
|
nsresult GetLength(uint32_t *aLength);
|
|
|
|
nsresult SetLength(uint32_t aLength);
|
|
|
|
nsresult Item(uint32_t index, nsIDOMNode **_retval);
|
|
|
|
nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
|
|
|
|
nsresult Add(nsIDOMHTMLElement *element, nsIVariant *before);
|
|
|
|
nsresult Remove(int32_t index);
|
|
|
|
nsresult GetSelectedIndex(int32_t *aSelectedIndex);
|
|
|
|
nsresult SetSelectedIndex(int32_t aSelectedIndex);
|
|
|
|
nsresult GetValue(nsAString *aValue);
|
|
|
|
nsresult SetValue(const nsAString *aValue);
|
|
|
|
nsresult GetWillValidate(bool *aWillValidate);
|
|
|
|
nsresult GetValidity(nsIDOMValidityState **aValidity);
|
|
|
|
nsresult GetValidationMessage(nsAString *aValidationMessage);
|
|
|
|
nsresult CheckValidity(bool *_retval);
|
|
|
|
nsresult SetCustomValidity(const nsAString *error);
|
|
|
|
nsresult GetRequired(bool *aRequired);
|
|
|
|
nsresult SetRequired(bool aRequired);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(b7e1b86f-c98e-4658-81ce-ac29962f854a),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLTextAreaElement : nsIDOMHTMLElement
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAutofocus(bool *aAutofocus);
|
|
|
|
nsresult SetAutofocus(bool aAutofocus);
|
|
|
|
nsresult GetCols(uint32_t *aCols);
|
|
|
|
nsresult SetCols(uint32_t aCols);
|
|
|
|
nsresult GetDisabled(bool *aDisabled);
|
|
|
|
nsresult SetDisabled(bool aDisabled);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetMaxLength(int32_t *aMaxLength);
|
|
|
|
nsresult SetMaxLength(int32_t aMaxLength);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPlaceholder(nsAString *aPlaceholder);
|
|
|
|
nsresult SetPlaceholder(const nsAString *aPlaceholder);
|
|
|
|
nsresult GetReadOnly(bool *aReadOnly);
|
|
|
|
nsresult SetReadOnly(bool aReadOnly);
|
|
|
|
nsresult GetRequired(bool *aRequired);
|
|
|
|
nsresult SetRequired(bool aRequired);
|
|
|
|
nsresult GetRows(uint32_t *aRows);
|
|
|
|
nsresult SetRows(uint32_t aRows);
|
|
|
|
nsresult GetWrap(nsAString *aWrap);
|
|
|
|
nsresult SetWrap(const nsAString *aWrap);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetType(nsAString *aType);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDefaultValue(nsAString *aDefaultValue);
|
|
|
|
nsresult SetDefaultValue(const nsAString *aDefaultValue);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetValue(nsAString *aValue);
|
|
|
|
nsresult SetValue(const nsAString *aValue);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetTextLength(int32_t *aTextLength);
|
|
|
|
nsresult GetWillValidate(bool *aWillValidate);
|
|
|
|
nsresult GetValidity(nsIDOMValidityState **aValidity);
|
|
|
|
nsresult GetValidationMessage(nsAString *aValidationMessage);
|
|
|
|
nsresult CheckValidity(bool *_retval);
|
|
|
|
nsresult SetCustomValidity(const nsAString *error);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Select();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetSelectionStart(int32_t *aSelectionStart);
|
|
|
|
nsresult SetSelectionStart(int32_t aSelectionStart);
|
|
|
|
nsresult GetSelectionEnd(int32_t *aSelectionEnd);
|
|
|
|
nsresult SetSelectionEnd(int32_t aSelectionEnd);
|
|
|
|
nsresult SetSelectionRange(int32_t selectionStart, int32_t selectionEnd, const nsAString *direction);
|
|
|
|
nsresult GetSelectionDirection(nsAString *aSelectionDirection);
|
|
|
|
nsresult SetSelectionDirection(const nsAString *aSelectionDirection);
|
|
|
|
nsresult GetControllers(nsIControllers **aControllers);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(8783371a-6185-4176-9ed9-f781c75bf48a),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLScriptElement : nsIDOMHTMLElement
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetSrc(nsAString *aSrc);
|
|
|
|
nsresult SetSrc(const nsAString *aSrc);
|
|
|
|
nsresult GetAsync(bool *aAsync);
|
|
|
|
nsresult SetAsync(bool aAsync);
|
|
|
|
nsresult GetDefer(bool *aDefer);
|
|
|
|
nsresult SetDefer(bool aDefer);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult SetType(const nsAString *aType);
|
|
|
|
nsresult GetCharset(nsAString *aCharset);
|
|
|
|
nsresult SetCharset(const nsAString *aCharset);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetText(nsAString *aText);
|
|
|
|
nsresult SetText(const nsAString *aText);
|
|
|
|
nsresult GetHtmlFor(nsAString *aHtmlFor);
|
|
|
|
nsresult SetHtmlFor(const nsAString *aHtmlFor);
|
|
|
|
nsresult GetEvent(nsAString *aEvent);
|
|
|
|
nsresult SetEvent(const nsAString *aEvent);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetCrossOrigin(nsAString *aCrossOrigin);
|
|
|
|
nsresult SetCrossOrigin(const nsAString *aCrossOrigin);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
2008-07-08 16:39:29 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(98c38ca0-5e3a-4c71-90a4-69d12a3c8d16),
|
2008-07-08 16:39:29 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLImageElement : nsIDOMHTMLElement
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAlt(nsAString *aAlt);
|
|
|
|
nsresult SetAlt(const nsAString *aAlt);
|
|
|
|
nsresult GetSrc(nsAString *aSrc);
|
|
|
|
nsresult SetSrc(const nsAString *aSrc);
|
|
|
|
nsresult GetCrossOrigin(nsAString *aCrossOrigin);
|
|
|
|
nsresult SetCrossOrigin(const nsAString *aCrossOrigin);
|
|
|
|
nsresult GetUseMap(nsAString *aUseMap);
|
|
|
|
nsresult SetUseMap(const nsAString *aUseMap);
|
|
|
|
nsresult GetIsMap(bool *aIsMap);
|
|
|
|
nsresult SetIsMap(bool aIsMap);
|
|
|
|
nsresult GetWidth(uint32_t *aWidth);
|
|
|
|
nsresult SetWidth(uint32_t aWidth);
|
|
|
|
nsresult GetHeight(uint32_t *aHeight);
|
|
|
|
nsresult SetHeight(uint32_t aHeight);
|
|
|
|
nsresult GetNaturalWidth(uint32_t *aNaturalWidth);
|
|
|
|
nsresult GetNaturalHeight(uint32_t *aNaturalHeight);
|
|
|
|
nsresult GetComplete(bool *aComplete);
|
2008-07-08 16:39:29 +00:00
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
|
|
|
nsresult GetAlign(nsAString *aAlign);
|
|
|
|
nsresult SetAlign(const nsAString *aAlign);
|
|
|
|
nsresult GetBorder(nsAString *aBorder);
|
|
|
|
nsresult SetBorder(const nsAString *aBorder);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetHspace(int32_t *aHspace);
|
|
|
|
nsresult SetHspace(int32_t aHspace);
|
2008-07-08 16:39:29 +00:00
|
|
|
nsresult GetLongDesc(nsAString *aLongDesc);
|
|
|
|
nsresult SetLongDesc(const nsAString *aLongDesc);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetVspace(int32_t *aVspace);
|
|
|
|
nsresult SetVspace(int32_t aVspace);
|
|
|
|
nsresult GetLowsrc(nsAString *aLowsrc);
|
|
|
|
nsresult SetLowsrc(const nsAString *aLowsrc);
|
|
|
|
nsresult GetX(int32_t *aX);
|
|
|
|
nsresult GetY(int32_t *aY);
|
2008-07-08 16:39:29 +00:00
|
|
|
}
|
|
|
|
|
2009-10-20 19:28:02 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(76ec122a-db6d-4b3f-8a24-15faf117f695),
|
2009-10-20 19:28:02 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLAnchorElement : nsIDOMHTMLElement
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetHref(nsAString *aHref);
|
|
|
|
nsresult SetHref(const nsAString *aHref);
|
|
|
|
nsresult GetTarget(nsAString *aTarget);
|
|
|
|
nsresult SetTarget(const nsAString *aTarget);
|
|
|
|
nsresult GetPing(nsAString *aPing);
|
|
|
|
nsresult SetPing(const nsAString *aPing);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetDownload(nsAString *aPing);
|
|
|
|
nsresult SetDownload(const nsAString *aPing);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetRel(nsAString *aRel);
|
|
|
|
nsresult SetRel(const nsAString *aRel);
|
|
|
|
nsresult GetHreflang(nsAString *aHreflang);
|
|
|
|
nsresult SetHreflang(const nsAString *aHreflang);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult SetType(const nsAString *aType);
|
|
|
|
nsresult GetText(nsAString *aText);
|
|
|
|
nsresult SetText(const nsAString *aText);
|
|
|
|
nsresult GetProtocol(nsAString *aProtocol);
|
|
|
|
nsresult SetProtocol(const nsAString *aProtocol);
|
|
|
|
nsresult GetHost(nsAString *aHost);
|
|
|
|
nsresult SetHost(const nsAString *aHost);
|
|
|
|
nsresult GetHostname(nsAString *aHostname);
|
|
|
|
nsresult SetHostname(const nsAString *aHostname);
|
|
|
|
nsresult GetPort(nsAString *aPort);
|
|
|
|
nsresult SetPort(const nsAString *aPort);
|
|
|
|
nsresult GetPathname(nsAString *aPathname);
|
|
|
|
nsresult SetPathname(const nsAString *aPathname);
|
|
|
|
nsresult GetSearch(nsAString *aSearch);
|
|
|
|
nsresult SetSearch(const nsAString *aSearch);
|
|
|
|
nsresult GetHash(nsAString *aHash);
|
|
|
|
nsresult SetHash(const nsAString *aHash);
|
2009-10-20 19:28:02 +00:00
|
|
|
nsresult GetCharset(nsAString *aCharset);
|
|
|
|
nsresult SetCharset(const nsAString *aCharset);
|
|
|
|
nsresult GetCoords(nsAString *aCoords);
|
|
|
|
nsresult SetCoords(const nsAString *aCoords);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
|
|
|
nsresult GetRev(nsAString *aRev);
|
|
|
|
nsresult SetRev(const nsAString *aRev);
|
|
|
|
nsresult GetShape(nsAString *aShape);
|
|
|
|
nsresult SetShape(const nsAString *aShape);
|
|
|
|
nsresult ToString(nsAString *_retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(ad43cb9b-3253-446d-8ba9-50ee50ff017e),
|
2013-05-19 21:21:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLLinkElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetDisabled(bool *aDisabled);
|
|
|
|
nsresult SetDisabled(bool aDisabled);
|
|
|
|
nsresult GetCharset(nsAString *aCharset);
|
|
|
|
nsresult SetCharset(const nsAString *aCharset);
|
2009-10-20 19:28:02 +00:00
|
|
|
nsresult GetHref(nsAString *aHref);
|
|
|
|
nsresult SetHref(const nsAString *aHref);
|
|
|
|
nsresult GetHreflang(nsAString *aHreflang);
|
|
|
|
nsresult SetHreflang(const nsAString *aHreflang);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetMedia(nsAString *aMedia);
|
|
|
|
nsresult SetMedia(const nsAString *aMedia);
|
2009-10-20 19:28:02 +00:00
|
|
|
nsresult GetRel(nsAString *aRel);
|
|
|
|
nsresult SetRel(const nsAString *aRel);
|
|
|
|
nsresult GetRev(nsAString *aRev);
|
|
|
|
nsresult SetRev(const nsAString *aRev);
|
|
|
|
nsresult GetTarget(nsAString *aTarget);
|
|
|
|
nsresult SetTarget(const nsAString *aTarget);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult SetType(const nsAString *aType);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetCrossOrigin(nsAString *aCrossOrigin);
|
|
|
|
nsresult SetCrossOrigin(const nsAString *aCrossOrigin);
|
2009-10-20 19:28:02 +00:00
|
|
|
}
|
|
|
|
|
2009-02-04 14:35:06 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(1a7bf1f1-5d6c-4200-9ceb-455874322315),
|
2009-02-04 14:35:06 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLTableElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetCaption(nsIDOMHTMLTableCaptionElement **aCaption);
|
|
|
|
nsresult SetCaption(nsIDOMHTMLTableCaptionElement *aCaption);
|
|
|
|
nsresult GetTHead(nsIDOMHTMLTableSectionElement **aTHead);
|
|
|
|
nsresult SetTHead(nsIDOMHTMLTableSectionElement *aTHead);
|
|
|
|
nsresult GetTFoot(nsIDOMHTMLTableSectionElement **aTFoot);
|
|
|
|
nsresult SetTFoot(nsIDOMHTMLTableSectionElement *aTFoot);
|
|
|
|
nsresult GetRows(nsIDOMHTMLCollection **aRows);
|
|
|
|
nsresult GetTBodies(nsIDOMHTMLCollection **aTBodies);
|
|
|
|
nsresult GetAlign(nsAString *aAlign);
|
|
|
|
nsresult SetAlign(const nsAString *aAlign);
|
|
|
|
nsresult GetBgColor(nsAString *aBgColor);
|
|
|
|
nsresult SetBgColor(const nsAString *aBgColor);
|
|
|
|
nsresult GetBorder(nsAString *aBorder);
|
|
|
|
nsresult SetBorder(const nsAString *aBorder);
|
|
|
|
nsresult GetCellPadding(nsAString *aCellPadding);
|
|
|
|
nsresult SetCellPadding(const nsAString *aCellPadding);
|
|
|
|
nsresult GetCellSpacing(nsAString *aCellSpacing);
|
|
|
|
nsresult SetCellSpacing(const nsAString *aCellSpacing);
|
|
|
|
nsresult GetFrame(nsAString *aFrame);
|
|
|
|
nsresult SetFrame(const nsAString *aFrame);
|
|
|
|
nsresult GetRules(nsAString *aRules);
|
|
|
|
nsresult SetRules(const nsAString *aRules);
|
|
|
|
nsresult GetSummary(nsAString *aSummary);
|
|
|
|
nsresult SetSummary(const nsAString *aSummary);
|
|
|
|
nsresult GetWidth(nsAString *aWidth);
|
|
|
|
nsresult SetWidth(const nsAString *aWidth);
|
|
|
|
nsresult CreateTHead(nsIDOMHTMLElement **_retval);
|
|
|
|
nsresult DeleteTHead();
|
|
|
|
nsresult CreateTFoot(nsIDOMHTMLElement **_retval);
|
|
|
|
nsresult DeleteTFoot();
|
|
|
|
nsresult CreateCaption(nsIDOMHTMLElement **_retval);
|
|
|
|
nsresult DeleteCaption();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InsertRow(int32_t index, nsIDOMHTMLElement **_retval);
|
|
|
|
nsresult DeleteRow(int32_t index);
|
2009-02-04 14:35:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(02094366-0d3d-47e3-949c-89113a9bcc15),
|
2009-02-04 14:35:06 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLTableRowElement : nsIDOMHTMLElement
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetRowIndex(int32_t *aRowIndex);
|
|
|
|
nsresult GetSectionRowIndex(int32_t *aSectionRowIndex);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetCells(nsIDOMHTMLCollection **aCells);
|
|
|
|
nsresult GetAlign(nsAString *aAlign);
|
|
|
|
nsresult SetAlign(const nsAString *aAlign);
|
|
|
|
nsresult GetBgColor(nsAString *aBgColor);
|
|
|
|
nsresult SetBgColor(const nsAString *aBgColor);
|
|
|
|
nsresult GetCh(nsAString *aCh);
|
|
|
|
nsresult SetCh(const nsAString *aCh);
|
|
|
|
nsresult GetChOff(nsAString *aChOff);
|
|
|
|
nsresult SetChOff(const nsAString *aChOff);
|
|
|
|
nsresult GetVAlign(nsAString *aVAlign);
|
|
|
|
nsresult SetVAlign(const nsAString *aVAlign);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InsertCell(int32_t index, nsIDOMHTMLElement **_retval);
|
|
|
|
nsresult DeleteCell(int32_t index);
|
2009-02-04 14:35:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(21ffbe98-51f5-499e-8d6f-612ae798c1e1),
|
2009-02-04 14:35:06 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLIFrameElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetAlign(nsAString *aAlign);
|
|
|
|
nsresult SetAlign(const nsAString *aAlign);
|
|
|
|
nsresult GetFrameBorder(nsAString *aFrameBorder);
|
|
|
|
nsresult SetFrameBorder(const nsAString *aFrameBorder);
|
|
|
|
nsresult GetHeight(nsAString *aHeight);
|
|
|
|
nsresult SetHeight(const nsAString *aHeight);
|
|
|
|
nsresult GetLongDesc(nsAString *aLongDesc);
|
|
|
|
nsresult SetLongDesc(const nsAString *aLongDesc);
|
|
|
|
nsresult GetMarginHeight(nsAString *aMarginHeight);
|
|
|
|
nsresult SetMarginHeight(const nsAString *aMarginHeight);
|
|
|
|
nsresult GetMarginWidth(nsAString *aMarginWidth);
|
|
|
|
nsresult SetMarginWidth(const nsAString *aMarginWidth);
|
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
|
|
|
nsresult GetScrolling(nsAString *aScrolling);
|
|
|
|
nsresult SetScrolling(const nsAString *aScrolling);
|
|
|
|
nsresult GetSrc(nsAString *aSrc);
|
|
|
|
nsresult SetSrc(const nsAString *aSrc);
|
|
|
|
nsresult GetWidth(nsAString *aWidth);
|
|
|
|
nsresult SetWidth(const nsAString *aWidth);
|
|
|
|
nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetContentWindow(nsIDOMWindow **aContentWindow);
|
|
|
|
nsresult GetSandbox(nsAString *aSandbox);
|
|
|
|
nsresult SetSandbox(const nsAString *aSandbox);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetAllowFullscreen(bool *aAllowFullscreen);
|
|
|
|
nsresult SetAllowFullscreen(bool aAllowFullscreen);
|
2009-02-04 14:35:06 +00:00
|
|
|
}
|
|
|
|
|
2009-11-15 23:44:20 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(1a79af54-dbbb-4532-be48-944f3995e7e9),
|
2009-11-15 23:44:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLFrameElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetFrameBorder(nsAString *aFrameBorder);
|
|
|
|
nsresult SetFrameBorder(const nsAString *aFrameBorder);
|
|
|
|
nsresult GetLongDesc(nsAString *aLongDesc);
|
|
|
|
nsresult SetLongDesc(const nsAString *aLongDesc);
|
|
|
|
nsresult GetMarginHeight(nsAString *aMarginHeight);
|
|
|
|
nsresult SetMarginHeight(const nsAString *aMarginHeight);
|
|
|
|
nsresult GetMarginWidth(nsAString *aMarginWidth);
|
|
|
|
nsresult SetMarginWidth(const nsAString *aMarginWidth);
|
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetNoResize(bool *aNoResize);
|
|
|
|
nsresult SetNoResize(bool aNoResize);
|
2009-11-15 23:44:20 +00:00
|
|
|
nsresult GetScrolling(nsAString *aScrolling);
|
|
|
|
nsresult SetScrolling(const nsAString *aScrolling);
|
|
|
|
nsresult GetSrc(nsAString *aSrc);
|
|
|
|
nsresult SetSrc(const nsAString *aSrc);
|
|
|
|
nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetContentWindow(nsIDOMWindow **aContentWindow);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(bed8f222-c4dd-41ba-9ec6-dfae0ec8def8),
|
2013-05-19 21:21:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLObjectElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
|
|
|
|
nsresult GetCode(nsAString *aCode);
|
|
|
|
nsresult SetCode(const nsAString *aCode);
|
|
|
|
nsresult GetAlign(nsAString *aAlign);
|
|
|
|
nsresult SetAlign(const nsAString *aAlign);
|
|
|
|
nsresult GetArchive(nsAString *aArchive);
|
|
|
|
nsresult SetArchive(const nsAString *aArchive);
|
|
|
|
nsresult GetBorder(nsAString *aBorder);
|
|
|
|
nsresult SetBorder(const nsAString *aBorder);
|
|
|
|
nsresult GetCodeBase(nsAString *aCodeBase);
|
|
|
|
nsresult SetCodeBase(const nsAString *aCodeBase);
|
|
|
|
nsresult GetCodeType(nsAString *aCodeType);
|
|
|
|
nsresult SetCodeType(const nsAString *aCodeType);
|
|
|
|
nsresult GetData(nsAString *aData);
|
|
|
|
nsresult SetData(const nsAString *aData);
|
|
|
|
nsresult GetDeclare(bool *aDeclare);
|
|
|
|
nsresult SetDeclare(bool aDeclare);
|
|
|
|
nsresult GetHeight(nsAString *aHeight);
|
|
|
|
nsresult SetHeight(const nsAString *aHeight);
|
|
|
|
nsresult GetHspace(int32_t *aHspace);
|
|
|
|
nsresult SetHspace(int32_t aHspace);
|
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
|
|
|
nsresult GetStandby(nsAString *aStandby);
|
|
|
|
nsresult SetStandby(const nsAString *aStandby);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult SetType(const nsAString *aType);
|
|
|
|
nsresult GetUseMap(nsAString *aUseMap);
|
|
|
|
nsresult SetUseMap(const nsAString *aUseMap);
|
|
|
|
nsresult GetVspace(int32_t *aVspace);
|
|
|
|
nsresult SetVspace(int32_t aVspace);
|
|
|
|
nsresult GetWidth(nsAString *aWidth);
|
|
|
|
nsresult SetWidth(const nsAString *aWidth);
|
|
|
|
nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
|
|
|
|
nsresult GetWillValidate(bool *aWillValidate);
|
|
|
|
nsresult GetValidity(nsIDOMValidityState **aValidity);
|
|
|
|
nsresult GetValidationMessage(nsAString *aValidationMessage);
|
|
|
|
nsresult CheckValidity(bool *_retval);
|
|
|
|
nsresult SetCustomValidity(const nsAString *error);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(f85e1b05-6dc4-442d-bea8-7cf551f9bc9f),
|
2013-05-19 21:21:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLParamElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult SetType(const nsAString *aType);
|
|
|
|
nsresult GetValue(nsAString *aValue);
|
|
|
|
nsresult SetValue(const nsAString *aValue);
|
|
|
|
nsresult GetValueType(nsAString *aValueType);
|
|
|
|
nsresult SetValueType(const nsAString *aValueType);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(e81273e1-d440-4dd3-9073-8199f7a9525e),
|
2013-05-19 21:21:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMHTMLStyleElement : nsIDOMHTMLElement
|
|
|
|
{
|
|
|
|
nsresult GetDisabled(bool *aDisabled);
|
|
|
|
nsresult SetDisabled(bool aDisabled);
|
|
|
|
nsresult GetMedia(nsAString *aMedia);
|
|
|
|
nsresult SetMedia(const nsAString *aMedia);
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult SetType(const nsAString *aType);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetScoped(bool *aScoped);
|
|
|
|
nsresult SetScoped(bool aScoped);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDOMStyleSheet(nsIDOMStyleSheet **aDOMStyleSheet);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(7cebc153-168a-416c-ba5a-56a8c2ddb2ec),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMNodeSelector : nsISupports
|
|
|
|
{
|
|
|
|
nsresult QuerySelector(const nsAString *selectors, nsIDOMElement **_retval);
|
|
|
|
nsresult QuerySelectorAll(const nsAString *selectors, nsIDOMNodeList **_retval);
|
2009-11-15 23:44:20 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(94928ab3-8b63-11d3-989d-001083010e9b),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIURIContentListener : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult OnStartURIOpen(nsIURI *aURI, bool *_retval);
|
|
|
|
nsresult DoContent(const char *aContentType, bool aIsContentPreferred, nsIRequest *aRequest,
|
|
|
|
nsIStreamListener **aContentHandler, bool *_retval);
|
|
|
|
nsresult IsPreferred(const char *aContentType, char **aDesiredContentType, bool *_retval);
|
|
|
|
nsresult CanHandleContent(const char *aContentType, bool aIsContentPreferred,
|
|
|
|
char **aDesiredContentType, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetLoadCookie(nsISupports **aLoadCookie);
|
|
|
|
nsresult SetLoadCookie(nsISupports *aLoadCookie);
|
|
|
|
nsresult GetParentContentListener(nsIURIContentListener **aParentContentListener);
|
|
|
|
nsresult SetParentContentListener(nsIURIContentListener *aParentContentListener);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(44b78386-1dd2-11b2-9ad2-e4eee2ca1916),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsITooltipListener : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult OnShowTooltip(int32_t aXCoords, int32_t aYCoords, const PRUnichar *aTipText);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult OnHideTooltip();
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(33e9d001-caab-4ba9-8961-54902f197202),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWebBrowser : nsISupports
|
|
|
|
{
|
|
|
|
nsresult AddWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
|
|
|
|
nsresult RemoveWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
|
|
|
|
nsresult GetContainerWindow(nsIWebBrowserChrome **aContainerWindow);
|
|
|
|
nsresult SetContainerWindow(nsIWebBrowserChrome *aContainerWindow);
|
|
|
|
nsresult GetParentURIContentListener(nsIURIContentListener **aParentURIContentListener);
|
|
|
|
nsresult SetParentURIContentListener(nsIURIContentListener *aParentURIContentListener);
|
|
|
|
nsresult GetContentDOMWindow(nsIDOMWindow **aContentDOMWindow);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIsActive(bool *aIsActive);
|
|
|
|
nsresult SetIsActive(bool aIsActive);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
2009-02-04 14:35:06 +00:00
|
|
|
cpp_quote("#define SETUP_ALLOW_JAVASCRIPT 2")
|
2008-04-11 12:45:31 +00:00
|
|
|
cpp_quote("#define SETUP_IS_CHROME_WRAPPER 7")
|
2013-05-19 21:21:20 +00:00
|
|
|
cpp_quote("#define SETUP_DISABLE_NOSCRIPT 16")
|
2008-04-11 12:45:31 +00:00
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(f15398a0-8018-11d3-af70-00a024ffc08c),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWebBrowserSetup : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetProperty(uint32_t aId, uint32_t aValue);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
typedef void* nativeWindow;
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(9da319f3-eee6-4504-81a5-6A19cf6215bf),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIBaseWindow : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InitWindow(nativeWindow parentNativeWindow, nsIWidget *parentWidget, int32_t x,
|
|
|
|
int32_t y, int32_t cx, int32_t cy);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Create();
|
|
|
|
nsresult Destroy();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetPosition(int32_t x, int32_t y);
|
|
|
|
nsresult GetPosition(int32_t *x, int32_t *y);
|
|
|
|
nsresult SetSize(int32_t cx, int32_t cy, bool fRepaint);
|
|
|
|
nsresult GetSize(int32_t *cx, int32_t *cy);
|
|
|
|
nsresult SetPositionAndSize(int32_t x, int32_t y, int32_t cx, int32_t cy, bool fRepaint);
|
|
|
|
nsresult GetPositionAndSize(int32_t *x, int32_t *y, int32_t *cx, int32_t *cy);
|
|
|
|
nsresult Repaint(bool force);
|
|
|
|
nsresult GetParentWidget(nsIWidget **aParentWidget);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SetParentWidget(nsIWidget *aParentWidget);
|
|
|
|
nsresult GetParentNativeWindow(nativeWindow *aParentNativeWindow);
|
|
|
|
nsresult SetParentNativeWindow(nativeWindow aParentNativeWindow);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetNativeHandle(nsAString *aNativeHandle);
|
|
|
|
nsresult GetVisibility(bool *aVisibility);
|
|
|
|
nsresult SetVisibility(bool aVisibility);
|
|
|
|
nsresult GetEnabled(bool *aEnabled);
|
|
|
|
nsresult SetEnabled(bool aEnabled);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetMainWidget(nsIWidget **aMainWidget);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetUnscaledDevicePixelsPerCSSPixel(double *aUnscaledDevicePixelsPerCSSPixel);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SetFocus();
|
|
|
|
nsresult GetTitle(PRUnichar **aTitle);
|
|
|
|
nsresult SetTitle(const PRUnichar *aTitle);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(28404f7e-0f17-4dc3-a21a-2074d8659b02),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWebNavigation : nsISupports
|
|
|
|
{
|
2013-10-07 14:22:37 +00:00
|
|
|
const UINT LOAD_FLAGS_MASK = 0xffff;
|
|
|
|
const UINT LOAD_FLAGS_NONE = 0;
|
|
|
|
const UINT LOAD_FLAGS_IS_REFRESH = 0x0010;
|
|
|
|
const UINT LOAD_FLAGS_IS_LINK = 0x0020;
|
|
|
|
const UINT LOAD_FLAGS_BYPASS_HISTORY = 0x0040;
|
|
|
|
const UINT LOAD_FLAGS_REPLACE_HISTORY = 0x0080;
|
|
|
|
const UINT LOAD_FLAGS_BYPASS_CACHE = 0x0100;
|
|
|
|
const UINT LOAD_FLAGS_BYPASS_PROXY = 0x0200;
|
|
|
|
const UINT LOAD_FLAGS_CHARSET_CHANGE = 0x0400;
|
|
|
|
const UINT LOAD_FLAGS_STOP_CONTENT = 0x0800;
|
|
|
|
const UINT LOAD_FLAGS_FROM_EXTERNAL = 0x1000;
|
|
|
|
const UINT LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP = 0x2000;
|
|
|
|
const UINT LOAD_FLAGS_FIRST_LOAD = 0x4000;
|
|
|
|
const UINT LOAD_FLAGS_ALLOW_POPUPS = 0x8000;
|
|
|
|
const UINT LOAD_FLAGS_BYPASS_CLASSIFIER = 0x10000;
|
|
|
|
const UINT LOAD_FLAGS_FORCE_ALLOW_COOKIES = 0x20000;
|
|
|
|
const UINT LOAD_FLAGS_DISALLOW_INHERIT_OWNER = 0x40000;
|
|
|
|
const UINT LOAD_FLAGS_URI_IS_UTF8 = 0x80000;
|
|
|
|
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetCanGoBack(bool *aCanGoBack);
|
|
|
|
nsresult GetCanGoForward(bool *aCanGoForward);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GoBack();
|
|
|
|
nsresult GoForward();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GotoIndex(int32_t index);
|
|
|
|
nsresult LoadURI(const PRUnichar *aURI, uint32_t aLoadFlags, nsIURI *aReferrer,
|
2008-04-11 12:45:31 +00:00
|
|
|
nsIInputStream *aPostData, nsIInputStream *aHeaders);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Reload(uint32_t aReloadFlags);
|
|
|
|
nsresult Stop(uint32_t aStopFlags);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetDocument(nsIDOMDocument **aDocument);
|
|
|
|
nsresult GetCurrentURI(nsIURI **aCurrentURI);
|
|
|
|
nsresult GetReferringURI(nsIURI **aReferringURI);
|
|
|
|
nsresult GetSessionHistory(nsISHistory **aSessionHistory);
|
|
|
|
nsresult SetSessionHistory(nsISHistory *aSessionHistory);
|
|
|
|
}
|
|
|
|
|
2009-11-15 23:44:20 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(1c3437b0-9e2c-11e2-9e96-0800200c9a66),
|
2009-11-15 23:44:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWebProgress : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult AddProgressListener(nsIWebProgressListener *aListener, uint32_t aNotifyMask);
|
2009-11-15 23:44:20 +00:00
|
|
|
nsresult RemoveProgressListener(nsIWebProgressListener *aListener);
|
|
|
|
nsresult GetDOMWindow(nsIDOMWindow **aDOMWindow);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetDOMWindowID(uint64_t *aDOMWindowID);
|
|
|
|
nsresult GetIsTopLevel(bool *aIsTopLevel);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIsLoadingDocument(bool *aIsLoadingDocument);
|
2009-11-15 23:44:20 +00:00
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(1bcfc611-8941-4c39-9e06-7116e564a1ce),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIPrintSettings : nsISupports
|
|
|
|
{
|
2009-08-09 12:00:11 +00:00
|
|
|
typedef struct { char dummy; } nsIntMargin;
|
2008-04-11 12:45:31 +00:00
|
|
|
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetPrintOptions(int32_t aType, bool aTurnOnOff);
|
|
|
|
nsresult GetPrintOptions(int32_t aType, bool *_retval);
|
|
|
|
nsresult GetPrintOptionsBits(int32_t *_retval);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetEffectivePageSize(double *aWidth, double *aHeight);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Clone(nsIPrintSettings **_retval);
|
|
|
|
nsresult Assign(nsIPrintSettings *aPS);
|
|
|
|
nsresult GetPrintSession(nsIPrintSession **aPrintSession);
|
|
|
|
nsresult SetPrintSession(nsIPrintSession *aPrintSession);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetStartPageRange(int32_t *aStartPageRange);
|
|
|
|
nsresult SetStartPageRange(int32_t aStartPageRange);
|
|
|
|
nsresult GetEndPageRange(int32_t *aEndPageRange);
|
|
|
|
nsresult SetEndPageRange(int32_t aEndPageRange);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetEdgeTop(double *aEdgeTop);
|
|
|
|
nsresult SetEdgeTop(double aEdgeTop);
|
|
|
|
nsresult GetEdgeLeft(double *aEdgeLeft);
|
|
|
|
nsresult SetEdgeLeft(double aEdgeLeft);
|
|
|
|
nsresult GetEdgeBottom(double *aEdgeBottom);
|
|
|
|
nsresult SetEdgeBottom(double aEdgeBottom);
|
|
|
|
nsresult GetEdgeRight(double *aEdgeRight);
|
|
|
|
nsresult SetEdgeRight(double aEdgeRight);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetMarginTop(double *aMarginTop);
|
|
|
|
nsresult SetMarginTop(double aMarginTop);
|
|
|
|
nsresult GetMarginLeft(double *aMarginLeft);
|
|
|
|
nsresult SetMarginLeft(double aMarginLeft);
|
|
|
|
nsresult GetMarginBottom(double *aMarginBottom);
|
|
|
|
nsresult SetMarginBottom(double aMarginBottom);
|
|
|
|
nsresult GetMarginRight(double *aMarginRight);
|
|
|
|
nsresult SetMarginRight(double aMarginRight);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult GetUnwriteableMarginTop(double *aUnwriteableMarginTop);
|
|
|
|
nsresult SetUnwriteableMarginTop(double aUnwriteableMarginTop);
|
|
|
|
nsresult GetUnwriteableMarginLeft(double *aUnwriteableMarginLeft);
|
|
|
|
nsresult SetUnwriteableMarginLeft(double aUnwriteableMarginLeft);
|
|
|
|
nsresult GetUnwriteableMarginBottom(double *aUnwriteableMarginBottom);
|
|
|
|
nsresult SetUnwriteableMarginBottom(double aUnwriteableMarginBottom);
|
|
|
|
nsresult GetUnwriteableMarginRight(double *aUnwriteableMarginRight);
|
|
|
|
nsresult SetUnwriteableMarginRight(double aUnwriteableMarginRight);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetScaling(double *aScaling);
|
|
|
|
nsresult SetScaling(double aScaling);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPrintBGColors(bool *aPrintBGColors);
|
|
|
|
nsresult SetPrintBGColors(bool aPrintBGColors);
|
|
|
|
nsresult GetPrintBGImages(bool *aPrintBGImages);
|
|
|
|
nsresult SetPrintBGImages(bool aPrintBGImages);
|
|
|
|
nsresult GetPrintRange(int16_t *aPrintRange);
|
|
|
|
nsresult SetPrintRange(int16_t aPrintRange);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetTitle(PRUnichar **aTitle);
|
|
|
|
nsresult SetTitle(const PRUnichar *aTitle);
|
|
|
|
nsresult GetDocURL(PRUnichar **aDocURL);
|
|
|
|
nsresult SetDocURL(const PRUnichar *aDocURL);
|
|
|
|
nsresult GetHeaderStrLeft(PRUnichar **aHeaderStrLeft);
|
|
|
|
nsresult SetHeaderStrLeft(const PRUnichar *aHeaderStrLeft);
|
|
|
|
nsresult GetHeaderStrCenter(PRUnichar **aHeaderStrCenter);
|
|
|
|
nsresult SetHeaderStrCenter(const PRUnichar *aHeaderStrCenter);
|
|
|
|
nsresult GetHeaderStrRight(PRUnichar **aHeaderStrRight);
|
|
|
|
nsresult SetHeaderStrRight(const PRUnichar *aHeaderStrRight);
|
|
|
|
nsresult GetFooterStrLeft(PRUnichar **aFooterStrLeft);
|
|
|
|
nsresult SetFooterStrLeft(const PRUnichar *aFooterStrLeft);
|
|
|
|
nsresult GetFooterStrCenter(PRUnichar **aFooterStrCenter);
|
|
|
|
nsresult SetFooterStrCenter(const PRUnichar *aFooterStrCenter);
|
|
|
|
nsresult GetFooterStrRight(PRUnichar **aFooterStrRight);
|
|
|
|
nsresult SetFooterStrRight(const PRUnichar *aFooterStrRight);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetHowToEnableFrameUI(int16_t *aHowToEnableFrameUI);
|
|
|
|
nsresult SetHowToEnableFrameUI(int16_t aHowToEnableFrameUI);
|
|
|
|
nsresult GetIsCancelled(bool *aIsCancelled);
|
|
|
|
nsresult SetIsCancelled(bool aIsCancelled);
|
|
|
|
nsresult GetPrintFrameTypeUsage(int16_t *aPrintFrameTypeUsage);
|
|
|
|
nsresult SetPrintFrameTypeUsage(int16_t aPrintFrameTypeUsage);
|
|
|
|
nsresult GetPrintFrameType(int16_t *aPrintFrameType);
|
|
|
|
nsresult SetPrintFrameType(int16_t aPrintFrameType);
|
|
|
|
nsresult GetPrintSilent(bool *aPrintSilent);
|
|
|
|
nsresult SetPrintSilent(bool aPrintSilent);
|
|
|
|
nsresult GetShrinkToFit(bool *aShrinkToFit);
|
|
|
|
nsresult SetShrinkToFit(bool aShrinkToFit);
|
|
|
|
nsresult GetShowPrintProgress(bool *aShowPrintProgress);
|
|
|
|
nsresult SetShowPrintProgress(bool aShowPrintProgress);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetPaperName(PRUnichar **aPaperName);
|
|
|
|
nsresult SetPaperName(const PRUnichar *aPaperName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPaperSizeType(int16_t *aPaperSizeType);
|
|
|
|
nsresult SetPaperSizeType(int16_t aPaperSizeType);
|
|
|
|
nsresult GetPaperData(int16_t *aPaperData);
|
|
|
|
nsresult SetPaperData(int16_t aPaperData);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetPaperWidth(double *aPaperWidth);
|
|
|
|
nsresult SetPaperWidth(double aPaperWidth);
|
|
|
|
nsresult GetPaperHeight(double *aPaperHeight);
|
|
|
|
nsresult SetPaperHeight(double aPaperHeight);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPaperSizeUnit(int16_t *aPaperSizeUnit);
|
|
|
|
nsresult SetPaperSizeUnit(int16_t aPaperSizeUnit);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetPlexName(PRUnichar **aPlexName);
|
|
|
|
nsresult SetPlexName(const PRUnichar *aPlexName);
|
|
|
|
nsresult GetColorspace(PRUnichar **aColorspace);
|
|
|
|
nsresult SetColorspace(const PRUnichar *aColorspace);
|
|
|
|
nsresult GetResolutionName(PRUnichar **aResolutionName);
|
|
|
|
nsresult SetResolutionName(const PRUnichar aResolutionName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDownloadFonts(bool *aDownloadFonts);
|
|
|
|
nsresult SetDownloadFonts(bool aDownloadFonts);
|
|
|
|
nsresult GetPrintReversed(bool *aPrintReversed);
|
|
|
|
nsresult SetPrintReversed(bool aPrintReversed);
|
|
|
|
nsresult GetPrintInColor(bool *aPrintInColor);
|
|
|
|
nsresult SetPrintInColor(bool aPrintInColor);
|
|
|
|
nsresult GetOrientation(int32_t *aOrientation);
|
|
|
|
nsresult SetOrientation(int32_t aOrientation);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetPrintCommand(PRUnichar **aPrintCommand);
|
|
|
|
nsresult SetPrintCommand(const PRUnichar *aPrintCommand);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetNumCopies(int32_t *aNumCopies);
|
|
|
|
nsresult SetNumCopies(int32_t aNumCopies);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetPrinterName(PRUnichar **aPrinterName);
|
|
|
|
nsresult SetPrinterName(const PRUnichar *aPrinterName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPrintToFile(bool *aPrintToFile);
|
|
|
|
nsresult SetPrintToFile(bool aPrintToFile);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetToFileName(PRUnichar **aToFileName);
|
|
|
|
nsresult SetToFileName(const PRUnichar *aToFileName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetOutputFormat(int16_t *aOutputFormat);
|
|
|
|
nsresult SetOutputFormat(int16_t aOutputFormat);
|
|
|
|
nsresult GetPrintPageDelay(int32_t *aPrintPageDelay);
|
|
|
|
nsresult SetPrintPageDelay(int32_t aPrintPageDelay);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetResolution(int32_t *aResolution) = 0;
|
|
|
|
nsresult SetResolution(int32_t aResolution) = 0;
|
|
|
|
nsresult GetDuplex(int32_t *aDuplex);
|
|
|
|
nsresult SetDuplex(int32_t aDuplex);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIsInitializedFromPrinter(bool *aIsInitializedFromPrinter);
|
|
|
|
nsresult SetIsInitializedFromPrinter(bool aIsInitializedFromPrinter);
|
|
|
|
nsresult GetIsInitializedFromPrefs(bool *aIsInitializedFromPrefs);
|
|
|
|
nsresult SetIsInitializedFromPrefs(bool aIsInitializedFromPrefs);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetPersistMarginBoxSettings(bool *aPersistMarginBoxSettings);
|
|
|
|
nsresult SetPersistMarginBoxSettings(bool aPersistMarginBoxSettings);
|
2009-08-09 12:00:11 +00:00
|
|
|
nsresult SetMarginInTwips(nsIntMargin *aMargin);
|
|
|
|
nsresult SetEdgeInTwips(nsIntMargin *aEdge);
|
|
|
|
nsresult GetMarginInTwips(nsIntMargin *aMargin);
|
|
|
|
nsresult GetEdgeInTwips(nsIntMargin *aEdge);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult SetupSilentPrinting();
|
2009-08-09 12:00:11 +00:00
|
|
|
nsresult SetUnwriteableMarginInTwips(nsIntMargin *aEdge);
|
|
|
|
nsresult GetUnwriteableMarginInTwips(nsIntMargin *aEdge);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPageRanges(void * /*nsTArray<int32_t>&*/ aPages);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(9a7ca4b0-fbba-11d4-a869-00105a183419),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWebBrowserPrint : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings);
|
|
|
|
nsresult GetCurrentPrintSettings(nsIPrintSettings **aCurrentPrintSettings);
|
|
|
|
nsresult GetCurrentChildDOMWindow(nsIDOMWindow **aCurrentChildDOMWindow);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDoingPrint(bool *aDoingPrint);
|
|
|
|
nsresult GetDoingPrintPreview(bool *aDoingPrintPreview);
|
|
|
|
nsresult GetIsFramesetDocument(bool *aIsFramesetDocument);
|
|
|
|
nsresult GetIsFramesetFrameSelected(bool *aIsFramesetFrameSelected);
|
|
|
|
nsresult GetIsIFrameSelected(bool *aIsIFrameSelected);
|
|
|
|
nsresult GetIsRangeSelection(bool *aIsRangeSelection);
|
|
|
|
nsresult GetPrintPreviewNumPages(int32_t *aPrintPreviewNumPages);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Print(nsIPrintSettings *aThePrintSettings, nsIWebProgressListener *aWPListener);
|
|
|
|
nsresult PrintPreview(nsIPrintSettings *aThePrintSettings, nsIDOMWindow *aChildDOMWin,
|
|
|
|
nsIWebProgressListener *aWPListener);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult PrintPreviewNavigate(int16_t aNavType, int32_t aPageNum);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Cancel();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult EnumerateDocumentNames(uint32_t *aCount, PRUnichar ***aResult);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult ExitPrintPreview();
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(919e792a-6490-40b8-bba5-f9e9ad5640c8),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIScrollable : nsISupports
|
|
|
|
{
|
|
|
|
enum {
|
|
|
|
ScrollOrientation_X = 1,
|
|
|
|
ScrollOrientation_Y = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
Scrollbar_Auto = 1,
|
|
|
|
Scrollbar_Never = 2,
|
|
|
|
Scrollbar_Always = 3
|
|
|
|
};
|
|
|
|
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetCurScrollPos(int32_t scrollOrientation, int32_t *curPos);
|
|
|
|
nsresult SetCurScrollPos(int32_t scrollOrientation, int32_t curPos);
|
|
|
|
nsresult SetCurScrollPosEx(int32_t curHorizontalPos, int32_t curVerticalPos);
|
|
|
|
nsresult GetScrollRange(int32_t scrollOrientation, int32_t *minPos, int32_t *maxPos);
|
|
|
|
nsresult SetScrollRange(int32_t scrollOrientation, int32_t minPos, int32_t maxPos);
|
|
|
|
nsresult SetScrollRangeEx(int32_t minHorizontalPos, int32_t maxHorizontalPos,
|
|
|
|
int32_t minVerticalPos, int32_t maxVerticalPos);
|
|
|
|
nsresult GetDefaultScrollbarPreferences(int32_t scrollOrientation, int32_t *scrollbarPref);
|
|
|
|
nsresult SetDefaultScrollbarPreferences(int32_t scrollOrientation, int32_t scrollbarPref);
|
|
|
|
nsresult GetScrollbarVisibility(bool *verticalVisible, bool *horizontalVisible);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(272a5020-64f5-485c-a8c4-44b2882ae0a2),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIFile : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
typedef struct {
|
|
|
|
/* Currently not needed */
|
|
|
|
char dummy;
|
|
|
|
} PRFileDesc, PRLibrary, widl_FILE;
|
|
|
|
#define FILE widl_FILE
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Append(const nsAString *node);
|
|
|
|
nsresult AppendNative(const nsAString *node);
|
|
|
|
nsresult Normalize();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Create(uint32_t type, uint32_t permission);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetLeafName(nsAString *aLeafName);
|
|
|
|
nsresult SetLeafName(const nsAString *aLeafName);
|
|
|
|
nsresult GetNativeLeafName(nsAString *aLeafName);
|
|
|
|
nsresult SetNativeLeafName(const nsAString *aLeafName);
|
|
|
|
nsresult CopyTo(nsIFile *newParentDir, const nsAString *newName);
|
|
|
|
nsresult CopyToNative(nsIFile *newParentDir, const nsAString *newName);
|
|
|
|
nsresult CopyToFollowingLinks(nsIFile *newParentDir, const nsAString *newName);
|
|
|
|
nsresult CopyToFollowingLinksNative(nsIFile *newParentDir, const nsAString *newName);
|
|
|
|
nsresult MoveTo(nsIFile *newParentDir, const nsAString *newName);
|
|
|
|
nsresult MoveToNative(nsIFile *newParentDir, const nsAString *newName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Remove(bool recursive);
|
|
|
|
nsresult GetPermissions(uint32_t *aPermissions);
|
|
|
|
nsresult SetPermissions(uint32_t pPermissions);
|
|
|
|
nsresult GetPermissionsOfLink(uint32_t *aPermissions);
|
|
|
|
nsresult SetPermissionsOfLink(uint32_t pPermissions);
|
|
|
|
nsresult GetLastModifiedTime(PRTime *aLastModifiedTime);
|
|
|
|
nsresult SetLastModifiedTime(PRTime aLastModifiedTime);
|
|
|
|
nsresult GetLastModifiedTimeOfLink(PRTime *aLastModifiedTimeOfLink);
|
|
|
|
nsresult SetLastModifiedTimeOfLink(PRTime aLastModifiedTimeOfLink);
|
|
|
|
nsresult GetFileSize(int64_t *aFileSize);
|
|
|
|
nsresult SetFileSize(int64_t aFileSize);
|
|
|
|
nsresult GetFileSizeOfLink(int64_t *aFileSizeOfLink);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetTarget(nsAString *aTarget);
|
|
|
|
nsresult GetNativeTarget(nsACString *aNativeTarget);
|
|
|
|
nsresult GetPath(nsAString *aPath);
|
|
|
|
nsresult GetNativePath(nsACString *aNativePath);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Exists(bool *_retval);
|
|
|
|
nsresult IsWritable(bool *_retval);
|
|
|
|
nsresult IsReadable(bool *_retval);
|
|
|
|
nsresult IsExecutable(bool *_retval);
|
|
|
|
nsresult IsHidden(bool *_retval);
|
|
|
|
nsresult IsDirectory(bool *_retval);
|
|
|
|
nsresult IsFile(bool *_retval);
|
|
|
|
nsresult IsSymlink(bool *_retval);
|
|
|
|
nsresult IsSpecial(bool *_retval);
|
|
|
|
nsresult CreateUnique(uint32_t type, uint32_t permission);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Clone(nsIFile **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Equals(nsIFile *inFile, bool *_retval);
|
|
|
|
nsresult Contains(nsIFile *inFile, bool recir, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetParent(nsIFile **aParent);
|
|
|
|
nsresult GetDirectoryEntries(nsISimpleEnumerator **aDirectoryEntries);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InitWithPath(const nsAString *filePath);
|
|
|
|
nsresult InitWithNativePath(const nsACString *filePath);
|
|
|
|
nsresult InitWithFile(nsIFile *aFile);
|
|
|
|
nsresult GetFollowLinks(bool *aFollowLinks);
|
|
|
|
nsresult SetFollowLinks(bool aFollowLinks);
|
|
|
|
nsresult OpenNSPRFileDesc(int32_t flags, int32_t mode, PRFileDesc **_retval);
|
|
|
|
nsresult OpenANSIFileDesc(const char *mode, FILE **_retval);
|
|
|
|
nsresult Load(PRLibrary **_retval);
|
|
|
|
nsresult GetDiskSpaceAvailable(int64_t *aDiskSpaceAvailable);
|
|
|
|
nsresult AppendRelativePath(const nsAString *relativeFilePath);
|
|
|
|
nsresult AppendRelativeNativePath(const nsACString *relativeFilePath);
|
|
|
|
nsresult GetPersistentDescriptor(nsACString *aPersistentDescriptor);
|
|
|
|
nsresult SetPersistentDescriptor(const nsACString *aPersistentDescriptor);
|
|
|
|
nsresult Reveal();
|
|
|
|
nsresult Launch();
|
|
|
|
nsresult GetRelativeDescriptor(nsIFile *fromFile, nsACString *_retval);
|
|
|
|
nsresult SetRelativeDescriptor(nsIFile *fromFile, const nsACString *relativeDesc);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(1d940426-5fe5-42c3-84ae-a300f2d9ebd5),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIComponentManager : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetClassObject(nsCIDRef aClass, nsIIDRef aIID, void **result);
|
|
|
|
nsresult GetClassObjectByContractID(const char *aContractID, nsIIDRef aIID, void **result);
|
|
|
|
nsresult CreateInstance(nsCIDRef aClass, nsISupports *aDelegate, nsIIDRef aIID,
|
|
|
|
void **result);
|
|
|
|
nsresult CreateInstanceByContractID(const char *aContractID, nsISupports *aDelegate,
|
|
|
|
nsIIDRef aIID, void **result);
|
|
|
|
nsresult AddBootstrappedManifestLocation(nsIFile *aLocation);
|
|
|
|
nsresult RemoveBootstrappedManifestLocation(nsIFile *aLocation);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(55d25e49-793f-4727-a69f-de8b15f4b985),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIPrefBranch : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetRoot(char **aRoot);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetPrefType(const char *aPrefName, int32_t *_retval);
|
|
|
|
nsresult GetBoolPref(const char *aPrefName, bool *_retval);
|
|
|
|
nsresult SetBoolPref(const char *aPrefName, bool aValue);
|
|
|
|
nsresult GetFloatPref(const char *aPrefName, float *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetCharPref(const char *aPrefName, char **_retval);
|
|
|
|
nsresult SetCharPref(const char *aPrefName, const char *aValue);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIntPref(const char *aPrefName, int32_t *_retval);
|
|
|
|
nsresult SetIntPref(const char *aPrefName, int32_t aValue);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetComplexValue(const char *aPrefName, const nsIID *aType, void **aValue);
|
|
|
|
nsresult SetComplexValue(const char *aPrefName, const nsIID *aType, nsISupports *aValue);
|
|
|
|
nsresult ClearUserPref(const char *aPrefName);
|
|
|
|
nsresult LockPref(const char *aPrefName);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult PrefHasUserValue(const char *aPrefName, bool *_retval);
|
|
|
|
nsresult PrefIsLocked(const char *aPrefName, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult UnlockPref(const char *aPrefName);
|
|
|
|
nsresult DeleteBranch(const char *aStartingAt);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetChildList(const char *aStartingAt, uint32_t *aCount, char ***aChildArray);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult ResetBranch(const char *aStartingAt);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult AddObserver(const char *aDomain, nsIObserver *aObserver, bool aHoldWeak);
|
|
|
|
nsresult RemoveObserver(const char *aDomain, nsIObserver *aObserver);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(bbf8cab0-d43a-11d3-8cc2-00609792278c),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDirectoryServiceProvider : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetFile(const char *prop, bool *persistent, nsIFile **_retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(2f977d4b-5485-11d4-87e2-0010a4e75ef2),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDirectoryServiceProvider2 : nsIDirectoryServiceProvider
|
|
|
|
{
|
|
|
|
nsresult GetFiles(const char *prop, nsISimpleEnumerator **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(f5753fec-a051-4ddc-8891-11f1f1575072),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIProtocolHandler : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetScheme(nsACString *aScheme);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetDefaultPort(int32_t *aDefaultPort);
|
|
|
|
nsresult GetProtocolFlags(uint32_t *aProtocolFlags);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset,
|
|
|
|
nsIURI *aBaseURI, nsIURI **_retval);
|
|
|
|
nsresult NewChannel(nsIURI *aURI, nsIChannel **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult AllowPort(int32_t port, const char *scheme, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(0e61f3b2-34d7-4c79-bfdc-4860bc7341b7),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIExternalProtocolHandler : nsIProtocolHandler
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult ExternalAppExistsForScheme(const nsACString *scheme, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(bddeda3f-9020-4d12-8c70-984ee9f7935e),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIIOService : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetProtocolHandler(const char *aScheme, nsIProtocolHandler **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetProtocolFlags(const char *aScheme, uint32_t *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
|
|
|
|
nsIURI **_retval);
|
|
|
|
nsresult NewFileURI(nsIFile *aFile, nsIURI **_retval);
|
|
|
|
nsresult NewChannelFromURI(nsIURI *aURI, nsIChannel **_retval);
|
|
|
|
nsresult NewChannel(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
|
|
|
|
nsIChannel **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetOffline(bool *aOffline);
|
|
|
|
nsresult SetOffline(bool aOffline);
|
|
|
|
nsresult AllowPort(int32_t aPort, const char *aScheme, bool *_retval);
|
|
|
|
nsresult ExtractScheme(const nsACString *urlString, nsACString *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(ca68c485-9db3-4c12-82a6-4fab7948e2d5),
|
2008-04-11 12:45:31 +00:00
|
|
|
local,
|
|
|
|
]
|
|
|
|
interface nsINetUtil : nsISupports
|
|
|
|
{
|
|
|
|
nsresult ParseContentType(const nsACString *aTypeHeader, nsACString *aCharset,
|
2013-05-19 21:21:20 +00:00
|
|
|
bool *aHadCharset, nsACString *_retval);
|
|
|
|
nsresult ProtocolHasFlags(nsIURI *aURI, uint32_t aFlag, bool *_retval);
|
|
|
|
nsresult URIChainHasFlags(nsIURI *aURI, uint32_t aFlags, bool *_retval);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult ToImmutableURI(nsIURI *aURI, nsIURI **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult NewSimpleNestedURI(nsIURI *aURI, nsIURI **_retval);
|
|
|
|
nsresult EscapeString(const nsACString *aString, uint32_t aEscapeType, nsACString *_retval);
|
|
|
|
nsresult EscapeURL(const nsACString *aStr, uint32_t aFlags, nsACString *_retval);
|
|
|
|
nsresult UnescapeString(const nsACString *aStr, uint32_t aFlags, nsACString *_retval);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult ExtractCharsetFromContentType(const nsACString *aTypeHeader, nsACString *aCharset,
|
2013-05-19 21:21:20 +00:00
|
|
|
int32_t *aCharsetStart, int32_t *aCharsetEnd, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(9c5d3c58-1dd1-11b2-a1c9-f3699284657a),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWebBrowserFocus : nsISupports
|
|
|
|
{
|
|
|
|
nsresult Activate();
|
|
|
|
nsresult Deactivate();
|
|
|
|
nsresult SetFocusAtFirstElement();
|
|
|
|
nsresult SetFocusAtLastElement();
|
|
|
|
nsresult GetFocusedWindow(nsIDOMWindow **aFocusedWindow);
|
|
|
|
nsresult SetFocusedWindow(nsIDOMWindow *aFocusedWindow);
|
|
|
|
nsresult GetFocusedElement(nsIDOMElement **aFocusedElement);
|
|
|
|
nsresult SetFocusedElement(nsIDOMElement *aFocusedElement);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(e8c414c4-dc38-4ba3-ab4e-ec4cbbe22907),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIWebBrowserChrome : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetStatus(uint32_t statusType, const PRUnichar *status);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetWebBrowser(nsIWebBrowser **aWebBrowser);
|
|
|
|
nsresult SetWebBrowser(nsIWebBrowser *aWebBrowser);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetChromeFlags(uint32_t *aChromeFlags);
|
|
|
|
nsresult SetChromeFlags(uint32_t aChromeFlags);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult DestroyBrowserWindow();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SizeBrowserTo(int32_t aCX, int32_t aCY);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult ShowAsModal();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult IsWindowModal(bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult ExitModalEventLoop(nsresult aStatus);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(df31c120-ded6-11d1-bd85-00805f8ae3f4),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMEventListener : nsISupports
|
|
|
|
{
|
|
|
|
nsresult HandleEvent(nsIDOMEvent *event);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(31e92e56-4d23-4a4a-9cfe-a6d12cf434bc),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMEventTarget : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult AddEventListener(const nsAString *type, nsIDOMEventListener *listener, bool useCapture, bool wantsUntrusted, uint8_t _argc);
|
|
|
|
nsresult AddSystemEventListener(const nsAString *type, nsIDOMEventListener *listener, bool aUseCapture, bool aWantsUntrusted, uint8_t _argc);
|
|
|
|
nsresult RemoveEventListener(const nsAString *type, nsIDOMEventListener *listener, bool useCapture);
|
|
|
|
nsresult RemoveSystemEventListener(const nsAString *type, nsIDOMEventListener *listener, bool aUseCapture);
|
|
|
|
nsresult DispatchEvent(nsIDOMEvent *evt, bool *_retval);
|
|
|
|
|
|
|
|
/* Followed by methods we should try to avoid using */
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(02d54f52-a1f5-4ad2-b560-36f14012935e),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMEvent : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetType(nsAString *aType);
|
|
|
|
nsresult GetTarget(nsIDOMEventTarget **aTarget);
|
|
|
|
nsresult GetCurrentTarget(nsIDOMEventTarget **aCurrentTarget);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetEventPhase(uint16_t *aEventPhase);
|
|
|
|
nsresult GetBubbles(bool *aBubbles);
|
|
|
|
nsresult GetCancelable(bool *aCancelable);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetTimeStamp(DOMTimeStamp *aTimeStamp);
|
|
|
|
nsresult StopPropagation();
|
|
|
|
nsresult PreventDefault();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InitEvent(const nsAString *eventTypeArg, bool canBubbleArg, bool cancelableArg);
|
|
|
|
nsresult GetDefaultPrevented(bool *aDefaultPrevented);
|
|
|
|
nsresult StopImmediatePropagation();
|
|
|
|
nsresult GetOriginalTarget(nsIDOMEventTarget **aOriginalTarget);
|
|
|
|
nsresult GetExplicitOriginalTarget(nsIDOMEventTarget * *aExplicitOriginalTarget);
|
|
|
|
nsresult GetPreventDefault(bool *_retval);
|
|
|
|
nsresult GetIsTrusted(bool *aIsTrusted);
|
|
|
|
nsresult DuplicatePrivateData();
|
|
|
|
nsresult SetTarget(nsIDOMEventTarget *aTarget);
|
|
|
|
bool IsDispatchStopped();
|
|
|
|
/*nsEvent*/ void *GetInternalNSEvent();
|
2013-10-07 14:22:37 +00:00
|
|
|
void SetTrusted(bool aTrusted);
|
2013-05-19 21:21:20 +00:00
|
|
|
void Serialize(/*IPC::Message*/ void *aMsg, bool aSerializeInterfaceType);
|
|
|
|
bool Deserialize(const /*IPC::Message*/ void *aMsg, void **aIter);
|
2014-04-26 18:30:09 +00:00
|
|
|
void SetOwner(void /*mozilla::dom::EventTarget*/ *aOwner);
|
|
|
|
void /*nsDOMEvent*/ *InternalDOMEvent();
|
2013-05-19 21:21:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(cbe333d7-5b2c-4a9b-b99b-e6e388afa62b),
|
2013-05-19 21:21:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMWindowUtils : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetImageAnimationMode(uint16_t *aImageAnimationMode);
|
|
|
|
nsresult SetImageAnimationMode(uint16_t aImageAnimationMode);
|
|
|
|
nsresult GetDocCharsetIsForced(bool *aDocCharsetIsForced);
|
|
|
|
nsresult GetCursorType(int16_t *_retval);
|
|
|
|
nsresult GetDocumentMetadata(const nsAString *aName, nsAString *_retval);
|
|
|
|
nsresult Redraw(uint32_t aCount, uint32_t *_retval);
|
|
|
|
nsresult SetCSSViewport(float aWidthPx, float aHeightPx);
|
|
|
|
nsresult GetViewportInfo(uint32_t aDisplayWidth, uint32_t aDisplayHeight, double *aDefaultZoom, bool *aAllowZoom,
|
|
|
|
double *aMinZoom, double *aMaxZoom, uint32_t *aWidth, uint32_t *aHeight, bool *aAutoSize);
|
|
|
|
nsresult SetDisplayPortForElement(float aXPx, float aYPx, float aWidthPx, float aHeightPx, nsIDOMElement *aElement);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult SetCriticalDisplayPortForElement(float aXPx, float aYPx, float aWidthPx, float aHeightPx, nsIDOMElement *aElement);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetResolution(float aXResolution, float aYResolution);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetResolution(float *aXResolution, float *aYResolution);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIsFirstPaint(bool *aIsFirstPaint);
|
|
|
|
nsresult SetIsFirstPaint(bool aIsFirstPaint);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetPresShellId(uint32_t *aPresShellId);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SendMouseEvent(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
|
2013-10-07 14:22:37 +00:00
|
|
|
int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, bool *_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SendTouchEvent(const nsAString *aType, uint32_t *aIdentifiers, int32_t *aXs, int32_t *aYs,
|
|
|
|
uint32_t *aRxs, uint32_t *aRys, float *aRotationAngles, float *aForces, uint32_t count, int32_t aModifiers,
|
|
|
|
bool aIgnoreRootScrollFrame, bool *_retval);
|
|
|
|
nsresult SendMouseEventToWindow(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
|
|
|
|
int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg);
|
|
|
|
nsresult SendWheelEvent(float aX, float aY, double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aDeltaMode,
|
|
|
|
int32_t aModifiers, int32_t aLineOrPageDeltaX, int32_t aLineOrPageDeltaY, uint32_t aOptions);
|
|
|
|
nsresult SendKeyEvent(const nsAString *aType, int32_t aKeyCode, int32_t aCharCode, int32_t aModifiers,
|
|
|
|
uint32_t aAdditionalFlags, bool *_retval);
|
|
|
|
nsresult SendNativeKeyEvent(int32_t aNativeKeyboardLayout, int32_t aNativeKeyCode, int32_t aModifierFlags,
|
|
|
|
const nsAString *aCharacters, const nsAString *aUnmodifiedCharacters);
|
|
|
|
nsresult SendNativeMouseEvent(int32_t aScreenX, int32_t aScreenY, int32_t aNativeMessage, int32_t aModifierFlags,
|
|
|
|
nsIDOMElement *aElement);
|
|
|
|
nsresult SendNativeMouseScrollEvent(int32_t aScreenX, int32_t aScreenY, uint32_t aNativeMessage, double aDeltaX,
|
|
|
|
double aDeltaY, double aDeltaZ, uint32_t aModifierFlags, uint32_t aAdditionalFlags, nsIDOMElement *aElement);
|
|
|
|
nsresult ActivateNativeMenuItemAt(const nsAString *indexString);
|
|
|
|
nsresult ForceUpdateNativeMenuAt(const nsAString *indexString);
|
|
|
|
nsresult Focus(nsIDOMElement *aElement);
|
|
|
|
nsresult GarbageCollect(nsICycleCollectorListener *aListener, int32_t aExtraForgetSkippableCalls);
|
|
|
|
nsresult CycleCollect(nsICycleCollectorListener *aListener, int32_t aExtraForgetSkippableCalls);
|
|
|
|
nsresult SendSimpleGestureEvent(const nsAString *aType, float aX, float aY, uint32_t aDirection, double aDelta,
|
|
|
|
int32_t aModifiers, uint32_t aClickCount);
|
|
|
|
nsresult ElementFromPoint(float aX, float aY, bool aIgnoreRootScrollFrame, bool aFlushLayout, nsIDOMElement **_retval);
|
|
|
|
nsresult NodesFromRect(float aX, float aY, float aTopSize, float aRightSize, float aBottomSize, float aLeftSize,
|
|
|
|
bool aIgnoreRootScrollFrame, bool aFlushLayout, nsIDOMNodeList **_retval);
|
|
|
|
nsresult CompareCanvases(nsIDOMHTMLCanvasElement *aCanvas1, nsIDOMHTMLCanvasElement *aCanvas2,
|
|
|
|
uint32_t *aMaxDifference, uint32_t *_retval);
|
|
|
|
nsresult GetIsMozAfterPaintPending(bool *aIsMozAfterPaintPending);
|
|
|
|
nsresult SuppressEventHandling(bool aSuppress);
|
|
|
|
nsresult ClearMozAfterPaintEvents();
|
|
|
|
nsresult DisableNonTestMouseEvents(bool aDisable);
|
|
|
|
nsresult GetScrollXY(bool aFlushLayout, int32_t *aScrollX, int32_t *aScrollY);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetScrollbarSize(bool aFlushLayout, int32_t *aWidth, int32_t *aHeight);
|
|
|
|
nsresult GetBoundsWithoutFlushing(nsIDOMElement *aElement, nsIDOMClientRect **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetRootBounds(nsIDOMClientRect **_retval);
|
|
|
|
nsresult GetIMEIsOpen(bool *aIMEIsOpen);
|
|
|
|
nsresult GetIMEStatus(uint32_t *aIMEStatus);
|
|
|
|
nsresult GetScreenPixelsPerCSSPixel(float *aScreenPixelsPerCSSPixel);
|
|
|
|
nsresult GetFullZoom(float *aFullZoom);
|
|
|
|
nsresult DispatchDOMEventViaPresShell(nsIDOMNode *aTarget, nsIDOMEvent *aEvent, bool aTrusted, bool *_retval);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult DispatchEventToChromeOnly(nsIDOMEventTarget *aTarget, nsIDOMEvent *aEvent, bool *_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetClassName(const /*JS::Value*/ void *aObject, JSContext *cx, char **_retval);
|
|
|
|
nsresult SendContentCommandEvent(const nsAString *aType, nsITransferable *aTransferable);
|
|
|
|
nsresult SendCompositionEvent(const nsAString *aType, const nsAString *aData, const nsAString *aLocale);
|
|
|
|
nsresult SendTextEvent(const nsAString *aCompositionString, int32_t aFirstClauseLength, uint32_t aFirstClauseAttr,
|
|
|
|
int32_t aSecondClauseLength, uint32_t aSecondClauseAttr, int32_t aThirdClauseLength, uint32_t aThirdClauseAttr,
|
|
|
|
int32_t aCaretStart, int32_t aCaretLength);
|
|
|
|
nsresult SendQueryContentEvent(uint32_t aType, uint32_t aOffset, uint32_t aLength, int32_t aX, int32_t aY,
|
|
|
|
nsIQueryContentEventResult **_retval);
|
|
|
|
nsresult RemoteFrameFullscreenChanged(nsIDOMElement *aFrameElement, const nsAString *aNewOrigin);
|
|
|
|
nsresult RemoteFrameFullscreenReverted();
|
|
|
|
nsresult ExitFullscreen();
|
|
|
|
nsresult SendSelectionSetEvent(uint32_t aOffset, uint32_t aLength, bool aReverse, bool *_retval);
|
|
|
|
nsresult SelectAtPoint(float aX, float aY, uint32_t aSelectBehavior, bool *_retval);
|
|
|
|
nsresult GetVisitedDependentComputedStyle(nsIDOMElement *aElement, const nsAString *aPseudoElement,
|
|
|
|
const nsAString *aPropertyName, nsAString *_retval);
|
|
|
|
nsresult GetParent(const /*JS::Value*/ void *obj, JSContext *cx, /*JS::Value*/ void *_retval);
|
|
|
|
nsresult GetOuterWindowID(uint64_t *aOuterWindowID);
|
|
|
|
nsresult GetCurrentInnerWindowID(uint64_t *aCurrentInnerWindowID);
|
|
|
|
nsresult EnterModalState();
|
|
|
|
nsresult LeaveModalState();
|
|
|
|
nsresult EnterModalStateWithWindow(nsIDOMWindow **_retval);
|
|
|
|
nsresult LeaveModalStateWithWindow(nsIDOMWindow *aWindow);
|
|
|
|
nsresult IsInModalState(bool *_retval);
|
|
|
|
nsresult SuspendTimeouts();
|
|
|
|
nsresult ResumeTimeouts();
|
|
|
|
nsresult GetLayerManagerType(nsAString *aLayerManagerType);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetLayerManagerRemote(bool *aLayerManagerRemote);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult StartFrameTimeRecording(uint32_t *startIndex);
|
|
|
|
nsresult StopFrameTimeRecording(uint32_t startIndex, float **paintTimes, uint32_t *frameCount, float **frameIntervals);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult BeginTabSwitch();
|
|
|
|
nsresult GetDisplayDPI(float *aDisplayDPI);
|
|
|
|
nsresult GetOuterWindowWithId(uint64_t aOuterWindowID, nsIDOMWindow **_retval);
|
|
|
|
nsresult RenderDocument(const void /*nsRect*/ *aRect, uint32_t aFlags, int /*nscolor*/ aBackgroundColor,
|
|
|
|
void /*gfxContext*/ *aThebesContext);
|
|
|
|
nsresult AdvanceTimeAndRefresh(int64_t aMilliseconds);
|
|
|
|
nsresult RestoreNormalRefresh();
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetIsTestControllingRefreshes(bool *aIsTestControllingRefreshes);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult ComputeAnimationDistance(nsIDOMElement *element, const nsAString *property, const nsAString *value1,
|
|
|
|
const nsAString *value2, double *_retval);
|
|
|
|
nsresult WrapDOMFile(nsIFile *aFile, nsIDOMFile **_retval);
|
|
|
|
nsresult GetFocusedInputType(char **aFocusedInputType);
|
|
|
|
nsresult FindElementWithViewId(long /*nsViewID*/ aId, nsIDOMElement **_retval);
|
|
|
|
nsresult LeafLayersPartitionWindow(bool *_retval);
|
|
|
|
nsresult GetMayHaveTouchEventListeners(bool *aMayHaveTouchEventListeners);
|
|
|
|
nsresult CheckAndClearPaintedState(nsIDOMElement *aElement, bool *_retval);
|
|
|
|
nsresult GetFile(const nsAString *aName, const /*JS::Value*/ void *aBlobParts, const /*JS::Value*/ void *aParameters,
|
|
|
|
JSContext* cx, uint8_t _argc, nsIDOMFile **_retval);
|
|
|
|
nsresult GetBlob(const /*JS::Value*/ void *aBlobParts, const /*JS::Value*/ void *aParameters, JSContext *cx,
|
|
|
|
uint8_t _argc, nsIDOMBlob * _retval);
|
|
|
|
nsresult GetFileId(const /*JS::Value*/ void *aFile, JSContext *cx, int64_t *_retval);
|
|
|
|
nsresult GetFileReferences(const nsAString *aDatabaseName, int64_t aId, int32_t *aRefCnt, int32_t *aDBRefCnt,
|
|
|
|
int32_t *aSliceRefCnt, bool *_retval);
|
|
|
|
nsresult IsIncrementalGCEnabled(JSContext *cx, bool *_retval);
|
|
|
|
nsresult StartPCCountProfiling(JSContext *cx);
|
|
|
|
nsresult StopPCCountProfiling(JSContext *cx);
|
|
|
|
nsresult PurgePCCounts(JSContext *cx);
|
|
|
|
nsresult GetPCCountScriptCount(JSContext *cx, int32_t *_retval);
|
|
|
|
nsresult GetPCCountScriptSummary(int32_t script, JSContext *cx, nsAString *_retval);
|
|
|
|
nsresult GetPCCountScriptContents(int32_t script, JSContext *cx, nsAString *_retval);
|
|
|
|
nsresult GetPaintingSuppressed(bool *aPaintingSuppressed);
|
|
|
|
nsresult GetPlugins(JSContext *cx, /*JS::Value*/ void *aPlugins);
|
|
|
|
nsresult SetScrollPositionClampingScrollPortSize(float aWidth, float aHeight);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult SetContentDocumentFixedPositionMargins(float aTop, float aRight, float aBottom, float aLeft);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult PreventFurtherDialogs();
|
|
|
|
nsresult LoadSheet(nsIURI *sheetURI, uint32_t type);
|
|
|
|
nsresult RemoveSheet(nsIURI *sheetURI, uint32_t type);
|
|
|
|
nsresult GetIsHandlingUserInput(bool *aIsHandlingUserInput);
|
|
|
|
nsresult AllowScriptsToClose();
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetIsParentWindowMainWidgetVisible(bool *aIsParentWindowMainWidgetVisible);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult IsNodeDisabledForEvents(nsIDOMNode *aNode, bool *_retval);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetPaintFlashing(bool *aPaintFlashing);
|
|
|
|
nsresult SetPaintFlashing(bool aPaintFlashing);
|
|
|
|
nsresult RunInStableState(nsIRunnable *runnable);
|
|
|
|
nsresult RunBeforeNextEvent(nsIRunnable *runnable);
|
|
|
|
nsresult GetOMTAOrComputedStyle(nsIDOMNode *aNode, const nsAString *aProperty, nsAString *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cpp_quote("#define CONTEXT_NONE 0x00")
|
|
|
|
cpp_quote("#define CONTEXT_LINK 0x01")
|
|
|
|
cpp_quote("#define CONTEXT_IMAGE 0x02")
|
|
|
|
cpp_quote("#define CONTEXT_DOCUMENT 0x04")
|
|
|
|
cpp_quote("#define CONTEXT_TEXT 0x08")
|
|
|
|
cpp_quote("#define CONTEXT_INPUT 0x10")
|
|
|
|
cpp_quote("#define CONTEXT_BACKGROUND_IMAGE 0x20")
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(3478b6b0-3875-11d4-94ef-0020183bf181),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIContextMenuListener : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult OnShowContextMenu(uint32_t aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(d73852f8-7bd6-477d-8233-117dbf83860b),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMUIEvent : nsIDOMEvent
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetView(nsIDOMWindow **aView);
|
|
|
|
nsresult GetDetail(int32_t *aDetail);
|
|
|
|
nsresult InitUIEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
|
|
|
|
nsIDOMWindow *viewArg, int32_t detailArg);
|
|
|
|
nsresult GetLayerX(int32_t *aLayerX);
|
|
|
|
nsresult GetLayerY(int32_t *aLayerY);
|
|
|
|
nsresult GetPageX(int32_t *aPageX);
|
|
|
|
nsresult GetPageY(int32_t *aPageY);
|
|
|
|
nsresult GetWhich(uint32_t *aWhich);
|
|
|
|
nsresult GetRangeParent(nsIDOMNode **aRangeParent);
|
|
|
|
nsresult GetRangeOffset(int32_t *aRangeOffset);
|
|
|
|
nsresult GetCancelBubble(bool *aCancelBubble);
|
|
|
|
nsresult SetCancelBubble(bool aCancelBubble);
|
|
|
|
nsresult GetIsChar(bool *aIsChar);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(afb2e57b-2822-4969-b2a9-0cada6859534),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMMouseEvent : nsIDOMUIEvent
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetScreenX(int32_t *aScreenX);
|
|
|
|
nsresult GetScreenY(int32_t *aScreenY);
|
|
|
|
nsresult GetMozMovementX(int32_t *aMozMovementX);
|
|
|
|
nsresult GetMozMovementY(int32_t *aMozMovementY);
|
|
|
|
nsresult GetClientX(int32_t *aClientX);
|
|
|
|
nsresult GetClientY(int32_t *aClientY);
|
|
|
|
nsresult GetCtrlKey(bool *aCtrlKey);
|
|
|
|
nsresult GetShiftKey(bool *aShiftKey);
|
|
|
|
nsresult GetAltKey(bool *aAltKey);
|
|
|
|
nsresult GetMetaKey(bool *aMetaKey);
|
|
|
|
nsresult GetButton(uint16_t *aButton);
|
|
|
|
nsresult GetButtons(uint16_t *aButtons);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetRelatedTarget(nsIDOMEventTarget **aRelatedTarget);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InitMouseEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
|
|
|
|
nsIDOMWindow *viewArg, int32_t detailArg, int32_t screenXArg, int32_t screenYArg,
|
|
|
|
int32_t clientXArg, int32_t clientYArg, bool ctrlKeyArg, bool altKeyArg,
|
|
|
|
bool shiftKeyArg, bool metaKeyArg, uint16_t buttonArg,
|
2008-04-11 12:45:31 +00:00
|
|
|
nsIDOMEventTarget *relatedTargetArg);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetMozPressure(float *aMozPressure);
|
|
|
|
nsresult GetMozInputSource(uint16_t *aMozInputSource);
|
|
|
|
nsresult InitNSMouseEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
|
|
|
|
nsIDOMWindow *viewArg, int32_t detailArg, int32_t screenXArg, int32_t screenYArg,
|
|
|
|
int32_t clientXArg, int32_t clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg,
|
|
|
|
bool metaKeyArg, uint16_t buttonArg, nsIDOMEventTarget *relatedTargetArg, float pressure,
|
|
|
|
uint16_t inputSourceArg);
|
|
|
|
nsresult GetModifierState(const nsAString *keyArg, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(91a3d7f2-223b-4e09-a566-634e7ee0a31d),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDOMKeyEvent : nsIDOMUIEvent
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetCharCode(uint32_t *aCharCode);
|
|
|
|
nsresult GetKeyCode(uint32_t *aKeyCode);
|
|
|
|
nsresult GetAltKey(bool *aAltKey);
|
|
|
|
nsresult GetCtrlKey(bool *aCtrlKey);
|
|
|
|
nsresult GetShiftKey(bool *aShiftKey);
|
|
|
|
nsresult GetMetaKey(bool *aMetaKey);
|
|
|
|
nsresult InitKeyEvent(const nsAString *typeArg, bool canBubbleArg,
|
|
|
|
bool cancelableArg, nsIDOMWindow *viewArg, bool ctrlKeyArg,
|
|
|
|
bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, uint32_t keyCodeArg,
|
|
|
|
uint32_t charCodeArg);
|
|
|
|
nsresult GetModifierState(const nsAString *keyArg, bool *_retval);
|
|
|
|
nsresult GetLocation(uint32_t *aLocation);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetKey(nsAString *aKey);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(0b976267-4aaa-4f36-a2d4-27b5ca8d73bb),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIEmbeddingSiteWindow : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetDimensions(uint32_t flags, int32_t x, int32_t y, int32_t cx, int32_t cy);
|
|
|
|
nsresult GetDimensions(uint32_t flags, int32_t *x, int32_t *y, int32_t *cx, int32_t *cy);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SetFocus();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetVisibility(bool *aVisibility);
|
|
|
|
nsresult SetVisibility(bool aVisibility);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetTitle(PRUnichar **aTitle);
|
|
|
|
nsresult SetTitle(const PRUnichar *aTitle);
|
|
|
|
nsresult GetSiteWindow(void **aSiteWindow);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Blur();
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(2417cbfe-65ad-48a6-b4b6-eb84db174392),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIComponentRegistrar : nsISupports
|
|
|
|
{
|
|
|
|
nsresult AutoRegister(nsIFile *aSpec);
|
|
|
|
nsresult AutoUnregister(nsIFile *aSpec);
|
|
|
|
nsresult RegisterFactory(const nsCID *aClass, const char *aClassName,
|
|
|
|
const char *aContractID, nsIFactory *aFactory);
|
|
|
|
nsresult UnregisterFactory(const nsCID *aClass, nsIFactory *aFactory);
|
|
|
|
nsresult RegisterFactoryLocation(const nsCID *aClass, const char *aClassName,
|
|
|
|
const char *aContractID, nsIFile *aFile, const char *aLoaderStr,
|
|
|
|
const char *aType);
|
|
|
|
nsresult UnregisterFactoryLocation(const nsCID *aClass, nsIFile *aFile);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult IsCIDRegistered(const nsCID *aClass, bool *_retval);
|
|
|
|
nsresult IsContractIDRegistered(const char *aContractID, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult EnumerateCIDs(nsISimpleEnumerator **_retval);
|
|
|
|
nsresult EnumerateContractIDs(nsISimpleEnumerator **_retval);
|
|
|
|
nsresult CIDToContractID(const nsCID *aClass, char **_retval);
|
|
|
|
nsresult ContractIDToCID(const char *aContractID, nsCID **_retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(1630c61a-325e-49ca-8759-a31b16c47aa5),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIPromptService : nsISupports
|
|
|
|
{
|
|
|
|
nsresult Alert(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
|
|
|
const PRUnichar *aText);
|
|
|
|
nsresult AlertCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
2013-05-19 21:21:20 +00:00
|
|
|
const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Confirm(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
2013-05-19 21:21:20 +00:00
|
|
|
const PRUnichar *aText, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult ConfirmCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
2013-05-19 21:21:20 +00:00
|
|
|
const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState,
|
|
|
|
bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult ConfirmEx(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
2013-05-19 21:21:20 +00:00
|
|
|
const PRUnichar *aText, uint32_t aButtonFlags, const PRUnichar *aButton0Title,
|
2008-04-11 12:45:31 +00:00
|
|
|
const PRUnichar *aButton1Title, const PRUnichar *aButton2Title,
|
2013-05-19 21:21:20 +00:00
|
|
|
const PRUnichar *aCheckMsg, bool *aCheckState, int32_t *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Prompt(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
|
|
|
const PRUnichar *aText, PRUnichar **aValue, const PRUnichar *aCheckMsg,
|
2013-05-19 21:21:20 +00:00
|
|
|
bool *aCheckState, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult PromptUsernameAndPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
|
|
|
const PRUnichar *aText, PRUnichar **aUsername, PRUnichar **aPassword,
|
2013-05-19 21:21:20 +00:00
|
|
|
const PRUnichar *aCheckMsg, bool *aCheckState, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult PromptPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
|
|
|
const PRUnichar *aText, PRUnichar **aPassword, const PRUnichar *aCheckMsg,
|
2013-05-19 21:21:20 +00:00
|
|
|
bool *aCheckState, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Select(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
|
2013-05-19 21:21:20 +00:00
|
|
|
const PRUnichar *aText, uint32_t aCount, const PRUnichar **aSelectList,
|
|
|
|
int32_t *aOutSelection, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(b128a1e6-44f3-4331-8fbe-5af360ff21ee),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsITooltipTextProvider : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetNodeText(nsIDOMNode *aNode, PRUnichar **aText, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(24f3f4da-18a4-448d-876d-7360fefac029),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIEditingSession : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetEditorStatus(uint32_t *aEditorStatus);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult MakeWindowEditable(nsIDOMWindow *window, const char *aEditorType,
|
2013-05-19 21:21:20 +00:00
|
|
|
bool doAfterUriLoad, bool aMakeWholeDocumentEditable, bool aInteractive);
|
|
|
|
nsresult WindowIsEditable(nsIDOMWindow *window, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetEditorForWindow(nsIDOMWindow *window, nsIEditor **_retval);
|
|
|
|
nsresult SetupEditorOnWindow(nsIDOMWindow *window);
|
|
|
|
nsresult TearDownEditorOnWindow(nsIDOMWindow *window);
|
|
|
|
nsresult SetEditorOnControllers(nsIDOMWindow *aWindow, nsIEditor *aEditor);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult DisableJSAndPlugins(nsIDOMWindow *aWindow);
|
|
|
|
nsresult RestoreJSAndPlugins(nsIDOMWindow *aWindow);
|
|
|
|
nsresult DetachFromWindow(nsIDOMWindow *aWindow);
|
|
|
|
nsresult ReattachToWindow(nsIDOMWindow *aWindow);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetJsAndPluginsDisabled(bool *aJsAndPluginsDisabled);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(83f892cf-7ed3-490e-967a-62640f3158e1),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsICommandParams : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetValueType(const char *name, int16_t *_retval);
|
|
|
|
nsresult GetBooleanValue(const char *name, bool *_retval);
|
|
|
|
nsresult GetLongValue(const char *name, int32_t *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetDoubleValue(const char *name, double *_retval);
|
|
|
|
nsresult GetStringValue(const char *name, nsAString *_retval);
|
|
|
|
nsresult GetCStringValue(const char *name, char **_retval);
|
|
|
|
nsresult GetISupportsValue(const char *name, nsISupports **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetBooleanValue(const char *name, bool value);
|
|
|
|
nsresult SetLongValue(const char *name, int32_t value);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SetDoubleValue(const char *name, double value);
|
|
|
|
nsresult SetStringValue(const char *name, const nsAString *value);
|
|
|
|
nsresult SetCStringValue(const char *name, const char *value);
|
|
|
|
nsresult SetISupportsValue(const char *name, nsISupports *value);
|
|
|
|
nsresult RemoveValue(const char *name);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult HasMoreElements(bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult First();
|
|
|
|
nsresult GetNext(char **_retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(080d2001-f91e-11d4-a73c-f9242928207c),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsICommandManager : nsISupports
|
|
|
|
{
|
|
|
|
nsresult AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve);
|
|
|
|
nsresult RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult IsCommandSupported(const char *aCommandName, nsIDOMWindow *aTargetWindow, bool *_retval);
|
|
|
|
nsresult IsCommandEnabled(const char *aCommandName, nsIDOMWindow *aTargetWindow, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetCommandState(const char *aCommandName, nsIDOMWindow *aTargetWindow,
|
|
|
|
nsICommandParams *aCommandParams);
|
|
|
|
nsresult DoCommand(const char *aCommandName, nsICommandParams *aCommandParams,
|
|
|
|
nsIDOMWindow *aTargetWindow);
|
|
|
|
}
|
|
|
|
|
2014-04-26 18:30:09 +00:00
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(3275b2cd-af6d-429a-80d7-f0c5120342ac),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsICategoryManager : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetCategoryEntry(const char *aCategory, const char *aEntry, char **_retval);
|
|
|
|
nsresult AddCategoryEntry(const char *aCategory, const char *aEntry, const char *aValue, bool aPersist,
|
|
|
|
bool aReplace, char **_retval);
|
|
|
|
nsresult DeleteCategoryEntry(const char *aCategory, const char *aEntry, bool aPersist);
|
|
|
|
nsresult DeleteCategory(const char *aCategory);
|
|
|
|
nsresult EnumerateCategory(const char *aCategory, nsISimpleEnumerator **_retval);
|
|
|
|
nsresult EnumerateCategories(nsISimpleEnumerator **_retval);
|
|
|
|
}
|
|
|
|
|
2008-04-11 12:45:31 +00:00
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(47b82b60-a36f-4167-8072-6f421151ed50),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIControllerContext : nsISupports
|
|
|
|
{
|
|
|
|
nsresult Init(nsIControllerCommandTable *aCommandTable);
|
|
|
|
nsresult SetCommandContext(nsISupports *aCommandContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(d5b61b82-1da4-11d3-bf87-00105a1b0627),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIController : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult IsCommandEnabled(const char *command, bool *_retval);
|
|
|
|
nsresult SupportsCommand(const char *command, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult DoCommand(const char *command);
|
|
|
|
nsresult OnEvent(const char *eventName);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(8a8b4b1d-72d8-428e-9575-f918baf69ea1),
|
2013-05-19 21:21:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIContent : nsISupports
|
|
|
|
{
|
|
|
|
/* This is not a real interface declaration. It's too internal for us. */
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(62cca591-a030-4117-9b80-dcd366bbb509),
|
2013-05-19 21:21:20 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDocument : nsISupports
|
|
|
|
{
|
|
|
|
/* This is not a real interface declaration. It's too internal for us. */
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(b1ee32f2-b8c4-49b9-93df-b6fab5d54688),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIContentSerializer : nsISupports
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Init(uint32_t flags, uint32_t aWrapColumn, const char *aCharSet, bool aIsCopying,
|
|
|
|
bool aIsWholeDocument);
|
|
|
|
nsresult AppendText(nsIContent *aText, int32_t aStartOffset, int32_t aEndOffset, nsAString *aStr);
|
|
|
|
nsresult AppendCDATASection(nsIContent *aCDATASection, int32_t aStartOffset,
|
|
|
|
int32_t aEndOffset, nsAString *aStr);
|
|
|
|
nsresult AppendProcessingInstruction(nsIContent *aPI, int32_t aStartOffset,
|
|
|
|
int32_t aEndOffset, nsAString *aStr);
|
|
|
|
nsresult AppendComment(nsIContent *aComment, int32_t aStartOffset, int32_t aEndOffset,
|
2008-04-11 12:45:31 +00:00
|
|
|
nsAString *aStr);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult AppendDoctype(nsIContent *aDoctype, nsAString *aStr);
|
|
|
|
nsresult AppendElementStart(nsIContent *aElement, nsIContent *aOriginalElement,
|
|
|
|
nsAString *aStr);
|
|
|
|
nsresult AppendElementEnd(nsIContent *aElement, nsAString *aStr);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Flush(nsAString *aStr);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult AppendDocumentStart(nsIDocument *aDocument, nsAString *aStr);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-10-07 14:22:37 +00:00
|
|
|
uuid(753b38d1-ee03-4e58-a650-1076ccccdb7f),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIEditor : nsISupports
|
|
|
|
{
|
|
|
|
typedef void *nsIContentPtr;
|
|
|
|
|
|
|
|
nsresult GetSelection([out] nsISelection *_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult Init([in] nsIDOMDocument *doc, [in] nsIContentPtr aRoot, [in] nsISelectionController *aSelCon, [in] uint32_t aFlags);
|
|
|
|
nsresult SetAttributeOrEquivalent([in] nsIDOMElement *element, [in] const nsAString *sourceAttrName, [in] const nsAString *sourceAttrValue, [in] bool aSuppressTransaction);
|
|
|
|
nsresult RemoveAttributeOrEquivalent([in] nsIDOMElement *element, [in] const nsAString *sourceAttrName, [in] bool aSuppressTransaction);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult PostCreate();
|
|
|
|
nsresult PreDestroy();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetFlags([out] uint32_t *_retval);
|
|
|
|
nsresult SetFlags([in] uint32_t val);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetContentsMIMEType([out] char **_retval);
|
|
|
|
nsresult SetContentsMIMEType([in] const char *val);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIsDocumentEditable([out] bool *_retval);
|
|
|
|
nsresult GetIsSelectionEditable(bool *aIsSelectionEditable);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetDocument([out] nsIDOMDocument **_retval);
|
|
|
|
nsresult GetRootElement([out] nsIDOMElement **_retval);
|
|
|
|
nsresult GetSelectionController([out] nsISelectionController **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult DeleteSelection(int16_t action, int16_t aStripWrappers);
|
|
|
|
nsresult GetDocumentIsEmpty([out] bool *_retval);
|
|
|
|
nsresult GetDocumentModified([out] bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetDocumentCharacterSet([out] nsACString *_retval);
|
|
|
|
nsresult SetDocumentCharacterSet([in] const nsACString *val);
|
|
|
|
nsresult ResetModificationCount();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetModificationCount([out] int32_t *_retval);
|
|
|
|
nsresult IncrementModificationCount([in] int32_t aModCount);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetTransactionManager([out] nsITransactionManager **_retval);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult SetTransactionManager(nsITransactionManager *aTransactionManager);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult DoTransaction([in] nsITransaction *txn);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult EnableUndo([in] bool enable);
|
|
|
|
nsresult GetNumberOfUndoItems(int32_t *aNumberOfUndoItems);
|
|
|
|
nsresult GetNumberOfRedoItems(int32_t *aNumberOfRedoItems);
|
|
|
|
nsresult Undo([in] uint32_t count);
|
|
|
|
nsresult CanUndo([out] bool *isEnabled, [out] bool *canUndo);
|
|
|
|
nsresult Redo([in] uint32_t count);
|
|
|
|
nsresult CanRedo([out] bool *isEnabled, [out] bool *canRedo);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult BeginTransaction();
|
|
|
|
nsresult EndTransaction();
|
|
|
|
nsresult BeginPlaceHolderTransaction([in] nsIAtom *name);
|
|
|
|
nsresult EndPlaceHolderTransaction();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult ShouldTxnSetSelection([out] bool *_retval);
|
|
|
|
nsresult SetShouldTxnSetSelection([in] bool should);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetInlineSpellChecker([out] nsIInlineSpellChecker **_retval);
|
2009-02-04 14:35:06 +00:00
|
|
|
nsresult SyncRealTimeSpell();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetSpellcheckUserOverride(bool enable);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Cut();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult CanCut([out] bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult Copy();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult CanCopy([out] bool *_retval);
|
|
|
|
nsresult Paste([in] int32_t aSelectionType);
|
|
|
|
nsresult PasteTransferable(nsITransferable *aTransferable);
|
|
|
|
nsresult CanPaste([in] int32_t aSelectionType, [out] bool *_retval);
|
|
|
|
nsresult CanPasteTransferable(nsITransferable *aTransferable, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SelectAll();
|
|
|
|
nsresult BeginningOfDocument();
|
|
|
|
nsresult EndOfDocument();
|
|
|
|
nsresult SetAttribute([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [in] const nsAString *attvalue);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAttributeValue([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [out] nsAString *resultValue, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult RemoveAttribute([in] nsIDOMElement *aElement, [in] const nsAString *aAttribute);
|
|
|
|
nsresult CloneAttribute([in] const nsAString *aAttribute, [in] nsIDOMNode *aDestNode, [in] nsIDOMNode *aSourceNode);
|
|
|
|
nsresult CloneAttributes([in] nsIDOMNode *destNode, [in] nsIDOMNode *sourceNode);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult CreateNode([in] const nsAString *tag, [in] nsIDOMNode *parent, [in] int32_t position, [out] nsIDOMNode **_retval);
|
|
|
|
nsresult InsertNode([in] nsIDOMNode *node, [in] nsIDOMNode *parent, [in] int32_t aPosition);
|
|
|
|
nsresult SplitNode([in] nsIDOMNode *existingRightNode, [in] int32_t offset, [out] nsIDOMNode **newLeftNode);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult JoinNodes([in] nsIDOMNode *leftNode, [in] nsIDOMNode *rightNode, [in] nsIDOMNode *parent);
|
|
|
|
nsresult DeleteNode([in] nsIDOMNode *child);
|
2013-05-19 21:21:20 +00:00
|
|
|
bool OutputsMozDirty();
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult MarkNodeDirty([in] nsIDOMNode *node);
|
|
|
|
nsresult SwitchTextDirection();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult OutputToString([in] nsAString formatType, [in] uint32_t flags, [out] nsAString *_retval);
|
|
|
|
nsresult OutputToStream([in] nsIOutputStream *aStream, [in] nsAString *formatType, [in] nsACString *charsetOverride, [in] uint32_t flags);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult SetEditorObserver(nsIEditorObserver *observer);
|
|
|
|
nsresult RemoveEditorObserver(nsIEditorObserver *observer);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult AddEditActionListener([in] nsIEditActionListener *listener);
|
|
|
|
nsresult RemoveEditActionListener([in] nsIEditActionListener *listener);
|
|
|
|
nsresult AddDocumentStateListener([in] nsIDocumentStateListener *listener);
|
|
|
|
nsresult RemoveDocumentStateListener([in] nsIDocumentStateListener *listener);
|
|
|
|
nsresult DumpContentTree();
|
|
|
|
nsresult DebugDumpContent();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult DebugUnitTests([out] int32_t *outNumTests, [out] int32_t *outNumTestsFailed);
|
|
|
|
bool IsModifiableNode(nsIDOMNode *aNode);
|
|
|
|
nsresult GetLastKeypressEventTrusted(bool *aLastKeypressEventTrusted);
|
|
|
|
nsresult SetSuppressDispatchingInputEvent(bool aSuppressDispatchingInputEvent);
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(833f30de-94c7-4630-a852-2300ef329d7b),
|
2008-04-11 12:45:31 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIHTMLEditor : nsISupports
|
|
|
|
{
|
|
|
|
nsresult AddDefaultProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
|
|
|
|
nsresult RemoveDefaultProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
|
|
|
|
nsresult RemoveAllDefaultProperties();
|
|
|
|
nsresult SetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue, [out] bool *aFirst, [out] bool *aAny, [out] bool *aAll);
|
|
|
|
nsresult GetInlinePropertyWithAttrValue([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue, [out] bool *aFirst, [out] bool *aAny, [out] bool *aAll, [out] nsAString *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult RemoveAllInlineProperties();
|
|
|
|
nsresult RemoveInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute);
|
|
|
|
nsresult IncreaseFontSize();
|
|
|
|
nsresult DecreaseFontSize();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult NodeIsBlock([in] nsIDOMNode *node, bool *_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult InsertHTML([in] nsAString *aInputString);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult PasteNoFormatting([in] int32_t aSelectionType);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult RebuildDocumentFromSource([in] nsAString *aSourceString);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InsertHTMLWithContext([in] nsAString *aInputString, [in] nsAString *aContextStr, [in] nsAString *aInfoStr, [in] nsAString *aFlavor, [in] nsIDOMDocument *aSourceDoc, [in] nsIDOMNode *aDestinationNode, [in] int32_t aDestinationOffset, [in] bool aDeleteSelection);
|
|
|
|
nsresult InsertElementAtSelection([in] nsIDOMElement *aElement, [in] bool aDeleteSelection);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult SetDocumentTitle([in] nsAString *aTitle);
|
|
|
|
nsresult UpdateBaseURL();
|
|
|
|
nsresult SelectElement([in] nsIDOMElement *aElement);
|
|
|
|
nsresult SetCaretAfterElement([in] nsIDOMElement *aElement);
|
|
|
|
nsresult SetParagraphFormat([in] nsAString *aParagraphFormat);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetParagraphState([out] bool *aMixed, [out] nsAString *_retval);
|
|
|
|
nsresult GetFontFaceState([out] bool *aMixed, [out] nsAString *_retval);
|
|
|
|
nsresult GetFontColorState([out] bool *aMixed, [out] nsAString *_retval);
|
|
|
|
nsresult GetBackgroundColorState([out] bool *aMixed, [out] nsAString *_retval);
|
|
|
|
nsresult GetHighlightColorState([out] bool *aMixed, [out] nsAString *_retval);
|
|
|
|
nsresult GetListState([out] bool *aMixed, [out] bool *aOL, [out] bool *aUL, [out] bool *aDL);
|
|
|
|
nsresult GetListItemState([out] bool *aMixed, [out] bool *aLI, [out] bool *aDT, [out] bool *aDD);
|
|
|
|
nsresult GetAlignment([out] bool *aMixed, [out] int16_t *aAlign);
|
|
|
|
nsresult GetIndentState([out] bool *aCanIndent, [out] bool *aCanOutdent);
|
|
|
|
nsresult MakeOrChangeList([in] nsAString *aListType, [in] bool entireList, [in] nsAString *aBulletType);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult RemoveList([in] nsAString *aListType);
|
|
|
|
nsresult Indent([in] nsAString *aIndent);
|
|
|
|
nsresult Align([in] nsAString *aAlign);
|
|
|
|
nsresult GetElementOrParentByTagName([in] nsAString *aTagName, [in] nsIDOMNode *aNode, [out] nsIDOMElement **_retval);
|
|
|
|
nsresult GetSelectedElement([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
|
|
|
|
nsresult GetHeadContentsAsHTML([out] nsAString *_retval);
|
|
|
|
nsresult ReplaceHeadContentsWithHTML([in] nsAString *aSourceToInsert);
|
|
|
|
nsresult CreateElementWithDefaults([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
|
|
|
|
nsresult InsertLinkAroundSelection([in] nsIDOMElement *aAnchorElement);
|
|
|
|
nsresult SetBackgroundColor([in] nsAString *aColor);
|
|
|
|
nsresult SetBodyAttribute([in] nsAString *aAttr, [in] nsAString *aValue);
|
|
|
|
nsresult GetLinkedObjects([out] nsISupportsArray **_retval);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIsCSSEnabled([out] bool *_retval);
|
|
|
|
nsresult SetIsCSSEnabled([in] bool prb);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult AddInsertionListener([in] nsIContentFilter *inFilter);
|
|
|
|
nsresult RemoveInsertionListener([in] nsIContentFilter *inFilter);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult CreateAnonymousElement([in] nsAString *aTag, [in] nsIDOMNode *aParentNode, [in] nsAString *aAnonClass, [in] bool aIsCreatedHidden, [out] nsIDOMElement **_retval);
|
2008-04-11 12:45:31 +00:00
|
|
|
nsresult GetSelectionContainer([out] nsIDOMElement **_retval);
|
|
|
|
nsresult CheckSelectionStateForAnonymousButtons([in] nsISelection *aSelection);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult IsAnonymousElement([in] nsIDOMElement *aElement, [out] bool *_retval);
|
|
|
|
nsresult GetReturnInParagraphCreatesNewParagraph([out] bool *_retval);
|
|
|
|
nsresult SetReturnInParagraphCreatesNewParagraph([in] bool prb);
|
|
|
|
nsresult BreakIsVisible(nsIDOMNode *aNode, bool *_retval);
|
|
|
|
void /*Element*/ *GetActiveEditingHost();
|
2008-04-11 12:45:31 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 14:22:37 +00:00
|
|
|
interface nsIDocShellTreeItem;
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(37f1ab73-f224-44b1-82f0-d2834ab1cec0),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDocShellTreeNode : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetChildCount(int32_t *aChildCount);
|
|
|
|
nsresult AddChild(nsIDocShellTreeItem *child);
|
|
|
|
nsresult RemoveChild(nsIDocShellTreeItem *child);
|
|
|
|
nsresult GetChildAt(int32_t index, nsIDocShellTreeItem **_retval);
|
|
|
|
nsresult FindChildWithName(const PRUnichar *aName, bool aRecurse, bool aSameType, nsIDocShellTreeItem *aRequestor,
|
|
|
|
nsIDocShellTreeItem *aOriginalRequestor, nsIDocShellTreeItem **_retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(e35bbb39-985b-4d62-81da-73c330222e5f),
|
2013-10-07 14:22:37 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDocShellTreeItem : nsIDocShellTreeNode
|
|
|
|
{
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetName(nsAString *aName);
|
|
|
|
nsresult SetName(const nsAString *aName);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult NameEquals(const PRUnichar *name, bool *_retval);
|
|
|
|
nsresult GetItemType(int32_t *aItemType);
|
|
|
|
nsresult SetItemType(int32_t aItemType);
|
|
|
|
nsresult GetParent(nsIDocShellTreeItem **aParent);
|
|
|
|
nsresult GetSameTypeParent(nsIDocShellTreeItem **aSameTypeParent);
|
|
|
|
nsresult GetRootTreeItem(nsIDocShellTreeItem **aRootTreeItem);
|
|
|
|
nsresult GetSameTypeRootTreeItem(nsIDocShellTreeItem **aSameTypeRootTreeItem);
|
|
|
|
nsresult FindItemWithName(const PRUnichar *name, nsISupports *aRequestor, nsIDocShellTreeItem *aOriginalRequestor, nsIDocShellTreeItem **_retval);
|
|
|
|
nsresult GetTreeOwner(nsIDocShellTreeOwner **aTreeOwner);
|
|
|
|
nsresult SetTreeOwner(nsIDocShellTreeOwner *treeOwner);
|
|
|
|
}
|
|
|
|
|
2010-01-18 16:27:14 +00:00
|
|
|
[
|
|
|
|
object,
|
2014-04-26 18:30:09 +00:00
|
|
|
uuid(f453d2ee-bac7-46f9-a553-df918f0cc0d0),
|
2010-01-18 16:27:14 +00:00
|
|
|
local
|
|
|
|
]
|
2013-10-07 14:22:37 +00:00
|
|
|
interface nsIDocShell : nsIDocShellTreeItem
|
2010-01-18 16:27:14 +00:00
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult LoadURI(nsIURI *uri, nsIDocShellLoadInfo *loadInfo, uint32_t aLoadFlags, bool firstParty);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult LoadStream(nsIInputStream *aStream, nsIURI *aURI, const nsACString *aContentType,
|
|
|
|
const nsACString *aContentCharset, nsIDocShellLoadInfo *aLoadInfo);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult InternalLoad(nsIURI *aURI, nsIURI *aReferrer, nsISupports *aOwner, uint32_t aFlags, const PRUnichar *aWindowTarget,
|
2013-10-07 14:22:37 +00:00
|
|
|
const char *aTypeHint, nsACString *aFileName, nsIInputStream *aPostDataStream, nsIInputStream *aHeadersStream,
|
|
|
|
uint32_t aLoadFlags, nsISHEntry *aSHEntry, bool firstParty, nsIDocShell **aDocShell, nsIRequest **aRequest);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult AddState(nsIVariant *aData, const nsAString *aTitle, const nsAString *aURL, bool aReplace, JSContext *cx);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult CreateLoadInfo(nsIDocShellLoadInfo **loadInfo);
|
|
|
|
nsresult PrepareForNewContentModel();
|
|
|
|
nsresult SetCurrentURI(nsIURI *aURI);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult FirePageHideNotification(bool isUnload);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetPresContext(void /*nsPresContext*/ **aPresContext);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsIPresShell *GetPresShell();
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetEldestPresShell(nsIPresShell **aEldestPresShell);
|
|
|
|
nsresult GetContentViewer(nsIContentViewer **aContentViewer);
|
|
|
|
nsresult GetChromeEventHandler(nsIDOMEventTarget **aChromeEventHandler);
|
|
|
|
nsresult SetChromeEventHandler(nsIDOMEventTarget *aChromeEventHandler);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAllowPlugins(bool *aAllowPlugins);
|
|
|
|
nsresult SetAllowPlugins(bool aAllowPlugins);
|
|
|
|
nsresult GetAllowJavascript(bool *aAllowJavascript);
|
|
|
|
nsresult SetAllowJavascript(bool aAllowJavascript);
|
|
|
|
nsresult GetDisableNoScript(bool *aDisableNoScript);
|
|
|
|
nsresult SetDisableNoScript(bool aDisableNoScript);
|
|
|
|
nsresult GetAllowMetaRedirects(bool *aAllowMetaRedirects);
|
|
|
|
nsresult SetAllowMetaRedirects(bool aAllowMetaRedirects);
|
|
|
|
nsresult GetAllowSubframes(bool *aAllowSubframes);
|
|
|
|
nsresult SetAllowSubframes(bool aAllowSubframes);
|
|
|
|
nsresult GetAllowImages(bool *aAllowImages);
|
|
|
|
nsresult SetAllowImages(bool aAllowImages);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetAllowMedia(bool *aAllowMedia);
|
|
|
|
nsresult SetAllowMedia(bool aAllowMedia);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetAllowDNSPrefetch(bool *aAllowDNSPrefetch);
|
|
|
|
nsresult SetAllowDNSPrefetch(bool aAllowDNSPrefetch);
|
|
|
|
nsresult GetAllowWindowControl(bool *aAllowWindowControl);
|
|
|
|
nsresult SetAllowWindowControl(bool aAllowWindowControl);
|
|
|
|
nsresult GetDocShellEnumerator(int32_t aItemType, int32_t aDirection, nsISimpleEnumerator **_retval);
|
|
|
|
nsresult GetAppType(uint32_t *aAppType);
|
|
|
|
nsresult SetAppType(uint32_t aAppType);
|
|
|
|
nsresult GetAllowAuth(bool *aAllowAuth);
|
|
|
|
nsresult SetAllowAuth(bool aAllowAuth);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetZoom(float *aZoom);
|
|
|
|
nsresult SetZoom(float aZoom);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetMarginWidth(int32_t *aMarginWidth);
|
|
|
|
nsresult SetMarginWidth(int32_t aMarginWidth);
|
|
|
|
nsresult GetMarginHeight(int32_t *aMarginHeight);
|
|
|
|
nsresult SetMarginHeight(int32_t aMarginHeight);
|
|
|
|
nsresult TabToTreeOwner(bool forward, bool *tookFocus);
|
|
|
|
nsresult GetBusyFlags(uint32_t *aBusyFlags);
|
|
|
|
nsresult GetLoadType(uint32_t *aLoadType);
|
|
|
|
nsresult SetLoadType(uint32_t aLoadType);
|
|
|
|
nsresult IsBeingDestroyed(bool *_retval);
|
|
|
|
nsresult GetIsExecutingOnLoadHandler(bool *aIsExecutingOnLoadHandler);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetLayoutHistoryState(nsILayoutHistoryState **aLayoutHistoryState);
|
|
|
|
nsresult SetLayoutHistoryState(nsILayoutHistoryState *aLayoutHistoryState);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetShouldSaveLayoutState(bool *aShouldSaveLayoutState);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult GetSecurityUI(nsISecureBrowserUI **aSecurityUI);
|
|
|
|
nsresult SetSecurityUI(nsISecureBrowserUI *aSecurityUI);
|
|
|
|
nsresult SuspendRefreshURIs();
|
|
|
|
nsresult ResumeRefreshURIs();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult BeginRestore(nsIContentViewer *viewer, bool top);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult FinishRestore();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetRestoringDocument(bool *aRestoringDocument);
|
|
|
|
nsresult GetUseErrorPages(bool *aUseErrorPages);
|
|
|
|
nsresult SetUseErrorPages(bool aUseErrorPages);
|
|
|
|
nsresult GetPreviousTransIndex(int32_t *aPreviousTransIndex);
|
|
|
|
nsresult GetLoadedTransIndex(int32_t *aLoadedTransIndex);
|
|
|
|
nsresult HistoryPurged(int32_t numEntries);
|
|
|
|
nsresult GetSessionStorageForPrincipal(nsIPrincipal *principal, const nsAString *documentURI,
|
|
|
|
bool create, nsIDOMStorage **_retval);
|
2010-01-18 16:27:14 +00:00
|
|
|
nsresult AddSessionStorage(nsIPrincipal *principal, nsIDOMStorage *storage);
|
|
|
|
nsresult GetCurrentDocumentChannel(nsIChannel **aCurrentDocumentChannel);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult SetChildOffset(uint32_t offset);
|
|
|
|
nsresult GetIsInUnload(bool *aIsInUnload);
|
|
|
|
nsresult GetChannelIsUnsafe(bool *aChannelIsUnsafe);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetHasMixedActiveContentLoaded(bool *aHasMixedActiveContentLoaded);
|
|
|
|
nsresult GetHasMixedActiveContentBlocked(bool *aHasMixedActiveContentBlocked);
|
|
|
|
nsresult GetHasMixedDisplayContentLoaded(bool *aHasMixedDisplayContentLoaded);
|
|
|
|
nsresult GetHasMixedDisplayContentBlocked(bool *aHasMixedDisplayContentBlocked);
|
2010-01-18 16:27:14 +00:00
|
|
|
void DetachEditorFromWindow();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIsOffScreenBrowser(bool *aIsOffScreenBrowser);
|
|
|
|
nsresult SetIsOffScreenBrowser(bool aIsOffScreenBrowser);
|
|
|
|
nsresult GetPrintPreview(nsIWebBrowserPrint **aPrintPreview);
|
|
|
|
nsresult GetCanExecuteScripts(bool *aCanExecuteScripts);
|
|
|
|
nsresult GetIsActive(bool *aIsActive);
|
|
|
|
nsresult SetIsActive(bool aIsActive);
|
|
|
|
nsresult GetHistoryID(uint64_t *aHistoryID);
|
|
|
|
nsresult GetIsAppTab(bool *aIsAppTab);
|
|
|
|
nsresult SetIsAppTab(bool aIsAppTab);
|
|
|
|
nsresult CreateAboutBlankContentViewer(nsIPrincipal *aPrincipal);
|
|
|
|
nsresult GetCharset(char **aCharset);
|
|
|
|
nsresult SetCharset(const char * aCharset);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GatherCharsetMenuTelemetry();
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetForcedCharset(nsIAtom **aForcedCharset);
|
|
|
|
nsresult SetForcedCharset(nsIAtom *aForcedCharset);
|
|
|
|
nsresult GetParentCharset(nsIAtom **aParentCharset);
|
|
|
|
nsresult SetParentCharset(nsIAtom *aParentCharset);
|
|
|
|
nsresult GetParentCharsetSource(int32_t *aParentCharsetSource);
|
|
|
|
nsresult SetParentCharsetSource(int32_t aParentCharsetSource);
|
|
|
|
nsresult AddWeakPrivacyTransitionObserver(nsIPrivacyTransitionObserver *obs);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult AddWeakReflowObserver(nsISupports /*nsIReflowObserver*/ *obs);
|
|
|
|
nsresult RemoveWeakReflowObserver(nsISupports /*nsIReflowObserver*/ *obs);
|
|
|
|
nsresult NotifyReflowObservers(bool interruptible, int /*DOMHighResTimeStamp*/ start, int /*DOMHighResTimeStamp*/ end);
|
2013-05-19 21:21:20 +00:00
|
|
|
nsresult GetIsBrowserElement(bool *aIsBrowserElement);
|
|
|
|
nsresult GetIsApp(bool *aIsApp);
|
|
|
|
nsresult GetIsBrowserOrApp(bool *aIsBrowserOrApp);
|
|
|
|
nsresult GetIsInBrowserElement(bool *aIsInBrowserElement);
|
|
|
|
nsresult GetIsInBrowserOrApp(bool *aIsInBrowserOrApp);
|
|
|
|
nsresult SetIsApp(uint32_t ownAppId);
|
|
|
|
nsresult SetIsBrowserInsideApp(uint32_t containingAppId);
|
|
|
|
nsresult GetAppId(uint32_t *aAppId);
|
|
|
|
nsresult GetSameTypeParentIgnoreBrowserAndAppBoundaries(nsIDocShell **_retval);
|
|
|
|
nsresult GetAsyncPanZoomEnabled(bool *aAsyncPanZoomEnabled);
|
|
|
|
nsresult GetSandboxFlags(uint32_t *aSandboxFlags);
|
|
|
|
nsresult SetSandboxFlags(uint32_t aSandboxFlags);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetMixedContentChannel(nsIChannel **aMixedContentChannel);
|
|
|
|
nsresult SetMixedContentChannel(nsIChannel *aMixedContentChannel);
|
|
|
|
nsresult GetAllowMixedContentAndConnectionData(bool *rootHasSecureConnection, bool *allowMixedContent, bool *isRootDocShell);
|
2013-05-19 21:21:20 +00:00
|
|
|
bool PluginsAllowedInCurrentDoc();
|
|
|
|
nsresult GetFullscreenAllowed(bool *aFullscreenAllowed);
|
|
|
|
nsresult SetFullscreenAllowed(bool allowed);
|
2013-10-07 14:22:37 +00:00
|
|
|
nsresult GetAffectPrivateSessionLifetime(bool *aAffectPrivateSessionLifetime);
|
|
|
|
nsresult SetAffectPrivateSessionLifetime(bool aAffectPrivateSessionLifetime);
|
|
|
|
nsresult GetMayEnableCharacterEncodingMenu(bool *aMayEnableCharacterEncodingMenu);
|
|
|
|
nsresult GetEditor(nsIEditor **aEditor);
|
|
|
|
nsresult SetEditor(nsIEditor *aEditor);
|
|
|
|
nsresult GetEditable(bool *aEditable);
|
|
|
|
nsresult GetHasEditingSession(bool *aHasEditingSession);
|
|
|
|
nsresult MakeEditable(bool inWaitForUriLoad);
|
2014-04-26 18:30:09 +00:00
|
|
|
nsresult GetChildSHEntry(int32_t aChildOffset, nsISHEntry **_retval);
|
|
|
|
nsresult AddChildSHEntry(nsISHEntry *aCloneReference, nsISHEntry *aHistoryEntry, int32_t aChildOffset, uint32_t aLoadType, bool aCloneChildren);
|
|
|
|
nsresult GetUseGlobalHistory(bool *aUseGlobalHistory);
|
|
|
|
nsresult SetUseGlobalHistory(bool aUseGlobalHistory);
|
|
|
|
nsresult RemoveFromSessionHistory();
|
|
|
|
nsresult GetCreatedDynamically(bool *aCreatedDynamically);
|
|
|
|
nsresult SetCreatedDynamically(bool aCreatedDynamically);
|
|
|
|
nsresult GetCurrentSHEntry(nsISHEntry **aEntry, bool *_retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(02d37b31-e654-4b74-9bc3-14dfe0020bb3),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIMarkupDocumentViewer : nsISupports
|
|
|
|
{
|
|
|
|
nsresult ScrollToNode(nsIDOMNode *node);
|
|
|
|
nsresult GetTextZoom(float *aTextZoom);
|
|
|
|
nsresult SetTextZoom(float aTextZoom);
|
|
|
|
nsresult GetFullZoom(float *aFullZoom);
|
|
|
|
nsresult SetFullZoom(float aFullZoom);
|
|
|
|
nsresult GetAuthorStyleDisabled(bool *aAuthorStyleDisabled);
|
|
|
|
nsresult SetAuthorStyleDisabled(bool aAuthorStyleDisabled);
|
|
|
|
nsresult GetDefaultCharacterSet(nsACString *aDefaultCharacterSet);
|
|
|
|
nsresult SetDefaultCharacterSet(const nsACString *aDefaultCharacterSet);
|
|
|
|
nsresult GetForceCharacterSet(nsACString *aForceCharacterSet);
|
|
|
|
nsresult SetForceCharacterSet(const nsACString *aForceCharacterSet);
|
|
|
|
nsresult GetHintCharacterSet(nsACString *aHintCharacterSet);
|
|
|
|
nsresult SetHintCharacterSet(const nsACString *aHintCharacterSet);
|
|
|
|
nsresult GetHintCharacterSetSource(int32_t *aHintCharacterSetSource);
|
|
|
|
nsresult SetHintCharacterSetSource(int32_t aHintCharacterSetSource);
|
|
|
|
nsresult GetPrevDocCharacterSet(nsACString *aPrevDocCharacterSet);
|
|
|
|
nsresult SetPrevDocCharacterSet(const nsACString *aPrevDocCharacterSet);
|
|
|
|
nsresult GetContentSize(int32_t *width, int32_t *height);
|
|
|
|
nsresult GetBidiTextDirection(uint8_t *aBidiTextDirection);
|
|
|
|
nsresult SetBidiTextDirection(uint8_t aBidiTextDirection);
|
|
|
|
nsresult GetBidiTextType(uint8_t *aBidiTextType);
|
|
|
|
nsresult SetBidiTextType(uint8_t aBidiTextType);
|
|
|
|
nsresult GetBidiNumeral(uint8_t *aBidiNumeral);
|
|
|
|
nsresult SetBidiNumeral(uint8_t aBidiNumeral);
|
|
|
|
nsresult GetBidiSupport(uint8_t *aBidiSupport);
|
|
|
|
nsresult SetBidiSupport(uint8_t aBidiSupport);
|
|
|
|
nsresult GetBidiOptions(uint32_t *aBidiOptions);
|
|
|
|
nsresult SetBidiOptions(uint32_t aBidiOptions);
|
|
|
|
nsresult GetMinFontSize(int32_t *aMinFontSize);
|
|
|
|
nsresult SetMinFontSize(int32_t aMinFontSize);
|
|
|
|
nsresult AppendSubtree(void /* nsTArray<nsCOMPtr<nsIMarkupDocumentViewer>> */ *array);
|
|
|
|
nsresult ChangeMaxLineBoxWidth(int32_t maxLineBoxWidth);
|
2013-05-19 21:21:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(16fe5e3e-eadc-4312-9d44-b6bedd6b5474),
|
2009-02-04 14:35:06 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIMutationObserver : nsISupports
|
|
|
|
{
|
|
|
|
void CharacterDataWillChange(nsIDocument *aDocument, nsIContent *aContent,
|
|
|
|
void /*CharacterDataChangeInfo*/ *aInfo);
|
|
|
|
void CharacterDataChanged(nsIDocument *aDocument, nsIContent *aContent,
|
|
|
|
void /*CharacterDataChangeInfo*/ *aInfo);
|
2013-05-19 21:21:20 +00:00
|
|
|
void AttributeWillChange(nsIDocument *aDocument, nsIContent *aContent, int32_t aNameSpaceID,
|
|
|
|
nsIAtom *aAttribute, int32_t aModType);
|
|
|
|
void AttributeChanged(nsIDocument *aDocument, nsIContent *aContent, int32_t aNameSpaceID,
|
|
|
|
nsIAtom *aAttribute, int32_t aModType);
|
|
|
|
void AttributeSetToCurrentValue(nsIDocument *aDocument, /*mozilla::dom::Element*/ void *aElement,
|
|
|
|
int32_t aNameSpaceID, nsIAtom *aAttribute);
|
|
|
|
void ContentAppended(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aFirstNewContent,
|
|
|
|
int32_t aNewIndexInContainer);
|
2009-02-04 14:35:06 +00:00
|
|
|
void ContentInserted(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
|
2013-05-19 21:21:20 +00:00
|
|
|
int32_t aIndexInContainer);
|
2009-02-04 14:35:06 +00:00
|
|
|
void ContentRemoved(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
|
2013-05-19 21:21:20 +00:00
|
|
|
int32_t aIndexInContainer, nsIContent *aPreviousSibling);
|
2009-02-04 14:35:06 +00:00
|
|
|
void NodeWillBeDestroyed(const nsINode *aNode);
|
|
|
|
void ParentChainChanged(nsIContent *aContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
2013-05-19 21:21:20 +00:00
|
|
|
uuid(2c4ad90a-740e-4212-ba3f-feacda4b929e),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIParser : nsISupports
|
|
|
|
{
|
|
|
|
typedef int nsDTDMode;
|
|
|
|
typedef int eParserCommands;
|
|
|
|
|
|
|
|
/* From nsParserBase: */
|
|
|
|
bool IsParserEnabled();
|
|
|
|
nsresult GetChannel(nsIChannel **aChannel);
|
|
|
|
|
|
|
|
void SetContentSink(nsIContentSink *aSink);
|
|
|
|
nsIContentSink *GetContentSink();
|
|
|
|
void GetCommand(nsACString *aCommand);
|
|
|
|
void SetCommand2(const char *aCommand);
|
|
|
|
void SetCommand(eParserCommands aParserCommand);
|
|
|
|
void SetDocumentCharset(const nsACString *aCharset, int32_t aSource);
|
|
|
|
void GetDocumentCharset(nsACString *oCharset, int32_t *oSource);
|
|
|
|
nsresult GetDTD(nsIDTD **aDTD);
|
|
|
|
nsIStreamListener *GetStreamListener();
|
|
|
|
nsresult ContinueInterruptedParsing();
|
|
|
|
void BlockParser();
|
|
|
|
void UnblockParser();
|
|
|
|
void ContinueInterruptedParsingAsync();
|
|
|
|
bool IsComplete();
|
|
|
|
nsresult Parse(nsIURI *aURL, nsIRequestObserver *aListener, void *aKey, nsDTDMode aMode);
|
|
|
|
nsresult Terminate();
|
|
|
|
nsresult ParseFragment(const nsAString *aSourceBuffer, void /*nsTArray<nsString>*/ *aTagStack);
|
|
|
|
nsresult BuildModel();
|
|
|
|
nsresult CancelParsingEvents();
|
|
|
|
void Reset();
|
|
|
|
bool IsInsertionPointDefined();
|
|
|
|
void BeginEvaluatingParserInsertedScript();
|
|
|
|
void EndEvaluatingParserInsertedScript();
|
|
|
|
void MarkAsNotScriptCreated(const char *aCommand);
|
|
|
|
bool IsScriptCreated();
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(900bc4bc-8b6c-4cba-82fa-568a80fffd3e),
|
2009-02-04 14:35:06 +00:00
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIDocumentObserver : nsIMutationObserver
|
|
|
|
{
|
2013-05-19 21:21:20 +00:00
|
|
|
typedef uint32_t nsUpdateType;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
uint64_t mStates;
|
|
|
|
} nsEventStates;
|
2009-02-04 14:35:06 +00:00
|
|
|
|
|
|
|
void BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
|
|
|
|
void EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
|
|
|
|
void BeginLoad(nsIDocument *aDocument);
|
|
|
|
void EndLoad(nsIDocument *aDocument);
|
2013-05-19 21:21:20 +00:00
|
|
|
void ContentStatesChanged(nsIDocument *aDocument, nsIContent *aContent, nsEventStates *aStateMask);
|
|
|
|
void DocumentStatesChanged(nsIDocument *aDocument, nsEventStates *aStateMask);
|
|
|
|
void StyleSheetAdded(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, bool aDocumentSheet);
|
|
|
|
void StyleSheetRemoved(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, bool aDocumentSheet);
|
2009-02-04 14:35:06 +00:00
|
|
|
void StyleSheetApplicableStateChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet,
|
2013-05-19 21:21:20 +00:00
|
|
|
bool aApplicable);
|
2009-02-04 14:35:06 +00:00
|
|
|
void StyleRuleChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aOldStyleRule,
|
|
|
|
nsIStyleRule *aNewStyleRule);
|
|
|
|
void StyleRuleAdded(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule);
|
|
|
|
void StyleRuleRemoved(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule);
|
|
|
|
void BindToDocument(nsIDocument *aDocument, nsIContent *aContent);
|
2013-05-19 21:21:20 +00:00
|
|
|
void AttemptToExecuteScript(nsIContent *aContent, nsIParser *aParser, bool *aBlock);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(3682dd99-8560-44f4-9b8f-ccce9d7b96fb),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIContentUtils : nsISupports
|
|
|
|
{
|
|
|
|
bool IsSafeToRunScript();
|
|
|
|
nsresult AddDocumentObserver(nsIDocument *aDocument, nsIDocumentObserver *aObserver);
|
|
|
|
nsresult RemoveDocumentObserver(nsIDocument *aDocument, nsIDocumentObserver *aObserver);
|
|
|
|
nsresult AddMutationObserver(nsINode *aNode, nsIMutationObserver *aObserver);
|
|
|
|
nsresult RemoveMutationObserver(nsINode *aNode, nsIMutationObserver *aObserver);
|
|
|
|
nsresult AddScriptRunner(nsIRunnable *aRunnable);
|
|
|
|
JSContext *GetContextFromDocument(nsIDocument *aDocument);
|
|
|
|
}
|
|
|
|
|
|
|
|
[
|
|
|
|
object,
|
|
|
|
uuid(8f672000-bab9-4c60-aaaf-2673c4e2a4c6),
|
|
|
|
local
|
|
|
|
]
|
|
|
|
interface nsIPluginInstance : nsISupports
|
|
|
|
{
|
|
|
|
nsresult GetDOMElement(nsIDOMElement **aDOMElement);
|
2009-02-04 14:35:06 +00:00
|
|
|
}
|
2013-10-07 14:22:37 +00:00
|
|
|
|
|
|
|
cpp_quote("DEFINE_GUID(IID_nsCycleCollectionISupports, 0xc61eac14,0x5f7a,0x4481,0x96,0x5e,0x7e,0xaa,0x6e,0xff,0xa8,0x5f);")
|