wine/dlls/mshtml/nsiface.idl

3909 lines
165 KiB
Plaintext

/*
* Copyright 2005-2012 Jacek Caban for CodeWeavers
*
* 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
*/
/*
* NOTE:
* 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.
*/
cpp_quote("#define GECKO_VERSION \"2.24\"")
cpp_quote("#define GECKO_VERSION_STRING \"Wine Gecko \" GECKO_VERSION")
import "wtypes.idl";
cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
cpp_quote("#undef GetForm")
cpp_quote("#undef SetPort")
cpp_quote("#endif")
typedef HRESULT nsresult;
typedef ULONG nsrefcnt;
typedef IID nsID;
typedef IID nsIID;
typedef nsIID nsCID;
typedef REFIID nsIIDRef;
typedef nsIIDRef nsCIDRef;
typedef WCHAR PRUnichar;
/*
* 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
typedef struct {
void *v;
void *d1;
uint32_t d2;
void *d3;
} nsCStringContainer;
typedef struct {
void *v;
void *d1;
uint32_t d2;
void *d3;
} nsStringContainer;
typedef nsCStringContainer nsACString;
typedef nsStringContainer nsAString;
interface nsIWebBrowserChrome;
interface nsILoadGroup;
interface nsIDOMNode;
interface nsIDOMAttr;
interface nsIDOMDocument;
interface nsIDOMEvent;
interface nsIEditor;
interface nsISelectionController;
interface nsITransactionManager;
interface nsITransaction;
interface nsIInlineSpellChecker;
interface nsIOutputStream;
interface nsIEditorObserver;
interface nsIEditActionListener;
interface nsIDocumentStateListener;
interface nsIDOMCSSStyleSheet;
interface nsIDOMDocumentView;
interface nsIDOMWindow;
interface nsIDOMElement;
interface nsIDOMRange;
interface nsIDOMEventTarget;
interface nsISelection;
interface nsIDOMHTMLSelectElement;
interface nsIFile;
interface IMoniker;
[
object,
uuid(00000000-0000-0000-c000-000000000046),
local
]
interface nsISupports
{
nsresult QueryInterface(nsIIDRef riid, void **result);
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;
typedef nsISupports nsIDOMHTMLTableCaptionElement;
typedef nsISupports nsIDOMHTMLTableSectionElement;
typedef nsISupports nsIDOMClientRectList;
typedef nsISupports nsINode;
typedef nsISupports nsIStyleSheet;
typedef nsISupports nsIStyleRule;
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;
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;
typedef nsISupports nsILoadGroupConnectionInfo;
typedef nsISupports nsIDOMCrypto;
typedef nsISupports nsIDOMPkcs11;
typedef nsISupports nsIDocShellTreeOwner;
typedef void *JSContext;
typedef void *JSObject;
typedef uint64_t jsval;
[
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);
nsresult LockFactory(bool lock);
}
[
object,
uuid(6aef11c4-8615-44a6-9711-98f43805693d),
local
]
interface nsIMemory : nsISupports
{
void *Alloc(/*size_t*/ int size);
void *Realloc(void *_ptr, /*size_t*/ int newSize);
void Free(void *_ptr);
nsresult HeapMinimize(bool immediate);
nsresult IsLowMemory(bool *_retval);
nsresult IsLowMemoryPlatform(bool *_retval);
}
[
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,
uuid(4a2abaf0-6886-11d3-9382-00104ba0fd40),
local
]
interface nsIRunnable : nsISupports
{
nsresult Run();
}
[
object,
uuid(d1899240-f9d2-11d2-bdd6-000064657374),
local
]
interface nsISimpleEnumerator : nsISupports
{
nsresult HasMoreElements(bool *_retval);
nsresult GetNext(nsISupports **_retval);
}
[
object,
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),
local
]
interface nsIInputStream : nsISupports
{
nsresult Close();
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);
}
[
object,
uuid(395fe045-7d18-4adb-a3fd-af98c8a1af11),
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);
nsresult GetPort(int32_t *aPort);
nsresult SetPort(int32_t aPort);
nsresult GetPath(nsACString *aPath);
nsresult SetPath(const nsACString *aPath);
nsresult Equals(nsIURI *other, bool *_retval);
nsresult SchemeIs(const char *scheme, bool *_retval);
nsresult Clone(nsIURI **_retval);
nsresult Resolve(const nsACString *relativePath, nsACString *_retval);
nsresult GetAsciiSpec(nsACString *aAsciiSpec);
nsresult GetAsciiHost(nsACString *aAsciiHost);
nsresult GetOriginCharset(nsACString *aOriginCharset);
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);
}
[
object,
uuid(1419aa16-f134-4154-9886-00c7c5147a13),
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);
}
[
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);
}
[
object,
uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe),
local
]
interface nsIRequest : nsISupports
{
nsresult GetName(nsACString *aName);
nsresult IsPending(bool *_retval);
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,
uuid(3b4c8a77-76ba-4610-b316-678c73a3b88c),
local
]
interface nsIStreamListener : nsIRequestObserver
{
nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
nsIInputStream *aInputStream, uint64_t aOffset, uint32_t aCount);
}
[
object,
uuid(19501006-46e3-4634-b97d-26eff894b4d3),
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);
nsresult GetActiveCount(uint32_t *aActiveCount);
nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
nsresult GetConnectionInfo(nsILoadGroupConnectionInfo **aConnectionInfo);
}
[
object,
uuid(2a8a7237-c1e2-4de7-b669-2002af29e42d),
local
]
interface nsIChannel : nsIRequest
{
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;
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);
nsresult GetContentLength(int64_t *aContentLength);
nsresult SetContentLength(int64_t aContentLength);
nsresult Open(nsIInputStream **_retval);
nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext);
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);
}
[
object,
uuid(a01362a0-5c45-11e2-bcfd-0800200c9a66),
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);
nsresult SetRequestHeader(const nsACString *aHeader, const nsACString *aValue, bool aMerge);
nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
nsresult GetAllowPipelining(bool *aAllowPipelining);
nsresult SetAllowPipelining(bool aAllowPipelining);
nsresult GetRedirectionLimit(uint32_t *aRedirectionLimit);
nsresult SetRedirectionLimit(uint32_t aRedirectionLimit);
nsresult GetResponseStatus(uint32_t *aResponseStatus);
nsresult GetResponseStatusText(nsACString *aResponseStatusText);
nsresult GetRequestSucceeded(bool *aRequestSucceeded);
nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
nsresult SetResponseHeader(const nsACString *header, const nsACString *value, bool merge);
nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor);
nsresult IsNoStoreResponse(bool *_retval);
nsresult IsNoCacheResponse(bool *_retval);
nsresult RedirectTo(nsIURI *aNewURI);
}
[
object,
uuid(2cd7f6a6-63f3-4bd6-a0f5-6e3d6dcff81b),
local
]
interface nsIHttpChannelInternal : nsISupports
{
nsresult GetDocumentURI(nsIURI **aDocumentURI);
nsresult SetDocumentURI(nsIURI *aDocumentURI);
nsresult GetRequestVersion(uint32_t *major, uint32_t *minor);
nsresult GetResponseVersion(uint32_t *major, uint32_t *minor);
nsresult SetCookie(const char *aCookieHeader);
nsresult SetupFallbackChannel(const char *aFallbackKey);
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);
nsresult GetLoadAsBlocking(bool *aLoadAsBlocking);
nsresult SetLoadAsBlocking(bool aLoadAsBlocking);
nsresult GetLoadUnblocked(bool *aLoadUnblocked);
nsresult SetLoadUnblocked(bool aLoadUnblocked);
}
[
object,
uuid(5cfe15bd-5adb-4a7f-9e55-4f5a67d15794),
local
]
interface nsIUploadChannel : nsISupports
{
nsresult SetUploadStream(nsIInputStream *aStream, const nsACString *aContentType,
int64_t aContentLength);
nsresult GetUploadStream(nsIInputStream **aUploadStream);
}
[
object,
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,
uuid(79de76e5-994e-4f6b-81aa-42d9adb6e67e),
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);
nsresult GetOrigin(nsAString *aOrigin);
nsresult Reload(bool forceget);
nsresult Replace(const nsAString *url);
nsresult Assign(const nsAString *url);
nsresult ToString(nsAString *_retval);
nsresult ValueOf(nsIDOMLocation **_retval);
}
[
object,
uuid(2938307a-9d70-4b63-8afc-0197e82318ad),
local
]
interface nsIDOMCSSRule : nsISupports
{
nsresult GetType(uint16_t *aType);
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);
nsresult GetLength(uint32_t *aLength);
nsresult Item(uint32_t index, nsAString *_retval);
nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
}
[
object,
uuid(a6cf90c0-15b3-11d2-932e-00805f8add32),
local
]
interface nsIDOMCSSRuleList : nsISupports
{
nsresult GetLength(uint32_t *aLength);
nsresult Item(uint32_t index, nsIDOMCSSRule **_retval);
}
[
object,
uuid(a6cf9080-15b3-11d2-932e-00805f8add32),
local
]
interface nsIDOMStyleSheet : nsISupports
{
nsresult GetType(nsAString *aType);
nsresult GetDisabled(bool *aDisabled);
nsresult SetDisabled(bool aDisabled);
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);
nsresult InsertRule(const nsAString *rule, uint32_t index, uint32_t *_retval);
nsresult DeleteRule(uint32_t index);
}
[
object,
uuid(a6cf9081-15b3-11d2-932e-00805f8add32),
local
]
interface nsIDOMStyleSheetList : nsISupports
{
nsresult GetLength(uint32_t *aLength);
nsresult Item(uint32_t index, nsIDOMStyleSheet **_retval);
}
[
object,
uuid(450cf0ba-de90-4f86-85bf-e10cc8b8713f),
local
]
interface nsIDOMNodeList : nsISupports
{
nsresult Item(uint32_t index, nsIDOMNode **_retval);
nsresult GetLength(uint32_t *aLength);
}
[
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);
}
[
object,
uuid(cb5564cd-26ec-418f-a6d6-1d57cd2c971c),
local
]
interface nsIDOMMozNamedAttrMap : nsISupports
{
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);
nsresult GetLength(uint32_t *aLength);
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);
}
[
object,
uuid(56545150-a001-484e-9ed4-cb319eebd7b3),
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
};
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
};
nsresult GetNodeName(nsAString *aNodeName);
nsresult GetNodeValue(nsAString *aNodeValue);
nsresult SetNodeValue(const nsAString *aNodeValue);
nsresult GetNodeType(uint16_t *aNodeType);
nsresult GetParentNode(nsIDOMNode **aParentNode);
nsresult GetParentElement(nsIDOMElement **aParentElement);
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);
nsresult HasChildNodes(bool *_retval);
nsresult CloneNode(bool deep, uint8_t _argc, nsIDOMNode **_retval);
nsresult Normalize();
nsresult GetNamespaceURI(nsAString *aNamespaceURI);
nsresult GetPrefix(nsAString *aPrefix);
nsresult GetLocalName(nsAString *aLocalName);
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);
nsresult GetMshtmlNode(nsISupports **aMshtmlNode);
nsresult SetMshtmlNode(nsISupports *aMshtmlNode);
}
[
object,
uuid(a974a4d3-2ff1-445b-8b8e-0aada5d4eedc),
local
]
interface nsIDOMAttr : nsIDOMNode
{
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);
}
[
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);
}
[
object,
uuid(43d985da-b7ee-4d1f-a26f-348ccd9506f3),
local
]
interface nsIDOMElement : nsIDOMNode
{
nsresult GetTagName(nsAString *aTagName);
nsresult GetClassList(nsISupports **aClassList);
nsresult GetAttributes(nsIDOMMozNamedAttrMap **aAttributes);
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);
nsresult GetElementsByTagName(const nsAString *name, nsIDOMHTMLCollection **_retval);
nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMHTMLCollection **_retval);
nsresult GetElementsByClassName(const nsAString *classes, nsIDOMHTMLCollection **_retval);
nsresult GetChildElements(nsIDOMNodeList **aChildren);
nsresult GetFirstElementChild(nsIDOMElement **aFirstElementChild);
nsresult GetLastElementChild(nsIDOMElement **aLastElementChild);
nsresult GetPreviousElementSibling(nsIDOMElement **aPreviousElementSibling);
nsresult GetNextElementSibling(nsIDOMElement **aNextElementSibling);
nsresult GetChildElementCount(uint32_t *aChildElementCount);
nsresult Remove();
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);
}
cpp_quote("#undef GetClassName")
[
object,
uuid(e29ddc73-ac40-40fe-8bbd-14bf2d52c53a),
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);
nsresult GetDataset(nsISupports **aDataset);
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);
nsresult GetProperties(nsISupports **aProperties);
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);
}
[
object,
uuid(889602bb-4681-4b01-8582-4fad1fbb8325),
local
]
interface nsIDOMHTMLHeadElement : nsIDOMHTMLElement
{
}
[
object,
uuid(84f72a38-1873-46f8-937c-1df22d7e7cae),
local
]
interface nsIDOMCharacterData : nsIDOMNode
{
nsresult GetData(nsAString *aData);
nsresult SetData(const nsAString *aData);
nsresult GetLength(uint32_t *aLength);
nsresult SubstringData(uint32_t offset, uint32_t count, nsAString *_retval);
nsresult AppendData(const nsAString *arg);
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);
nsresult Remove();
}
[
object,
uuid(d14d13b4-21d5-49e2-8d59-76a24156db54),
local
]
interface nsIDOMText : nsIDOMCharacterData
{
nsresult SplitText(uint32_t offset, nsIDOMText **_retval);
nsresult GetWholeText(nsAString *aWholeText);
}
[
object,
uuid(e702a5d2-3aa8-4788-b048-2d3b3e6d16f2),
local
]
interface nsIDOMComment : nsIDOMCharacterData
{
}
[
object,
uuid(33127aed-9d6a-4b0d-95aa-0529f51bcb9c),
local
]
interface nsIDOMDocumentFragment : nsIDOMNode
{
}
[
object,
uuid(75996de6-6b0f-43e5-ae79-c98fa669da9a),
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);
nsresult CreateProcessingInstruction(const nsAString *target, const nsAString *data, nsIDOMProcessingInstruction **_retval);
nsresult CreateAttribute(const nsAString *name, nsIDOMAttr **_retval);
nsresult GetElementsByTagName(const nsAString *tagname, nsIDOMNodeList **_retval);
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);
nsresult GetElementById(const nsAString *elementId, nsIDOMElement **_retval);
nsresult GetInputEncoding(nsAString *aInputEncoding);
nsresult GetDocumentURI(nsAString *aDocumentURI);
nsresult GetURL(nsAString *aURL);
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);
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);
nsresult GetReadyState(nsAString *aReadyState);
nsresult GetLastModified(nsAString *aLastModified);
nsresult GetReferrer(nsAString *aReferrer);
nsresult HasFocus(bool *_retval);
nsresult GetActiveElement(nsIDOMElement **aActiveElement);
nsresult GetElementsByClassName(const nsAString *classes, nsIDOMNodeList **_retval);
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);
nsresult CaretPositionFromPoint(float x, float y, nsISupports **_retval);
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);
nsresult GetCompatMode(nsAString *aCompatMode);
}
[
object,
uuid(fd76e045-8d97-4a97-ad75-eac5ae2f3ea4),
local
]
interface nsIDOMHTMLDocument : nsIDOMDocument
{
nsresult GetDomain(nsAString *aDomain);
nsresult SetDomain(const nsAString *aDomain);
nsresult GetCookie(nsAString *aCookie);
nsresult SetCookie(const nsAString *aCookie);
nsresult GetHead(nsIDOMHTMLHeadElement **aHead);
nsresult GetBody(nsIDOMHTMLElement **aBody);
nsresult SetBody(nsIDOMHTMLElement *aBody);
nsresult GetImages(nsIDOMHTMLCollection **aImages);
nsresult GetEmbeds(nsIDOMHTMLCollection **aEmbeds);
nsresult GetPlugins(nsIDOMHTMLCollection **aPlugins);
nsresult GetLinks(nsIDOMHTMLCollection **aLinks);
nsresult GetForms(nsIDOMHTMLCollection **aForms);
nsresult GetScripts(nsIDOMHTMLCollection **aScripts);
nsresult GetElementsByName(const nsAString *elementName, nsIDOMNodeList **_retval);
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);
nsresult GetLinkColor(nsAString *aLinkColor);
nsresult SetLinkColor(const nsAString *aLinkColor);
nsresult GetVlinkColor(nsAString *aVlinkColor);
nsresult SetVlinkColor(const nsAString *aVlinkColor);
nsresult GetAlinkColor(nsAString *aAlinkColor);
nsresult SetAlinkColor(const nsAString *aAlinkColor);
nsresult GetAnchors(nsIDOMHTMLCollection **aAnchors);
nsresult GetApplets(nsIDOMHTMLCollection **aApplets);
nsresult Clear();
nsresult GetSelection(nsISelection **_retval);
nsresult CaptureEvents(int32_t eventFlags);
nsresult ReleaseEvents(int32_t eventFlags);
nsresult RouteEvent(nsIDOMEvent *evt);
}
[
object,
uuid(1f94055c-42e7-4a30-96a1-6a804f1c2d1e),
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);
nsresult GetStartOffset(int32_t *aStartOffset);
nsresult GetEndContainer(nsIDOMNode **aEndContainer);
nsresult GetEndOffset(int32_t *aEndOffset);
nsresult GetCollapsed(bool *aCollapsed);
nsresult GetCommonAncestorContainer(nsIDOMNode **aCommonAncestorContainer);
nsresult SetStart(nsIDOMNode *refNode, int32_t offset);
nsresult SetEnd(nsIDOMNode *refNode, int32_t offset);
nsresult SetStartBefore(nsIDOMNode *refNode);
nsresult SetStartAfter(nsIDOMNode *refNode);
nsresult SetEndBefore(nsIDOMNode *refNode);
nsresult SetEndAfter(nsIDOMNode *refNode);
nsresult Collapse(bool toStart);
nsresult SelectNode(nsIDOMNode *refNode);
nsresult SelectNodeContents(nsIDOMNode *refNode);
nsresult CompareBoundaryPoints(uint16_t how, nsIDOMRange *sourceRange, int16_t *_retval);
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);
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);
}
[
object,
uuid(12cf5a4d-fffb-4f2f-9cec-c65195661d76),
local
]
interface nsISelection : nsISupports
{
nsresult GetAnchorNode(nsIDOMNode **aAnchorNode);
nsresult GetAnchorOffset(int32_t *aAnchorOffset);
nsresult GetFocusNode(nsIDOMNode **aFocusNode);
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);
nsresult CollapseToStart();
nsresult CollapseToEnd();
nsresult ContainsNode(nsIDOMNode *node, bool entirelyContained, bool *_retval);
nsresult SelectAllChildren(nsIDOMNode *parentNode);
nsresult AddRange(nsIDOMRange *range);
nsresult RemoveRange(nsIDOMRange *range);
nsresult RemoveAllRanges();
nsresult DeleteFromDocument();
nsresult SelectionLanguageChange(bool langRTL);
nsresult ToString(nsAString *_retval);
nsresult Modify(const nsAString *alter, const nsAString *direction, const nsAString *granularity);
}
[
object,
uuid(a6cf906f-15b3-11d2-932e-00805f8add32),
local
]
interface nsIDOMWindowCollection : nsISupports
{
nsresult GetLength(uint32_t *aLength);
nsresult Item(uint32_t index, nsIDOMWindow **_retval);
nsresult NamedItem(const nsAString *name, nsIDOMWindow **_retval);
}
[
object,
uuid(be62660a-e3f6-409c-a4a9-378364a9526f),
local
]
interface nsIDOMWindow : nsISupports
{
nsresult GetWindow(nsIDOMWindow **aWindow);
nsresult GetSelf(nsIDOMWindow **aSelf);
nsresult GetDocument(nsIDOMDocument **aDocument);
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
nsresult GetLocation(nsIDOMLocation **aLocation);
nsresult GetHistory(nsIDOMHistory **aHistory);
nsresult GetLocationbar(nsISupports **aLocationbar);
nsresult GetMenubar(nsISupports **aMenubar);
nsresult GetPersonalbar(nsISupports **aPersonalbar);
nsresult GetScrollbars(nsISupports **aScrollbars);
nsresult GetStatusbar(nsISupports **aStatusbar);
nsresult GetToolbar(nsISupports **aToolbar);
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();
nsresult ShowModalDialog(const nsAString *aURI, nsIVariant *aArgs, const nsAString *aOptions, uint8_t _argc, nsIVariant **_retval);
nsresult PostMessageMoz(const long /*jsval*/ *message, const nsAString *targetOrigin, const /*JS::Value*/ void *transfer, JSContext *cx);
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);
nsresult GetDefaultComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
nsresult GetWindowRoot(nsIDOMEventTarget **aWindowRoot);
nsresult GetFrames(nsIDOMWindowCollection **aFrames);
nsresult GetTextZoom(float *aTextZoom);
nsresult SetTextZoom(float aTextZoom);
nsresult ScrollByLines(int32_t numLines);
nsresult ScrollByPages(int32_t numPages);
nsresult SizeToContent();
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);
nsresult RequestAnimationFrame(void /*const JS::Value*/ *aCallback, JSContext* cx, int32_t *_retval);
nsresult MozCancelAnimationFrame(int32_t aHandle);
nsresult MozCancelRequestAnimationFrame(int32_t aHandle);
nsresult CancelAnimationFrame(int32_t aHandle);
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,
uuid(8b29a62f-b448-49f3-9242-241d5cf94ea9),
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);
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,
uuid(5e49bff8-fb61-41e3-b6a9-2017865a6d74),
local
]
interface nsIDOMHTMLFormElement : nsIDOMHTMLElement
{
nsresult GetAcceptCharset(nsAString *aAcceptCharset);
nsresult SetAcceptCharset(const nsAString *aAcceptCharset);
nsresult GetAction(nsAString *aAction);
nsresult SetAction(const nsAString *aAction);
nsresult GetAutocomplete(nsAString *aAutocomplete);
nsresult SetAutocomplete(const nsAString *aAutocomplete);
nsresult GetEnctype(nsAString *aEnctype);
nsresult SetEnctype(const nsAString *aEnctype);
nsresult GetEncoding(nsAString *aEncoding);
nsresult SetEncoding(const nsAString *aEncoding);
nsresult GetMethod(nsAString *aMethod);
nsresult SetMethod(const nsAString *aMethod);
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
nsresult GetNoValidate(bool *aNoValidate);
nsresult SetNoValidate(bool aNoValidate);
nsresult GetTarget(nsAString *aTarget);
nsresult SetTarget(const nsAString *aTarget);
nsresult GetElements(nsIDOMHTMLCollection **aElements);
nsresult GetLength(int32_t *aLength);
nsresult Submit();
nsresult Reset();
nsresult CheckValidity(bool *_retval);
nsresult GetFormData(nsIDOMHTMLElement *aOriginatingElement, nsAString *aActionURI, nsIInputStream **aPostDataStream);
}
[
object,
uuid(d57537ed-39d0-46ea-8516-0ce0a5bfb805),
local
]
interface nsIDOMHTMLInputElement : nsIDOMHTMLElement
{
nsresult GetAccept(nsAString *aAccept);
nsresult SetAccept(const nsAString *aAccept);
nsresult GetAlt(nsAString *aAlt);
nsresult SetAlt(const nsAString *aAlt);
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);
nsresult GetInputMode(nsAString *aInputMode);
nsresult SetInputMode(const nsAString *aInputMode);
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);
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
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);
nsresult GetSrc(nsAString *aSrc);
nsresult SetSrc(const nsAString *aSrc);
nsresult GetType(nsAString *aType);
nsresult SetType(const nsAString *aType);
nsresult GetDefaultValue(nsAString *aDefaultValue);
nsresult SetDefaultValue(const nsAString *aDefaultValue);
nsresult GetValue(nsAString *aValue);
nsresult SetValue(const nsAString *aValue);
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);
nsresult Select();
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);
}
[
object,
uuid(09017cf4-0004-4c27-a340-7f5d2fe282e3),
local
]
interface nsIDOMHTMLOptionElement : nsIDOMHTMLElement
{
nsresult GetDisabled(bool *aDisabled);
nsresult SetDisabled(bool aDisabled);
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
nsresult GetLabel(nsAString *aLabel);
nsresult SetLabel(const nsAString *aLabel);
nsresult GetDefaultSelected(bool *aDefaultSelected);
nsresult SetDefaultSelected(bool aDefaultSelected);
nsresult GetSelected(bool *aSelected);
nsresult SetSelected(bool aSelected);
nsresult GetValue(nsAString *aValue);
nsresult SetValue(const nsAString *aValue);
nsresult GetText(nsAString *aText);
nsresult SetText(const nsAString *aText);
nsresult GetIndex(int32_t *aIndex);
}
[
object,
uuid(5564816e-2ab5-46ee-95a4-8f4688bdb449),
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),
local
]
interface nsIDOMHTMLOptionsCollection : nsISupports
{
typedef int nsWrapperCache;
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 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);
}
[
object,
uuid(8af2123f-c83a-430a-a739-d103a8eaba52),
local
]
interface nsIDOMHTMLSelectElement : nsIDOMHTMLElement
{
nsresult GetAutofocus(bool *aAutofocus);
nsresult SetAutofocus(bool aAutofocus);
nsresult GetDisabled(bool *aDisabled);
nsresult SetDisabled(bool aDisabled);
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
nsresult GetMultiple(bool *aMultiple);
nsresult SetMultiple(bool aMultiple);
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
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 select_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);
}
[
object,
uuid(b7e1b86f-c98e-4658-81ce-ac29962f854a),
local
]
interface nsIDOMHTMLTextAreaElement : nsIDOMHTMLElement
{
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);
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
nsresult GetMaxLength(int32_t *aMaxLength);
nsresult SetMaxLength(int32_t aMaxLength);
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
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);
nsresult GetType(nsAString *aType);
nsresult GetDefaultValue(nsAString *aDefaultValue);
nsresult SetDefaultValue(const nsAString *aDefaultValue);
nsresult GetValue(nsAString *aValue);
nsresult SetValue(const nsAString *aValue);
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);
nsresult Select();
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);
}
[
object,
uuid(8783371a-6185-4176-9ed9-f781c75bf48a),
local
]
interface nsIDOMHTMLScriptElement : nsIDOMHTMLElement
{
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);
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);
nsresult GetCrossOrigin(nsAString *aCrossOrigin);
nsresult SetCrossOrigin(const nsAString *aCrossOrigin);
}
[
object,
uuid(98c38ca0-5e3a-4c71-90a4-69d12a3c8d16),
local
]
interface nsIDOMHTMLImageElement : nsIDOMHTMLElement
{
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);
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);
nsresult GetHspace(int32_t *aHspace);
nsresult SetHspace(int32_t aHspace);
nsresult GetLongDesc(nsAString *aLongDesc);
nsresult SetLongDesc(const nsAString *aLongDesc);
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);
}
[
object,
uuid(76ec122a-db6d-4b3f-8a24-15faf117f695),
local
]
interface nsIDOMHTMLAnchorElement : nsIDOMHTMLElement
{
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);
nsresult GetDownload(nsAString *aPing);
nsresult SetDownload(const nsAString *aPing);
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);
nsresult GetCharset(nsAString *aCharset);
nsresult SetCharset(const nsAString *aCharset);
nsresult GetCoords(nsAString *aCoords);
nsresult SetCoords(const nsAString *aCoords);
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,
uuid(ad43cb9b-3253-446d-8ba9-50ee50ff017e),
local
]
interface nsIDOMHTMLLinkElement : nsIDOMHTMLElement
{
nsresult GetDisabled(bool *aDisabled);
nsresult SetDisabled(bool aDisabled);
nsresult GetCharset(nsAString *aCharset);
nsresult SetCharset(const nsAString *aCharset);
nsresult GetHref(nsAString *aHref);
nsresult SetHref(const nsAString *aHref);
nsresult GetHreflang(nsAString *aHreflang);
nsresult SetHreflang(const nsAString *aHreflang);
nsresult GetMedia(nsAString *aMedia);
nsresult SetMedia(const nsAString *aMedia);
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);
nsresult GetCrossOrigin(nsAString *aCrossOrigin);
nsresult SetCrossOrigin(const nsAString *aCrossOrigin);
}
[
object,
uuid(1a7bf1f1-5d6c-4200-9ceb-455874322315),
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();
nsresult InsertRow(int32_t index, nsIDOMHTMLElement **_retval);
nsresult DeleteRow(int32_t index);
}
[
object,
uuid(02094366-0d3d-47e3-949c-89113a9bcc15),
local
]
interface nsIDOMHTMLTableRowElement : nsIDOMHTMLElement
{
nsresult GetRowIndex(int32_t *aRowIndex);
nsresult GetSectionRowIndex(int32_t *aSectionRowIndex);
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);
nsresult InsertCell(int32_t index, nsIDOMHTMLElement **_retval);
nsresult DeleteCell(int32_t index);
}
[
object,
uuid(1fb22137-c231-4eae-9ca4-557bb0852d89),
local
]
interface nsIDOMHTMLTableCellElement : nsIDOMHTMLElement
{
nsresult GetCellIndex(int32_t *aCellIndex);
nsresult GetAbbr(nsAString *aAbbr);
nsresult SetAbbr(const nsAString *aAbbr);
nsresult GetAlign(nsAString *aAlign);
nsresult SetAlign(const nsAString *aAlign);
nsresult GetAxis(nsAString *aAxis);
nsresult SetAxis(const nsAString *aAxis);
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 GetColSpan(int32_t *aColSpan);
nsresult SetColSpan(int32_t aColSpan);
nsresult GetHeaders(nsAString *aHeaders);
nsresult SetHeaders(const nsAString *aHeaders);
nsresult GetHeight(nsAString *aHeight);
nsresult SetHeight(const nsAString *aHeight);
nsresult GetNoWrap(bool *aNoWrap);
nsresult SetNoWrap(bool aNoWrap);
nsresult GetRowSpan(int32_t *aRowSpan);
nsresult SetRowSpan(int32_t aRowSpan);
nsresult GetScope(nsAString *aScope);
nsresult SetScope(const nsAString *aScope);
nsresult GetVAlign(nsAString *aVAlign);
nsresult SetVAlign(const nsAString *aVAlign);
nsresult GetWidth(nsAString *aWidth);
nsresult SetWidth(const nsAString *aWidth);
}
[
object,
uuid(21ffbe98-51f5-499e-8d6f-612ae798c1e1),
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);
nsresult GetContentWindow(nsIDOMWindow **aContentWindow);
nsresult GetSandbox(nsAString *aSandbox);
nsresult SetSandbox(const nsAString *aSandbox);
nsresult GetAllowFullscreen(bool *aAllowFullscreen);
nsresult SetAllowFullscreen(bool aAllowFullscreen);
}
[
object,
uuid(1a79af54-dbbb-4532-be48-944f3995e7e9),
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);
nsresult GetNoResize(bool *aNoResize);
nsresult SetNoResize(bool aNoResize);
nsresult GetScrolling(nsAString *aScrolling);
nsresult SetScrolling(const nsAString *aScrolling);
nsresult GetSrc(nsAString *aSrc);
nsresult SetSrc(const nsAString *aSrc);
nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
nsresult GetContentWindow(nsIDOMWindow **aContentWindow);
}
[
object,
uuid(bed8f222-c4dd-41ba-9ec6-dfae0ec8def8),
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,
uuid(f85e1b05-6dc4-442d-bea8-7cf551f9bc9f),
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,
uuid(e81273e1-d440-4dd3-9073-8199f7a9525e),
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);
nsresult GetScoped(bool *aScoped);
nsresult SetScoped(bool aScoped);
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);
}
[
object,
uuid(94928ab3-8b63-11d3-989d-001083010e9b),
local
]
interface nsIURIContentListener : nsISupports
{
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);
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
{
nsresult OnShowTooltip(int32_t aXCoords, int32_t aYCoords, const PRUnichar *aTipText);
nsresult OnHideTooltip();
}
[
object,
uuid(33e9d001-caab-4ba9-8961-54902f197202),
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);
nsresult GetIsActive(bool *aIsActive);
nsresult SetIsActive(bool aIsActive);
}
cpp_quote("#define SETUP_ALLOW_JAVASCRIPT 2")
cpp_quote("#define SETUP_IS_CHROME_WRAPPER 7")
cpp_quote("#define SETUP_DISABLE_NOSCRIPT 16")
[
object,
uuid(f15398a0-8018-11d3-af70-00a024ffc08c),
local
]
interface nsIWebBrowserSetup : nsISupports
{
nsresult SetProperty(uint32_t aId, uint32_t aValue);
}
typedef void* nativeWindow;
[
object,
uuid(9da319f3-eee6-4504-81a5-6A19cf6215bf),
local
]
interface nsIBaseWindow : nsISupports
{
nsresult InitWindow(nativeWindow parentNativeWindow, nsIWidget *parentWidget, int32_t x,
int32_t y, int32_t cx, int32_t cy);
nsresult Create();
nsresult Destroy();
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);
nsresult SetParentWidget(nsIWidget *aParentWidget);
nsresult GetParentNativeWindow(nativeWindow *aParentNativeWindow);
nsresult SetParentNativeWindow(nativeWindow aParentNativeWindow);
nsresult GetNativeHandle(nsAString *aNativeHandle);
nsresult GetVisibility(bool *aVisibility);
nsresult SetVisibility(bool aVisibility);
nsresult GetEnabled(bool *aEnabled);
nsresult SetEnabled(bool aEnabled);
nsresult GetMainWidget(nsIWidget **aMainWidget);
nsresult GetUnscaledDevicePixelsPerCSSPixel(double *aUnscaledDevicePixelsPerCSSPixel);
nsresult SetFocus();
nsresult GetTitle(PRUnichar **aTitle);
nsresult SetTitle(const PRUnichar *aTitle);
}
[
object,
uuid(28404f7e-0f17-4dc3-a21a-2074d8659b02),
local
]
interface nsIWebNavigation : nsISupports
{
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;
nsresult GetCanGoBack(bool *aCanGoBack);
nsresult GetCanGoForward(bool *aCanGoForward);
nsresult GoBack();
nsresult GoForward();
nsresult GotoIndex(int32_t index);
nsresult LoadURI(const PRUnichar *aURI, uint32_t aLoadFlags, nsIURI *aReferrer,
nsIInputStream *aPostData, nsIInputStream *aHeaders);
nsresult Reload(uint32_t aReloadFlags);
nsresult Stop(uint32_t aStopFlags);
nsresult GetDocument(nsIDOMDocument **aDocument);
nsresult GetCurrentURI(nsIURI **aCurrentURI);
nsresult GetReferringURI(nsIURI **aReferringURI);
nsresult GetSessionHistory(nsISHistory **aSessionHistory);
nsresult SetSessionHistory(nsISHistory *aSessionHistory);
}
[
object,
uuid(1c3437b0-9e2c-11e2-9e96-0800200c9a66),
local
]
interface nsIWebProgress : nsISupports
{
nsresult AddProgressListener(nsIWebProgressListener *aListener, uint32_t aNotifyMask);
nsresult RemoveProgressListener(nsIWebProgressListener *aListener);
nsresult GetDOMWindow(nsIDOMWindow **aDOMWindow);
nsresult GetDOMWindowID(uint64_t *aDOMWindowID);
nsresult GetIsTopLevel(bool *aIsTopLevel);
nsresult GetIsLoadingDocument(bool *aIsLoadingDocument);
}
[
object,
uuid(1bcfc611-8941-4c39-9e06-7116e564a1ce),
local
]
interface nsIPrintSettings : nsISupports
{
typedef struct { char dummy; } nsIntMargin;
nsresult SetPrintOptions(int32_t aType, bool aTurnOnOff);
nsresult GetPrintOptions(int32_t aType, bool *_retval);
nsresult GetPrintOptionsBits(int32_t *_retval);
nsresult GetEffectivePageSize(double *aWidth, double *aHeight);
nsresult Clone(nsIPrintSettings **_retval);
nsresult Assign(nsIPrintSettings *aPS);
nsresult GetPrintSession(nsIPrintSession **aPrintSession);
nsresult SetPrintSession(nsIPrintSession *aPrintSession);
nsresult GetStartPageRange(int32_t *aStartPageRange);
nsresult SetStartPageRange(int32_t aStartPageRange);
nsresult GetEndPageRange(int32_t *aEndPageRange);
nsresult SetEndPageRange(int32_t aEndPageRange);
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);
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);
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);
nsresult GetScaling(double *aScaling);
nsresult SetScaling(double aScaling);
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);
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);
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);
nsresult GetPaperName(PRUnichar **aPaperName);
nsresult SetPaperName(const PRUnichar *aPaperName);
nsresult GetPaperSizeType(int16_t *aPaperSizeType);
nsresult SetPaperSizeType(int16_t aPaperSizeType);
nsresult GetPaperData(int16_t *aPaperData);
nsresult SetPaperData(int16_t aPaperData);
nsresult GetPaperWidth(double *aPaperWidth);
nsresult SetPaperWidth(double aPaperWidth);
nsresult GetPaperHeight(double *aPaperHeight);
nsresult SetPaperHeight(double aPaperHeight);
nsresult GetPaperSizeUnit(int16_t *aPaperSizeUnit);
nsresult SetPaperSizeUnit(int16_t aPaperSizeUnit);
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);
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);
nsresult GetPrintCommand(PRUnichar **aPrintCommand);
nsresult SetPrintCommand(const PRUnichar *aPrintCommand);
nsresult GetNumCopies(int32_t *aNumCopies);
nsresult SetNumCopies(int32_t aNumCopies);
nsresult GetPrinterName(PRUnichar **aPrinterName);
nsresult SetPrinterName(const PRUnichar *aPrinterName);
nsresult GetPrintToFile(bool *aPrintToFile);
nsresult SetPrintToFile(bool aPrintToFile);
nsresult GetToFileName(PRUnichar **aToFileName);
nsresult SetToFileName(const PRUnichar *aToFileName);
nsresult GetOutputFormat(int16_t *aOutputFormat);
nsresult SetOutputFormat(int16_t aOutputFormat);
nsresult GetPrintPageDelay(int32_t *aPrintPageDelay);
nsresult SetPrintPageDelay(int32_t aPrintPageDelay);
nsresult GetResolution(int32_t *aResolution) = 0;
nsresult SetResolution(int32_t aResolution) = 0;
nsresult GetDuplex(int32_t *aDuplex);
nsresult SetDuplex(int32_t aDuplex);
nsresult GetIsInitializedFromPrinter(bool *aIsInitializedFromPrinter);
nsresult SetIsInitializedFromPrinter(bool aIsInitializedFromPrinter);
nsresult GetIsInitializedFromPrefs(bool *aIsInitializedFromPrefs);
nsresult SetIsInitializedFromPrefs(bool aIsInitializedFromPrefs);
nsresult GetPersistMarginBoxSettings(bool *aPersistMarginBoxSettings);
nsresult SetPersistMarginBoxSettings(bool aPersistMarginBoxSettings);
nsresult SetMarginInTwips(nsIntMargin *aMargin);
nsresult SetEdgeInTwips(nsIntMargin *aEdge);
nsresult GetMarginInTwips(nsIntMargin *aMargin);
nsresult GetEdgeInTwips(nsIntMargin *aEdge);
nsresult SetupSilentPrinting();
nsresult SetUnwriteableMarginInTwips(nsIntMargin *aEdge);
nsresult GetUnwriteableMarginInTwips(nsIntMargin *aEdge);
nsresult GetPageRanges(void * /*nsTArray<int32_t>&*/ aPages);
}
[
object,
uuid(9a7ca4b0-fbba-11d4-a869-00105a183419),
local
]
interface nsIWebBrowserPrint : nsISupports
{
nsresult GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings);
nsresult GetCurrentPrintSettings(nsIPrintSettings **aCurrentPrintSettings);
nsresult GetCurrentChildDOMWindow(nsIDOMWindow **aCurrentChildDOMWindow);
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);
nsresult Print(nsIPrintSettings *aThePrintSettings, nsIWebProgressListener *aWPListener);
nsresult PrintPreview(nsIPrintSettings *aThePrintSettings, nsIDOMWindow *aChildDOMWin,
nsIWebProgressListener *aWPListener);
nsresult PrintPreviewNavigate(int16_t aNavType, int32_t aPageNum);
nsresult Cancel();
nsresult EnumerateDocumentNames(uint32_t *aCount, PRUnichar ***aResult);
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
};
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);
}
[
object,
uuid(272a5020-64f5-485c-a8c4-44b2882ae0a2),
local
]
interface nsIFile : nsISupports
{
typedef struct {
/* Currently not needed */
char dummy;
} PRFileDesc, PRLibrary, widl_FILE;
#define FILE widl_FILE
nsresult Append(const nsAString *node);
nsresult AppendNative(const nsAString *node);
nsresult Normalize();
nsresult Create(uint32_t type, uint32_t permission);
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);
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);
nsresult GetTarget(nsAString *aTarget);
nsresult GetNativeTarget(nsACString *aNativeTarget);
nsresult GetPath(nsAString *aPath);
nsresult GetNativePath(nsACString *aNativePath);
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);
nsresult Clone(nsIFile **_retval);
nsresult Equals(nsIFile *inFile, bool *_retval);
nsresult Contains(nsIFile *inFile, bool recir, bool *_retval);
nsresult GetParent(nsIFile **aParent);
nsresult GetDirectoryEntries(nsISimpleEnumerator **aDirectoryEntries);
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);
}
[
object,
uuid(55d25e49-793f-4727-a69f-de8b15f4b985),
local
]
interface nsIPrefBranch : nsISupports
{
nsresult GetRoot(char **aRoot);
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);
nsresult GetCharPref(const char *aPrefName, char **_retval);
nsresult SetCharPref(const char *aPrefName, const char *aValue);
nsresult GetIntPref(const char *aPrefName, int32_t *_retval);
nsresult SetIntPref(const char *aPrefName, int32_t aValue);
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);
nsresult PrefHasUserValue(const char *aPrefName, bool *_retval);
nsresult PrefIsLocked(const char *aPrefName, bool *_retval);
nsresult UnlockPref(const char *aPrefName);
nsresult DeleteBranch(const char *aStartingAt);
nsresult GetChildList(const char *aStartingAt, uint32_t *aCount, char ***aChildArray);
nsresult ResetBranch(const char *aStartingAt);
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);
}
[
object,
uuid(f5753fec-a051-4ddc-8891-11f1f1575072),
local
]
interface nsIProtocolHandler : nsISupports
{
nsresult GetScheme(nsACString *aScheme);
nsresult GetDefaultPort(int32_t *aDefaultPort);
nsresult GetProtocolFlags(uint32_t *aProtocolFlags);
nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset,
nsIURI *aBaseURI, nsIURI **_retval);
nsresult NewChannel(nsIURI *aURI, nsIChannel **_retval);
nsresult AllowPort(int32_t port, const char *scheme, bool *_retval);
}
[
object,
uuid(0e61f3b2-34d7-4c79-bfdc-4860bc7341b7),
local
]
interface nsIExternalProtocolHandler : nsIProtocolHandler
{
nsresult ExternalAppExistsForScheme(const nsACString *scheme, bool *_retval);
}
[
object,
uuid(bddeda3f-9020-4d12-8c70-984ee9f7935e),
local
]
interface nsIIOService : nsISupports
{
nsresult GetProtocolHandler(const char *aScheme, nsIProtocolHandler **_retval);
nsresult GetProtocolFlags(const char *aScheme, uint32_t *_retval);
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);
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);
}
[
object,
uuid(ca68c485-9db3-4c12-82a6-4fab7948e2d5),
local,
]
interface nsINetUtil : nsISupports
{
nsresult ParseContentType(const nsACString *aTypeHeader, nsACString *aCharset,
bool *aHadCharset, nsACString *_retval);
nsresult ProtocolHasFlags(nsIURI *aURI, uint32_t aFlag, bool *_retval);
nsresult URIChainHasFlags(nsIURI *aURI, uint32_t aFlags, bool *_retval);
nsresult ToImmutableURI(nsIURI *aURI, nsIURI **_retval);
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);
nsresult ExtractCharsetFromContentType(const nsACString *aTypeHeader, nsACString *aCharset,
int32_t *aCharsetStart, int32_t *aCharsetEnd, bool *_retval);
}
[
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,
uuid(e8c414c4-dc38-4ba3-ab4e-ec4cbbe22907),
local
]
interface nsIWebBrowserChrome : nsISupports
{
nsresult SetStatus(uint32_t statusType, const PRUnichar *status);
nsresult GetWebBrowser(nsIWebBrowser **aWebBrowser);
nsresult SetWebBrowser(nsIWebBrowser *aWebBrowser);
nsresult GetChromeFlags(uint32_t *aChromeFlags);
nsresult SetChromeFlags(uint32_t aChromeFlags);
nsresult DestroyBrowserWindow();
nsresult SizeBrowserTo(int32_t aCX, int32_t aCY);
nsresult ShowAsModal();
nsresult IsWindowModal(bool *_retval);
nsresult ExitModalEventLoop(nsresult aStatus);
}
[
object,
uuid(df31c120-ded6-11d1-bd85-00805f8ae3f4),
local
]
interface nsIDOMEventListener : nsISupports
{
nsresult HandleEvent(nsIDOMEvent *event);
}
[
object,
uuid(31e92e56-4d23-4a4a-9cfe-a6d12cf434bc),
local
]
interface nsIDOMEventTarget : nsISupports
{
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 */
}
[
object,
uuid(02d54f52-a1f5-4ad2-b560-36f14012935e),
local
]
interface nsIDOMEvent : nsISupports
{
nsresult GetType(nsAString *aType);
nsresult GetTarget(nsIDOMEventTarget **aTarget);
nsresult GetCurrentTarget(nsIDOMEventTarget **aCurrentTarget);
nsresult GetEventPhase(uint16_t *aEventPhase);
nsresult GetBubbles(bool *aBubbles);
nsresult GetCancelable(bool *aCancelable);
nsresult GetTimeStamp(DOMTimeStamp *aTimeStamp);
nsresult StopPropagation();
nsresult PreventDefault();
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();
void SetTrusted(bool aTrusted);
void Serialize(/*IPC::Message*/ void *aMsg, bool aSerializeInterfaceType);
bool Deserialize(const /*IPC::Message*/ void *aMsg, void **aIter);
void SetOwner(void /*mozilla::dom::EventTarget*/ *aOwner);
void /*nsDOMEvent*/ *InternalDOMEvent();
}
[
object,
uuid(cbe333d7-5b2c-4a9b-b99b-e6e388afa62b),
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);
nsresult SetCriticalDisplayPortForElement(float aXPx, float aYPx, float aWidthPx, float aHeightPx, nsIDOMElement *aElement);
nsresult SetResolution(float aXResolution, float aYResolution);
nsresult GetResolution(float *aXResolution, float *aYResolution);
nsresult GetIsFirstPaint(bool *aIsFirstPaint);
nsresult SetIsFirstPaint(bool aIsFirstPaint);
nsresult GetPresShellId(uint32_t *aPresShellId);
nsresult SendMouseEvent(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, bool *_retval);
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);
nsresult GetScrollbarSize(bool aFlushLayout, int32_t *aWidth, int32_t *aHeight);
nsresult GetBoundsWithoutFlushing(nsIDOMElement *aElement, nsIDOMClientRect **_retval);
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);
nsresult DispatchEventToChromeOnly(nsIDOMEventTarget *aTarget, nsIDOMEvent *aEvent, bool *_retval);
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);
nsresult GetLayerManagerRemote(bool *aLayerManagerRemote);
nsresult StartFrameTimeRecording(uint32_t *startIndex);
nsresult StopFrameTimeRecording(uint32_t startIndex, float **paintTimes, uint32_t *frameCount, float **frameIntervals);
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();
nsresult GetIsTestControllingRefreshes(bool *aIsTestControllingRefreshes);
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);
nsresult SetContentDocumentFixedPositionMargins(float aTop, float aRight, float aBottom, float aLeft);
nsresult PreventFurtherDialogs();
nsresult LoadSheet(nsIURI *sheetURI, uint32_t type);
nsresult RemoveSheet(nsIURI *sheetURI, uint32_t type);
nsresult GetIsHandlingUserInput(bool *aIsHandlingUserInput);
nsresult AllowScriptsToClose();
nsresult GetIsParentWindowMainWidgetVisible(bool *aIsParentWindowMainWidgetVisible);
nsresult IsNodeDisabledForEvents(nsIDOMNode *aNode, bool *_retval);
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);
}
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
{
nsresult OnShowContextMenu(uint32_t aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode);
}
[
object,
uuid(d73852f8-7bd6-477d-8233-117dbf83860b),
local
]
interface nsIDOMUIEvent : nsIDOMEvent
{
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);
}
[
object,
uuid(afb2e57b-2822-4969-b2a9-0cada6859534),
local
]
interface nsIDOMMouseEvent : nsIDOMUIEvent
{
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);
nsresult GetRelatedTarget(nsIDOMEventTarget **aRelatedTarget);
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,
nsIDOMEventTarget *relatedTargetArg);
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);
}
[
object,
uuid(91a3d7f2-223b-4e09-a566-634e7ee0a31d),
local
]
interface nsIDOMKeyEvent : nsIDOMUIEvent
{
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);
nsresult GetKey(nsAString *aKey);
}
[
object,
uuid(0b976267-4aaa-4f36-a2d4-27b5ca8d73bb),
local
]
interface nsIEmbeddingSiteWindow : nsISupports
{
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);
nsresult SetFocus();
nsresult GetVisibility(bool *aVisibility);
nsresult SetVisibility(bool aVisibility);
nsresult GetTitle(PRUnichar **aTitle);
nsresult SetTitle(const PRUnichar *aTitle);
nsresult GetSiteWindow(void **aSiteWindow);
nsresult Blur();
}
[
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);
nsresult IsCIDRegistered(const nsCID *aClass, bool *_retval);
nsresult IsContractIDRegistered(const char *aContractID, bool *_retval);
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,
const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState);
nsresult Confirm(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, bool *_retval);
nsresult ConfirmCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState,
bool *_retval);
nsresult ConfirmEx(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, uint32_t aButtonFlags, const PRUnichar *aButton0Title,
const PRUnichar *aButton1Title, const PRUnichar *aButton2Title,
const PRUnichar *aCheckMsg, bool *aCheckState, int32_t *_retval);
nsresult Prompt(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, PRUnichar **aValue, const PRUnichar *aCheckMsg,
bool *aCheckState, bool *_retval);
nsresult PromptUsernameAndPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, PRUnichar **aUsername, PRUnichar **aPassword,
const PRUnichar *aCheckMsg, bool *aCheckState, bool *_retval);
nsresult PromptPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, PRUnichar **aPassword, const PRUnichar *aCheckMsg,
bool *aCheckState, bool *_retval);
nsresult Select(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, uint32_t aCount, const PRUnichar **aSelectList,
int32_t *aOutSelection, bool *_retval);
}
[
object,
uuid(b128a1e6-44f3-4331-8fbe-5af360ff21ee),
local
]
interface nsITooltipTextProvider : nsISupports
{
nsresult GetNodeText(nsIDOMNode *aNode, PRUnichar **aText, bool *_retval);
}
[
object,
uuid(24f3f4da-18a4-448d-876d-7360fefac029),
local
]
interface nsIEditingSession : nsISupports
{
nsresult GetEditorStatus(uint32_t *aEditorStatus);
nsresult MakeWindowEditable(nsIDOMWindow *window, const char *aEditorType,
bool doAfterUriLoad, bool aMakeWholeDocumentEditable, bool aInteractive);
nsresult WindowIsEditable(nsIDOMWindow *window, bool *_retval);
nsresult GetEditorForWindow(nsIDOMWindow *window, nsIEditor **_retval);
nsresult SetupEditorOnWindow(nsIDOMWindow *window);
nsresult TearDownEditorOnWindow(nsIDOMWindow *window);
nsresult SetEditorOnControllers(nsIDOMWindow *aWindow, nsIEditor *aEditor);
nsresult DisableJSAndPlugins(nsIDOMWindow *aWindow);
nsresult RestoreJSAndPlugins(nsIDOMWindow *aWindow);
nsresult DetachFromWindow(nsIDOMWindow *aWindow);
nsresult ReattachToWindow(nsIDOMWindow *aWindow);
nsresult GetJsAndPluginsDisabled(bool *aJsAndPluginsDisabled);
}
[
object,
uuid(83f892cf-7ed3-490e-967a-62640f3158e1),
local
]
interface nsICommandParams : nsISupports
{
nsresult GetValueType(const char *name, int16_t *_retval);
nsresult GetBooleanValue(const char *name, bool *_retval);
nsresult GetLongValue(const char *name, int32_t *_retval);
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);
nsresult SetBooleanValue(const char *name, bool value);
nsresult SetLongValue(const char *name, int32_t value);
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);
nsresult HasMoreElements(bool *_retval);
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);
nsresult IsCommandSupported(const char *aCommandName, nsIDOMWindow *aTargetWindow, bool *_retval);
nsresult IsCommandEnabled(const char *aCommandName, nsIDOMWindow *aTargetWindow, bool *_retval);
nsresult GetCommandState(const char *aCommandName, nsIDOMWindow *aTargetWindow,
nsICommandParams *aCommandParams);
nsresult DoCommand(const char *aCommandName, nsICommandParams *aCommandParams,
nsIDOMWindow *aTargetWindow);
}
[
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);
}
[
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
{
nsresult IsCommandEnabled(const char *command, bool *_retval);
nsresult SupportsCommand(const char *command, bool *_retval);
nsresult DoCommand(const char *command);
nsresult OnEvent(const char *eventName);
}
[
object,
uuid(8a8b4b1d-72d8-428e-9575-f918baf69ea1),
local
]
interface nsIContent : nsISupports
{
/* This is not a real interface declaration. It's too internal for us. */
}
[
object,
uuid(62cca591-a030-4117-9b80-dcd366bbb509),
local
]
interface nsIDocument : nsISupports
{
/* This is not a real interface declaration. It's too internal for us. */
}
[
object,
uuid(b1ee32f2-b8c4-49b9-93df-b6fab5d54688),
local
]
interface nsIContentSerializer : nsISupports
{
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,
nsAString *aStr);
nsresult AppendDoctype(nsIContent *aDoctype, nsAString *aStr);
nsresult AppendElementStart(nsIContent *aElement, nsIContent *aOriginalElement,
nsAString *aStr);
nsresult AppendElementEnd(nsIContent *aElement, nsAString *aStr);
nsresult Flush(nsAString *aStr);
nsresult AppendDocumentStart(nsIDocument *aDocument, nsAString *aStr);
}
[
object,
uuid(753b38d1-ee03-4e58-a650-1076ccccdb7f),
local
]
interface nsIEditor : nsISupports
{
typedef void *nsIContentPtr;
nsresult GetSelection([out] nsISelection *_retval);
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);
nsresult PostCreate();
nsresult PreDestroy();
nsresult GetFlags([out] uint32_t *_retval);
nsresult SetFlags([in] uint32_t val);
nsresult GetContentsMIMEType([out] char **_retval);
nsresult SetContentsMIMEType([in] const char *val);
nsresult GetIsDocumentEditable([out] bool *_retval);
nsresult GetIsSelectionEditable(bool *aIsSelectionEditable);
nsresult GetDocument([out] nsIDOMDocument **_retval);
nsresult GetRootElement([out] nsIDOMElement **_retval);
nsresult GetSelectionController([out] nsISelectionController **_retval);
nsresult DeleteSelection(int16_t action, int16_t aStripWrappers);
nsresult GetDocumentIsEmpty([out] bool *_retval);
nsresult GetDocumentModified([out] bool *_retval);
nsresult GetDocumentCharacterSet([out] nsACString *_retval);
nsresult SetDocumentCharacterSet([in] const nsACString *val);
nsresult ResetModificationCount();
nsresult GetModificationCount([out] int32_t *_retval);
nsresult IncrementModificationCount([in] int32_t aModCount);
nsresult GetTransactionManager([out] nsITransactionManager **_retval);
nsresult SetTransactionManager(nsITransactionManager *aTransactionManager);
nsresult DoTransaction([in] nsITransaction *txn);
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);
nsresult BeginTransaction();
nsresult EndTransaction();
nsresult BeginPlaceHolderTransaction([in] nsIAtom *name);
nsresult EndPlaceHolderTransaction();
nsresult ShouldTxnSetSelection([out] bool *_retval);
nsresult SetShouldTxnSetSelection([in] bool should);
nsresult GetInlineSpellChecker([out] nsIInlineSpellChecker **_retval);
nsresult SyncRealTimeSpell();
nsresult SetSpellcheckUserOverride(bool enable);
nsresult Cut();
nsresult CanCut([out] bool *_retval);
nsresult Copy();
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);
nsresult SelectAll();
nsresult BeginningOfDocument();
nsresult EndOfDocument();
nsresult SetAttribute([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [in] const nsAString *attvalue);
nsresult GetAttributeValue([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [out] nsAString *resultValue, bool *_retval);
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);
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);
nsresult JoinNodes([in] nsIDOMNode *leftNode, [in] nsIDOMNode *rightNode, [in] nsIDOMNode *parent);
nsresult DeleteNode([in] nsIDOMNode *child);
bool OutputsMozDirty();
nsresult MarkNodeDirty([in] nsIDOMNode *node);
nsresult SwitchTextDirection();
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);
nsresult SetEditorObserver(nsIEditorObserver *observer);
nsresult RemoveEditorObserver(nsIEditorObserver *observer);
nsresult AddEditActionListener([in] nsIEditActionListener *listener);
nsresult RemoveEditActionListener([in] nsIEditActionListener *listener);
nsresult AddDocumentStateListener([in] nsIDocumentStateListener *listener);
nsresult RemoveDocumentStateListener([in] nsIDocumentStateListener *listener);
nsresult DumpContentTree();
nsresult DebugDumpContent();
nsresult DebugUnitTests([out] int32_t *outNumTests, [out] int32_t *outNumTestsFailed);
bool IsModifiableNode(nsIDOMNode *aNode);
nsresult GetLastKeypressEventTrusted(bool *aLastKeypressEventTrusted);
nsresult SetSuppressDispatchingInputEvent(bool aSuppressDispatchingInputEvent);
}
[
object,
uuid(833f30de-94c7-4630-a852-2300ef329d7b),
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);
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);
nsresult RemoveAllInlineProperties();
nsresult RemoveInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute);
nsresult IncreaseFontSize();
nsresult DecreaseFontSize();
nsresult NodeIsBlock([in] nsIDOMNode *node, bool *_retval);
nsresult InsertHTML([in] nsAString *aInputString);
nsresult PasteNoFormatting([in] int32_t aSelectionType);
nsresult RebuildDocumentFromSource([in] nsAString *aSourceString);
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);
nsresult SetDocumentTitle([in] nsAString *aTitle);
nsresult UpdateBaseURL();
nsresult SelectElement([in] nsIDOMElement *aElement);
nsresult SetCaretAfterElement([in] nsIDOMElement *aElement);
nsresult SetParagraphFormat([in] nsAString *aParagraphFormat);
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);
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);
nsresult GetIsCSSEnabled([out] bool *_retval);
nsresult SetIsCSSEnabled([in] bool prb);
nsresult AddInsertionListener([in] nsIContentFilter *inFilter);
nsresult RemoveInsertionListener([in] nsIContentFilter *inFilter);
nsresult CreateAnonymousElement([in] nsAString *aTag, [in] nsIDOMNode *aParentNode, [in] nsAString *aAnonClass, [in] bool aIsCreatedHidden, [out] nsIDOMElement **_retval);
nsresult GetSelectionContainer([out] nsIDOMElement **_retval);
nsresult CheckSelectionStateForAnonymousButtons([in] nsISelection *aSelection);
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();
}
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,
uuid(e35bbb39-985b-4d62-81da-73c330222e5f),
local
]
interface nsIDocShellTreeItem : nsIDocShellTreeNode
{
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
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);
}
[
object,
uuid(f453d2ee-bac7-46f9-a553-df918f0cc0d0),
local
]
interface nsIDocShell : nsIDocShellTreeItem
{
nsresult LoadURI(nsIURI *uri, nsIDocShellLoadInfo *loadInfo, uint32_t aLoadFlags, bool firstParty);
nsresult LoadStream(nsIInputStream *aStream, nsIURI *aURI, const nsACString *aContentType,
const nsACString *aContentCharset, nsIDocShellLoadInfo *aLoadInfo);
nsresult InternalLoad(nsIURI *aURI, nsIURI *aReferrer, nsISupports *aOwner, uint32_t aFlags, const PRUnichar *aWindowTarget,
const char *aTypeHint, nsACString *aFileName, nsIInputStream *aPostDataStream, nsIInputStream *aHeadersStream,
uint32_t aLoadFlags, nsISHEntry *aSHEntry, bool firstParty, nsIDocShell **aDocShell, nsIRequest **aRequest);
nsresult AddState(nsIVariant *aData, const nsAString *aTitle, const nsAString *aURL, bool aReplace, JSContext *cx);
nsresult CreateLoadInfo(nsIDocShellLoadInfo **loadInfo);
nsresult PrepareForNewContentModel();
nsresult SetCurrentURI(nsIURI *aURI);
nsresult FirePageHideNotification(bool isUnload);
nsresult GetPresContext(void /*nsPresContext*/ **aPresContext);
nsIPresShell *GetPresShell();
nsresult GetEldestPresShell(nsIPresShell **aEldestPresShell);
nsresult GetContentViewer(nsIContentViewer **aContentViewer);
nsresult GetChromeEventHandler(nsIDOMEventTarget **aChromeEventHandler);
nsresult SetChromeEventHandler(nsIDOMEventTarget *aChromeEventHandler);
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);
nsresult GetAllowMedia(bool *aAllowMedia);
nsresult SetAllowMedia(bool aAllowMedia);
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);
nsresult GetZoom(float *aZoom);
nsresult SetZoom(float aZoom);
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);
nsresult GetLayoutHistoryState(nsILayoutHistoryState **aLayoutHistoryState);
nsresult SetLayoutHistoryState(nsILayoutHistoryState *aLayoutHistoryState);
nsresult GetShouldSaveLayoutState(bool *aShouldSaveLayoutState);
nsresult GetSecurityUI(nsISecureBrowserUI **aSecurityUI);
nsresult SetSecurityUI(nsISecureBrowserUI *aSecurityUI);
nsresult SuspendRefreshURIs();
nsresult ResumeRefreshURIs();
nsresult BeginRestore(nsIContentViewer *viewer, bool top);
nsresult FinishRestore();
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);
nsresult AddSessionStorage(nsIPrincipal *principal, nsIDOMStorage *storage);
nsresult GetCurrentDocumentChannel(nsIChannel **aCurrentDocumentChannel);
nsresult SetChildOffset(uint32_t offset);
nsresult GetIsInUnload(bool *aIsInUnload);
nsresult GetChannelIsUnsafe(bool *aChannelIsUnsafe);
nsresult GetHasMixedActiveContentLoaded(bool *aHasMixedActiveContentLoaded);
nsresult GetHasMixedActiveContentBlocked(bool *aHasMixedActiveContentBlocked);
nsresult GetHasMixedDisplayContentLoaded(bool *aHasMixedDisplayContentLoaded);
nsresult GetHasMixedDisplayContentBlocked(bool *aHasMixedDisplayContentBlocked);
void DetachEditorFromWindow();
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);
nsresult GatherCharsetMenuTelemetry();
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);
nsresult AddWeakReflowObserver(nsISupports /*nsIReflowObserver*/ *obs);
nsresult RemoveWeakReflowObserver(nsISupports /*nsIReflowObserver*/ *obs);
nsresult NotifyReflowObservers(bool interruptible, int /*DOMHighResTimeStamp*/ start, int /*DOMHighResTimeStamp*/ end);
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);
nsresult GetMixedContentChannel(nsIChannel **aMixedContentChannel);
nsresult SetMixedContentChannel(nsIChannel *aMixedContentChannel);
nsresult GetAllowMixedContentAndConnectionData(bool *rootHasSecureConnection, bool *allowMixedContent, bool *isRootDocShell);
bool PluginsAllowedInCurrentDoc();
nsresult GetFullscreenAllowed(bool *aFullscreenAllowed);
nsresult SetFullscreenAllowed(bool allowed);
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);
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);
}
[
object,
uuid(16fe5e3e-eadc-4312-9d44-b6bedd6b5474),
local
]
interface nsIMutationObserver : nsISupports
{
void CharacterDataWillChange(nsIDocument *aDocument, nsIContent *aContent,
void /*CharacterDataChangeInfo*/ *aInfo);
void CharacterDataChanged(nsIDocument *aDocument, nsIContent *aContent,
void /*CharacterDataChangeInfo*/ *aInfo);
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);
void ContentInserted(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
int32_t aIndexInContainer);
void ContentRemoved(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
int32_t aIndexInContainer, nsIContent *aPreviousSibling);
void NodeWillBeDestroyed(const nsINode *aNode);
void ParentChainChanged(nsIContent *aContent);
}
[
object,
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),
local
]
interface nsIDocumentObserver : nsIMutationObserver
{
typedef uint32_t nsUpdateType;
typedef struct {
uint64_t mStates;
} nsEventStates;
void BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
void EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
void BeginLoad(nsIDocument *aDocument);
void EndLoad(nsIDocument *aDocument);
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);
void StyleSheetApplicableStateChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet,
bool aApplicable);
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);
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);
}
cpp_quote("DEFINE_GUID(IID_nsCycleCollectionISupports, 0xc61eac14,0x5f7a,0x4481,0x96,0x5e,0x7e,0xaa,0x6e,0xff,0xa8,0x5f);")