Sweden-Number/dlls/mshtml/nsiface.idl

4218 lines
178 KiB
Plaintext
Raw Normal View History

/*
2012-06-11 15:32:18 +02:00
* 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
*/
2011-11-09 18:11:42 +01:00
/*
* NOTE:
2008-05-06 15:54:52 +02:00
* This file is not a typical idl file. Interfaces in this file are XPCOM
* interfaces (NOT MSCOM!), but we generate the header file with WIDL
* compatible with XPCOM, usable in C code.
*/
#pragma makedep header
cpp_quote("#define GECKO_VERSION \"2.47\"")
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")
2014-11-03 12:39:59 +01:00
cpp_quote("#undef GetClassName")
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.
*/
2013-01-18 14:06:09 +01:00
#define int16_t short
#define int32_t LONG
2013-01-23 18:43:25 +01:00
#define int64_t INT64
2013-01-23 18:43:39 +01:00
#define uint8_t UINT8
2013-01-23 18:43:55 +01:00
#define uint16_t UINT16
#define uint32_t UINT32
2013-01-23 18:44:56 +01:00
#define uint64_t UINT64
#define char16_t PRUnichar
typedef uint64_t DOMTimeStamp;
typedef uint32_t nsLoadFlags;
2013-01-09 14:21:18 +01:00
typedef int64_t PRTime;
/* Similar trick to stdint.h types for C++ bool type */
typedef unsigned char cpp_bool;
#define bool cpp_bool
2012-03-14 14:45:32 +01:00
2006-03-18 22:00:34 +01:00
typedef struct {
void *v;
void *d1;
uint32_t d2;
2006-03-18 22:00:34 +01:00
void *d3;
} nsCStringContainer;
typedef struct {
void *v;
void *d1;
uint32_t d2;
void *d3;
} nsStringContainer;
2006-02-09 12:17:38 +01:00
typedef nsCStringContainer nsACString;
2005-12-15 10:41:56 +01:00
typedef nsStringContainer nsAString;
interface nsIWebBrowserChrome;
interface nsILoadGroup;
interface nsIDOMNode;
2013-09-25 14:17:08 +02:00
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;
2011-08-23 14:07:02 +02:00
interface nsIDOMRange;
2011-11-09 18:11:42 +01:00
interface nsIDOMEventTarget;
interface nsISelection;
2012-03-14 14:45:32 +01:00
interface nsIDOMHTMLSelectElement;
interface nsIFile;
2014-11-03 12:39:59 +01:00
interface nsIDocShell;
interface mozIDOMWindowProxy;
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 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 nsIDOMHTMLTableSectionElement;
2008-12-30 06:48:59 +01:00
typedef nsISupports nsIDOMClientRectList;
typedef nsISupports nsINode;
typedef nsISupports nsIDOMUserDataHandler;
typedef nsISupports nsISHEntry;
typedef nsISupports nsIPresShell;
typedef nsISupports nsIDocumentCharsetInfo;
typedef nsISupports nsILayoutHistoryState;
typedef nsISupports nsISecureBrowserUI;
typedef nsISupports nsIDOMStorage;
2010-08-25 14:22:25 +02:00
typedef nsISupports nsIDOMDOMTokenList;
typedef nsISupports nsITransferable;
typedef nsISupports nsIDOMFileList;
typedef nsISupports nsIDOMFile;
2010-08-25 14:22:25 +02:00
typedef nsISupports nsIControllers;
2011-03-15 13:45:29 +01:00
typedef nsISupports nsIDOMValidityState;
typedef nsISupports nsIPluginInstanceOwner;
typedef nsISupports nsIPluginStreamListener;
typedef nsISupports nsIContentSink;
typedef nsISupports nsIParserFilter;
typedef nsISupports nsIDTD;
typedef nsISupports nsIObserver;
2011-08-23 14:07:02 +02:00
typedef nsISupports nsIDOMNodeFilter;
typedef nsISupports nsIDOMNodeIterator;
typedef nsISupports nsIDOMTreeWalker;
typedef nsISupports nsIHttpUpgradeListener;
2011-11-09 18:11:42 +01:00
typedef nsISupports nsIDOMOfflineResourceList;
typedef nsISupports nsIDOMNavigator;
typedef nsISupports nsIDOMScreen;
typedef nsISupports nsIAnimationFrameListener;
typedef nsISupports nsIDOMStorageList;
typedef nsISupports nsILocalFile;
typedef nsISupports nsIDOMHTMLMenuElement;
typedef nsISupports nsIDOMCaretPosition;
2012-03-14 14:45:32 +01:00
typedef nsISupports nsIFrameRequestCallback;
typedef nsISupports nsICycleCollectorListener;
typedef nsISupports nsIDOMHTMLCanvasElement;
typedef nsISupports nsIQueryContentEventResult;
typedef nsISupports nsIDOMBlob;
2012-10-09 11:26:18 +02:00
typedef nsISupports nsIPrivacyTransitionObserver;
typedef nsISupports nsIDOMHTMLPropertiesCollection;
typedef nsISupports mozIDOMApplication;
2013-05-17 12:34:34 +02:00
typedef nsISupports nsIDOMCrypto;
typedef nsISupports nsIDOMPkcs11;
typedef nsISupports nsIDocShellTreeOwner;
2014-11-03 12:39:59 +01:00
typedef nsISupports nsIArray;
typedef nsISupports nsILoadInfo;
typedef nsISupports nsIContentSecurityPolicy;
typedef nsISupports nsIXMLHttpRequestUpload;
typedef nsISupports nsIClassInfo;
typedef nsISupports nsILoadContext;
typedef nsISupports nsIDomainPolicy;
typedef nsISupports nsIScriptContext;
typedef nsISupports nsIObjectInputStream;
typedef nsISupports nsIObjectOutputStream;
2011-08-23 14:07:02 +02:00
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);
2007-07-27 02:57:14 +02:00
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);
}
2006-03-27 21:02:28 +02:00
[
object,
uuid(9188bc85-f92e-11d2-81ef-0060083a0bcf),
local
2006-03-27 21:02:28 +02:00
]
interface nsIWeakReference : nsISupports
{
nsresult QueryReferent(const nsIID *riid, void **result);
}
[
object,
uuid(9188bc86-f92e-11d2-81ef-0060083a0bcf),
local
2006-03-27 21:02:28 +02:00
]
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);
}
2008-12-30 06:48:59 +01:00
[
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,
2013-01-09 14:21:18 +01:00
uuid(53cdbc97-c2d7-4e30-b2c3-45b2ee79db18),
local
]
interface nsIInputStream : nsISupports
{
nsresult Close();
2013-01-09 14:21:18 +01:00
nsresult Available(uint64_t *_retval);
nsresult Read(char *aBuf, uint32_t aCount, uint32_t *_retval);
2011-08-23 14:07:02 +02:00
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(8429d350-1040-4661-8b71-f2a6ba455980),
local
]
interface nsISeekableStream : nsISupports
{
enum {
NS_SEEK_SET = 0,
NS_SEEK_CUR = 1,
NS_SEEK_END = 2
};
nsresult Seek(int32_t whence, int64_t offset);
nsresult Tell(int64_t *_retval);
nsresult SetEOF();
}
2005-08-11 20:36:48 +02:00
[
object,
uuid(92073a54-6d78-4f30-913a-b871813208c6),
local
2005-08-11 20:36:48 +02:00
]
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);
2005-08-11 20:36:48 +02:00
nsresult GetPath(nsACString *aPath);
nsresult SetPath(const nsACString *aPath);
nsresult Equals(nsIURI *other, bool *_retval);
nsresult SchemeIs(const char *scheme, bool *_retval);
2005-08-11 20:36:48 +02:00
nsresult Clone(nsIURI **_retval);
nsresult Resolve(const nsACString *relativePath, nsACString *_retval);
nsresult GetAsciiSpec(nsACString *aAsciiSpec);
nsresult GetAsciiHostPort(nsACString *aAsciiHostPort);
2005-08-11 20:36:48 +02:00
nsresult GetAsciiHost(nsACString *aAsciiHost);
nsresult GetOriginCharset(nsACString *aOriginCharset);
2011-11-09 18:11:42 +01:00
nsresult GetRef(nsACString *aRef);
nsresult SetRef(const nsACString *aRef);
nsresult EqualsExceptRef(nsIURI *other, bool *_retval);
2011-11-09 18:11:42 +01:00
nsresult CloneIgnoringRef(nsIURI **_retval);
nsresult GetSpecIgnoringRef(nsACString *aSpecIgnoringRef);
nsresult GetHasRef(bool *aHasRef);
2005-08-11 20:36:48 +02:00
}
2009-08-27 11:31:14 +02:00
[
object,
uuid(86adcd89-0b70-47a2-b0fe-5bb2c5f37e31),
2009-08-27 11:31:14 +02:00
local
]
interface nsIURL : nsIURI
{
nsresult GetFilePath(nsACString *aFilePath);
nsresult SetFilePath(const nsACString *aFilePath);
nsresult GetQuery(nsACString *aQuery);
nsresult SetQuery(const nsACString *aQuery);
nsresult GetDirectory(nsACString *aDirectory);
nsresult SetDirectory(const nsACString *aDirectory);
nsresult GetFileName(nsACString *aFileName);
nsresult SetFileName(const nsACString *aFileName);
nsresult GetFileBaseName(nsACString *aFileBaseName);
nsresult SetFileBaseName(const nsACString *aFileBaseName);
nsresult GetFileExtension(nsACString *aFileExtension);
nsresult SetFileExtension(const nsACString *aFileExtension);
nsresult GetCommonBaseSpec(nsIURI *aURIToCompare, nsACString *_retval);
nsresult GetRelativeSpec(nsIURI *aURIToCompare, nsACString *_retval);
}
[
object,
uuid(e91ac988-27c2-448b-b1a1-3822e1ef1987),
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);
nsresult SetDefaultPort(int32_t aNewDefaultPort);
}
2006-02-09 12:19:13 +01:00
[
object,
uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe),
local
2006-02-09 12:19:13 +01:00
]
interface nsIRequest : nsISupports
{
nsresult GetName(nsACString *aName);
nsresult IsPending(bool *_retval);
2006-02-09 12:19:13 +01:00
nsresult GetStatus(nsresult *aStatus);
nsresult Cancel(nsresult aStatus);
nsresult Suspend();
nsresult Resume();
nsresult GetLoadGroup(nsILoadGroup **aLoadGroup);
nsresult SetLoadGroup(nsILoadGroup *aLoadGroup);
nsresult GetLoadFlags(nsLoadFlags *aLoadFlags);
nsresult SetLoadFlags(nsLoadFlags aLoadFlags);
}
[
object,
uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40),
local
]
interface nsIRequestObserver : nsISupports
{
nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext);
nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode);
}
[
object,
2013-01-09 14:21:18 +01:00
uuid(3b4c8a77-76ba-4610-b316-678c73a3b88c),
local
2011-08-23 14:07:02 +02:00
]
interface nsIStreamListener : nsIRequestObserver
{
nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
2013-01-09 14:21:18 +01:00
nsIInputStream *aInputStream, uint64_t aOffset, uint32_t aCount);
}
[
object,
uuid(f0c87725-7a35-463c-9ceb-2c07f23406cc),
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 GetSchedulingContextID(nsID *aSchedulingContextID);
2014-11-03 12:39:59 +01:00
nsresult GetDefaultLoadFlags(nsLoadFlags *aDefaultLoadFlags);
nsresult SetDefaultLoadFlags(nsLoadFlags aDefaultLoadFlags);
nsresult GetUserAgentOverrideCache(nsACString *aUserAgentOverrideCache);
nsresult SetUserAgentOverrideCache(const nsACString *aUserAgentOverrideCache);
}
2006-02-09 12:19:13 +01:00
[
object,
uuid(2c389865-23db-4aa7-9fe5-60cc7b00697e),
local
2006-02-09 12:19:13 +01:00
]
interface nsIChannel : nsIRequest
{
2013-04-04 16:15:16 +02:00
const UINT LOAD_DOCUMENT_URI = 1 << 16;
const UINT LOAD_RETARGETED_DOCUMENT_URI = 1 << 17;
const UINT LOAD_REPLACE = 1 << 18;
const UINT LOAD_INITIAL_DOCUMENT_URI = 1 << 19;
const UINT LOAD_TARGETED = 1 << 20;
const UINT LOAD_CALL_CONTENT_SNIFFERS = 1 << 21;
const UINT LOAD_CLASSIFY_URI = 1 << 22;
2014-11-03 12:39:59 +01:00
const UINT LOAD_MEDIA_SNIFFER_OVERRIDES_CONTENT_TYPE = 1 << 23;
2013-04-04 16:15:16 +02:00
const UINT LOAD_EXPLICIT_CREDENTIALS = 1 << 24;
const UINT LOAD_BYPASS_SERVICE_WORKER = 1 << 25;
2013-04-04 16:15:16 +02:00
2006-02-09 12:19:13 +01:00
nsresult GetOriginalURI(nsIURI **aOriginalURI);
nsresult SetOriginalURI(nsIURI *aOriginalURI);
nsresult GetURI(nsIURI **aURI);
nsresult GetOwner(nsISupports **aOwner);
nsresult SetOwner(nsISupports *aOwner);
nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
nsresult GetSecurityInfo(nsISupports **aSecurityInfo);
nsresult GetContentType(nsACString *aContentType);
nsresult SetContentType(const nsACString *aContentType);
nsresult GetContentCharset(nsACString *aContentCharset);
nsresult SetContentCharset(const nsACString *aContentCharset);
2013-05-17 12:34:34 +02:00
nsresult GetContentLength(int64_t *aContentLength);
nsresult SetContentLength(int64_t aContentLength);
2006-02-09 12:19:13 +01:00
nsresult Open(nsIInputStream **_retval);
nsresult Open2(nsIInputStream **_retval);
2006-02-09 12:19:13 +01:00
nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext);
nsresult AsyncOpen2(nsIStreamListener *aListener);
nsresult GetContentDisposition(uint32_t *aContentDisposition);
2013-01-09 14:21:18 +01:00
nsresult SetContentDisposition(uint32_t aContentDisposition);
2012-03-14 14:45:32 +01:00
nsresult GetContentDispositionFilename(nsAString *aContentDispositionFilename);
2013-01-09 14:21:18 +01:00
nsresult SetContentDispositionFilename(const nsAString *aContentDispositionFilename);
2012-03-14 14:45:32 +01:00
nsresult GetContentDispositionHeader(nsACString *aContentDispositionHeader);
2014-11-03 12:39:59 +01:00
nsresult GetLoadInfo(nsILoadInfo **aLoadInfo);
nsresult SetLoadInfo(nsILoadInfo *aLoadInfo);
2006-02-09 12:19:13 +01:00
}
[
object,
2011-11-09 18:11:42 +01:00
uuid(35412859-b9d9-423c-8866-2d4559fdd2be),
local
]
interface nsIHttpHeaderVisitor : nsISupports
{
nsresult VisitHeader(const nsACString *aHeader, const nsACString *aValue);
}
2006-02-09 12:19:13 +01:00
[
object,
uuid(b2596105-3d0d-4e6a-824f-0539713bb879),
local
2006-02-09 12:19:13 +01:00
]
interface nsIHttpChannel : nsIChannel
{
nsresult GetRequestMethod(nsACString *aRequestMethod);
nsresult SetRequestMethod(const nsACString *aRequestMethod);
nsresult GetReferrer(nsIURI **aReferrer);
nsresult SetReferrer(nsIURI *aReferrer);
2015-02-24 14:19:41 +01:00
nsresult GetReferrerPolicy(uint32_t *aReferrerPolicy);
nsresult SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy);
nsresult GetProtocolVersion(nsACString *aProtocolVersion);
nsresult GetTransferSize(uint64_t *aTransferSize);
nsresult GetDecodedBodySize(uint64_t *aDecodedBodySize);
nsresult GetEncodedBodySize(uint64_t *aEncodedBodySize);
2006-02-09 12:19:13 +01:00
nsresult GetRequestHeader(const nsACString *aHeader, nsACString *_retval);
nsresult SetRequestHeader(const nsACString *aHeader, const nsACString *aValue, bool aMerge);
nsresult SetEmptyRequestHeader(const nsACString *aHeader);
2006-02-09 12:19:13 +01:00
nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
nsresult VisitNonDefaultRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
nsresult GetAllowPipelining(bool *aAllowPipelining);
nsresult SetAllowPipelining(bool aAllowPipelining);
2014-11-03 12:39:59 +01:00
nsresult GetAllowSTS(bool *aAllowSTS);
nsresult SetAllowSTS(bool aAllowSTS);
nsresult GetRedirectionLimit(uint32_t *aRedirectionLimit);
nsresult SetRedirectionLimit(uint32_t aRedirectionLimit);
nsresult GetResponseStatus(uint32_t *aResponseStatus);
2006-02-09 12:19:13 +01:00
nsresult GetResponseStatusText(nsACString *aResponseStatusText);
nsresult GetRequestSucceeded(bool *aRequestSucceeded);
nsresult GetIsMainDocumentChannel(bool *aIsMainDocumentChannel);
nsresult SetIsMainDocumentChannel(bool aIsMainDocumentChannel);
2006-02-09 12:19:13 +01:00
nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
nsresult SetResponseHeader(const nsACString *header, const nsACString *value, bool merge);
2006-02-09 12:19:13 +01:00
nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor);
nsresult IsNoStoreResponse(bool *_retval);
nsresult IsNoCacheResponse(bool *_retval);
2015-08-11 15:11:35 +02:00
nsresult IsPrivateResponse(bool *_retval);
nsresult RedirectTo(nsIURI *aTargetURI);
nsresult GetSchedulingContextID(nsID *aSchedulingContextID);
nsresult SetSchedulingContextID(const nsID aSchedulingContextID);
2006-02-09 12:19:13 +01:00
}
[
object,
uuid(4e28263d-1e03-46f4-aa5c-9512f91957f9),
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 TakeAllSecurityMessages(void /*nsCOMArray<nsISecurityConsoleMessage>*/ *aMessages);
nsresult SetCookie(const char *aCookieHeader);
nsresult SetupFallbackChannel(const char *aFallbackKey);
nsresult GetThirdPartyFlags(uint32_t *aThirdPartyFlags);
nsresult SetThirdPartyFlags(uint32_t aThirdPartyFlags);
nsresult GetForceAllowThirdPartyCookie(bool *aForceAllowThirdPartyCookie);
nsresult SetForceAllowThirdPartyCookie(bool aForceAllowThirdPartyCookie);
nsresult GetCanceled(bool *aCanceled);
nsresult GetChannelIsForDownload(bool *aChannelIsForDownload);
nsresult SetChannelIsForDownload(bool aChannelIsForDownload);
2011-08-23 14:07:02 +02:00
nsresult GetLocalAddress(nsACString *aLocalAddress);
nsresult GetLocalPort(int32_t *aLocalPort);
2011-08-23 14:07:02 +02:00
nsresult GetRemoteAddress(nsACString *aRemoteAddress);
nsresult GetRemotePort(int32_t *aRemotePort);
2011-08-23 14:07:02 +02:00
nsresult SetCacheKeysRedirectChain(void /*nsTArray<nsCString>*/ *cacheKeys);
nsresult HTTPUpgrade(const nsACString *aProtocolName, nsIHttpUpgradeListener *aListener);
nsresult GetAllowSpdy(bool *aAllowSpdy);
nsresult SetAllowSpdy(bool aAllowSpdy);
2014-11-03 12:39:59 +01:00
nsresult GetResponseTimeoutEnabled(bool *aResponseTimeoutEnabled);
nsresult SetResponseTimeoutEnabled(bool aResponseTimeoutEnabled);
nsresult GetInitialRwin(uint32_t *aInitialRwin) ;
nsresult SetInitialRwin(uint32_t aInitialRwin);
2015-02-24 14:19:41 +01:00
nsresult GetApiRedirectToURI(nsIURI **aApiRedirectToURI);
2015-08-11 15:11:35 +02:00
nsresult GetAllowAltSvc(bool *aAllowAltSvc);
nsresult SetAllowAltSvc(bool aAllowAltSvc);
2014-11-03 12:39:59 +01:00
nsresult GetLastModifiedTime(PRTime *aLastModifiedTime);
nsresult ForceIntercepted(uint64_t aInterceptionID);
nsresult GetResponseSynthesized(bool *aResponseSynthesized);
2015-08-11 15:11:35 +02:00
nsresult GetCorsIncludeCredentials(bool *aCorsIncludeCredentials);
nsresult SetCorsIncludeCredentials(bool aCorsIncludeCredentials);
nsresult GetCorsMode(uint32_t *aCorsMode);
nsresult SetCorsMode(uint32_t aCorsMode);
nsresult GetRedirectMode(uint32_t *aRedirectMode);
nsresult SetRedirectMode(uint32_t aRedirectMode);
2015-02-24 14:19:41 +01:00
nsresult GetTopWindowURI(nsIURI **aTopWindowURI);
2015-08-11 15:11:35 +02:00
nsresult GetNetworkInterfaceId(nsACString *aNetworkInterfaceId);
nsresult SetNetworkInterfaceId(const nsACString *aNetworkInterfaceId);
nsresult GetProxyURI(nsIURI **aProxyURI);
nsresult SetCorsPreflightParameters(const void /*nsTArray<nsCString>*/ *unsafeHeaders);
nsresult GetBlockAuthPrompt(bool *aBlockAuthPrompt) ;
nsresult SetBlockAuthPrompt(bool aBlockAuthPrompt);
}
[
object,
2013-01-09 14:21:18 +01:00
uuid(5cfe15bd-5adb-4a7f-9e55-4f5a67d15794),
local
]
interface nsIUploadChannel : nsISupports
{
nsresult SetUploadStream(nsIInputStream *aStream, const nsACString *aContentType,
2013-01-09 14:21:18 +01:00
int64_t aContentLength);
nsresult GetUploadStream(nsIInputStream **aUploadStream);
}
[
object,
uuid(8d171460-a716-41f1-92be-8c659db39b45),
local
]
interface nsIAsyncVerifyRedirectCallback : nsISupports
{
nsresult OnRedirectVerifyCallback(nsresult result);
}
[
object,
2015-08-11 15:11:35 +02:00
uuid(0197720d-37ed-4e75-8956-d0d296e4d8a6),
local
]
interface nsIChannelEventSink : nsISupports
{
const UINT REDIRECT_TEMPORARY = 1;
const UINT REDIRECT_PERMANENT = 2;
const UINT REDIRECT_INTERNAL = 4;
2015-08-11 15:11:35 +02:00
const UINT REDIRECT_STS_UPGRADE = 8;
nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, uint32_t flags,
nsIAsyncVerifyRedirectCallback *callback);
}
[
object,
2013-05-17 12:34:34 +02:00
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);
2013-05-17 12:34:34 +02:00
nsresult GetOrigin(nsAString *aOrigin);
nsresult Reload(bool forceget);
nsresult Replace(const nsAString *url);
nsresult Assign(const nsAString *url);
nsresult ToString(nsAString *_retval);
2013-05-17 12:34:34 +02:00
nsresult ValueOf(nsIDOMLocation **_retval);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(4d6b3bad-f53c-4585-82f6-62982e27ede8),
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);
2014-11-03 12:39:59 +01:00
int /* thiscall mozilla::css::Rule */ GetCSSRule();
}
[
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,
2014-11-03 12:39:59 +01:00
uuid(0e424250-ac2a-4fe2-bccd-a45824af090e),
local
]
interface nsIDOMStyleSheetList : nsISupports
{
nsresult GetLength(uint32_t *aLength);
nsresult Item(uint32_t index, nsIDOMStyleSheet **_retval);
}
[
object,
2013-05-17 12:34:34 +02:00
uuid(450cf0ba-de90-4f86-85bf-e10cc8b8713f),
local
]
interface nsIDOMNodeList : nsISupports
{
nsresult Item(uint32_t index, nsIDOMNode **_retval);
nsresult GetLength(uint32_t *aLength);
2013-05-17 12:34:34 +02:00
}
[
object,
uuid(bb07f567-5b37-4172-92aa-7d00ceed4809),
local
]
interface nsIDOMHTMLCollection : nsISupports
{
nsresult GetLength(uint32_t *aLength);
nsresult Item(uint32_t index, nsIDOMNode **_retval);
nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
}
[
object,
2013-09-25 14:17:08 +02:00
uuid(cb5564cd-26ec-418f-a6d6-1d57cd2c971c),
local
]
2013-09-25 14:17:08 +02:00
interface nsIDOMMozNamedAttrMap : nsISupports
{
2013-09-25 14:17:08 +02:00
nsresult GetNamedItem(const nsAString *name, nsIDOMAttr **_retval);
nsresult SetNamedItem(nsIDOMAttr *arg, nsIDOMAttr **_retval);
nsresult RemoveNamedItem(const nsAString *name, nsIDOMAttr **_retval);
nsresult Item(uint32_t index, nsIDOMAttr **_retval);
nsresult GetLength(uint32_t *aLength);
2013-09-25 14:17:08 +02:00
nsresult GetNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
nsresult SetNamedItemNS(nsIDOMAttr *arg, nsIDOMAttr **_retval);
nsresult RemoveNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(cc35b412-009b-46a3-9be0-76448f12548d),
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
};
2011-11-09 18:11:42 +01:00
enum {
DOCUMENT_POSITION_DISCONNECTED = 1,
DOCUMENT_POSITION_PRECEDING = 2,
DOCUMENT_POSITION_FOLLOWING = 4,
DOCUMENT_POSITION_CONTAINS = 8,
DOCUMENT_POSITION_CONTAINED_BY = 16,
DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32
};
nsresult GetNodeName(nsAString *aNodeName);
nsresult GetNodeValue(nsAString *aNodeValue);
nsresult SetNodeValue(const nsAString *aNodeValue);
nsresult GetNodeType(uint16_t *aNodeType);
nsresult GetParentNode(nsIDOMNode **aParentNode);
2012-03-14 14:45:32 +01:00
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);
2015-02-24 14:19:41 +01:00
nsresult UnusedPlaceholder(bool *_retval);
2011-11-09 18:11:42 +01:00
nsresult GetDOMBaseURI(nsAString *aBaseURI);
nsresult CompareDocumentPosition(nsIDOMNode *other, uint16_t *_retval);
2011-11-09 18:11:42 +01:00
nsresult GetTextContent(nsAString *aTextContent);
nsresult SetTextContent(const nsAString *aTextContent);
nsresult LookupPrefix(const nsAString *namespaceURI, nsAString *_retval);
nsresult IsDefaultNamespace(const nsAString *namespaceURI, bool *_retval);
2011-11-09 18:11:42 +01:00
nsresult LookupNamespaceURI(const nsAString *prefix, nsAString *_retval);
nsresult IsEqualNode(nsIDOMNode *arg, bool *_retval);
2015-02-24 14:19:41 +01:00
nsresult SetUserData(const nsAString *key, nsIVariant *data, nsIVariant **_retval);
2011-11-09 18:11:42 +01:00
nsresult GetUserData(const nsAString *key, nsIVariant **_retval);
nsresult Contains(nsIDOMNode *aOther, bool *_retval);
2012-07-18 12:50:04 +02:00
nsresult GetMshtmlNode(nsISupports **aMshtmlNode);
nsresult SetMshtmlNode(nsISupports *aMshtmlNode);
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(7db491e8-a3a3-4432-ad67-e6c33e24ac6d),
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);
}
2008-12-30 06:48:59 +01:00
[
object,
2015-02-24 14:19:41 +01:00
uuid(6289999b-1008-4269-b42a-413ec5a9d3f4),
2008-12-30 06:48:59 +01:00
local
]
2012-03-14 14:45:32 +01:00
interface nsIDOMElement : nsIDOMNode
2008-12-30 06:48:59 +01:00
{
2012-03-14 14:45:32 +01:00
nsresult GetTagName(nsAString *aTagName);
2014-11-03 12:39:59 +01:00
nsresult GetId(nsAString *aId);
nsresult SetId(const nsAString *aId);
nsresult GetClassName(nsAString *aClassName);
nsresult SetClassName(const nsAString *aClassName) ;
2013-05-17 12:34:34 +02:00
nsresult GetClassList(nsISupports **aClassList);
2013-09-25 14:17:08 +02:00
nsresult GetAttributes(nsIDOMMozNamedAttrMap **aAttributes);
2012-03-14 14:45:32 +01:00
nsresult GetAttribute(const nsAString *name, nsAString *_retval);
nsresult GetAttributeNS(const nsAString *namespaceURI, const nsAString *localName, nsAString *_retval);
nsresult SetAttribute(const nsAString *name, const nsAString *value);
nsresult SetAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName, const nsAString *value);
nsresult RemoveAttribute(const nsAString *name);
nsresult RemoveAttributeNS(const nsAString *namespaceURI, const nsAString *localName);
nsresult HasAttribute(const nsAString *name, bool *_retval);
nsresult HasAttributeNS(const nsAString *namespaceURI, const nsAString *localName, bool *_retval);
2015-02-24 14:19:41 +01:00
nsresult HasAttributes(bool *_retval);
2012-03-14 14:45:32 +01:00
nsresult GetAttributeNode(const nsAString *name, nsIDOMAttr **_retval);
nsresult SetAttributeNode(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
nsresult RemoveAttributeNode(nsIDOMAttr *oldAttr, nsIDOMAttr **_retval);
nsresult GetAttributeNodeNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
nsresult SetAttributeNodeNS(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
2013-05-17 12:34:34 +02:00
nsresult GetElementsByTagName(const nsAString *name, nsIDOMHTMLCollection **_retval);
nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMHTMLCollection **_retval);
nsresult GetElementsByClassName(const nsAString *classes, nsIDOMHTMLCollection **_retval);
2012-03-14 14:45:32 +01:00
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);
2013-09-25 14:17:08 +02:00
nsresult Remove();
2008-12-30 06:48:59 +01:00
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);
2012-03-14 14:45:32 +01:00
nsresult MozMatchesSelector(const nsAString *selector, bool *_retval);
nsresult SetCapture(bool retargetToElement);
2010-08-25 14:22:25 +02:00
nsresult ReleaseCapture();
2012-07-18 12:50:04 +02:00
nsresult MozRequestFullScreen();
nsresult MozRequestPointerLock();
2014-11-03 12:39:59 +01:00
nsresult QuerySelector(const nsAString *selectors, nsIDOMElement **_retval);
nsresult QuerySelectorAll(const nsAString *selectors, nsIDOMNodeList **_retval);
2012-03-14 14:45:32 +01:00
}
[
object,
uuid(99715845-95fc-4a56-aa53-214b65c26e22),
local
]
interface nsIDOMElementCSSInlineStyle : nsISupports
{
nsresult GetStyle(nsIDOMCSSStyleDeclaration **aStyle);
2008-12-30 06:48:59 +01:00
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(b0c42392-d0e7-4f6a-beb5-a698ce648945),
local
]
interface nsIDOMHTMLElement : nsIDOMElement
{
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);
2013-05-17 12:34:34 +02:00
nsresult GetDataset(nsISupports **aDataset);
2012-10-09 11:26:18 +02:00
nsresult GetItemScope(bool *aItemScope);
nsresult SetItemScope(bool aItemScope);
nsresult GetItemType(nsIVariant **aItemType);
nsresult SetItemType(nsIVariant *aItemType);
nsresult GetItemId(nsAString *aItemId);
nsresult SetItemId(const nsAString *aItemId);
2013-05-17 12:34:34 +02:00
nsresult GetProperties(nsISupports **aProperties);
2012-10-09 11:26:18 +02:00
nsresult GetItemValue(nsIVariant **aItemValue);
nsresult SetItemValue(nsIVariant *aItemValue);
nsresult GetItemProp(nsIVariant **aItemProp);
nsresult SetItemProp(nsIVariant *aItemProp);
nsresult GetItemRef(nsIVariant **aItemRef);
nsresult SetItemRef(nsIVariant *aItemRef);
nsresult GetHidden(bool *aHidden);
nsresult SetHidden(bool aHidden);
2012-03-14 14:45:32 +01:00
nsresult Click();
nsresult GetTabIndex(int32_t *aTabIndex);
nsresult SetTabIndex(int32_t aTabIndex);
2012-03-14 14:45:32 +01:00
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);
2008-12-30 06:48:59 +01:00
nsresult GetContentEditable(nsAString *aContentEditable);
nsresult SetContentEditable(const nsAString *aContentEditable);
nsresult GetIsContentEditable(bool *aIsContentEditable);
2011-11-09 18:11:42 +01:00
nsresult GetContextMenu(nsIDOMHTMLMenuElement **aContextMenu);
nsresult GetSpellcheck(bool *aSpellcheck);
nsresult SetSpellcheck(bool aSpellcheck);
2012-03-14 14:45:32 +01:00
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);
2012-03-14 14:45:32 +01:00
nsresult GetOffsetParent(nsIDOMElement * *aOffsetParent);
nsresult GetOffsetTop(int32_t *aOffsetTop);
nsresult GetOffsetLeft(int32_t *aOffsetLeft);
nsresult GetOffsetWidth(int32_t *aOffsetWidth);
nsresult GetOffsetHeight(int32_t *aOffsetHeight);
}
2012-10-09 11:26:18 +02:00
[
object,
2014-11-03 12:39:59 +01:00
uuid(59b80014-00f5-412d-846f-725494122d42),
2012-10-09 11:26:18 +02:00
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLHeadElement : nsISupports
2012-10-09 11:26:18 +02:00
{
}
[
object,
uuid(2a3f789e-0667-464f-a8d7-6f58513443d9),
local
]
interface nsIDOMHTMLMetaElement : nsISupports
{
nsresult GetContent(nsAString *aContent);
nsresult SetContent(const nsAString *aContent);
nsresult GetHttpEquiv(nsAString *aHttpEquiv);
nsresult SetHttpEquiv(const nsAString *aHttpEquiv);
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
nsresult GetScheme(nsAString *aScheme);
nsresult SetScheme(const nsAString *aScheme);
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(4109a2d2-e7af-445d-bb72-c7c9b875f35e),
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);
2013-09-25 14:17:08 +02:00
nsresult Remove();
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(67273994-6aff-4091-9de9-b788a249f783),
local
]
interface nsIDOMText : nsIDOMCharacterData
{
nsresult SplitText(uint32_t offset, nsIDOMText **_retval);
2011-11-09 18:11:42 +01:00
nsresult GetWholeText(nsAString *aWholeText);
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(e7866ff8-b7fc-494f-87c0-fb017d8a4d30),
local
]
interface nsIDOMComment : nsIDOMCharacterData
{
}
[
object,
uuid(cd7467b9-0f26-4787-a359-66e80ba8db92),
local
]
interface nsIDOMDocumentType : nsIDOMNode
{
nsresult GetName(nsAString *aName);
nsresult GetPublicId(nsAString *aPublicId);
nsresult GetSystemId(nsAString *aSystemId);
nsresult GetInternalSubset(nsAString *aInternalSubset);
nsresult MozRemove();
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(48eb8d72-95bb-402e-a8fc-f2b187abcbdb),
local
]
interface nsIDOMDocumentFragment : nsIDOMNode
{
2014-11-03 12:39:59 +01:00
nsresult QuerySelector(const nsAString *selectors, nsIDOMElement **_retval);
nsresult QuerySelectorAll(const nsAString *selectors, nsIDOMNodeList **_retval);
}
[
object,
uuid(b15fa0f4-97c1-4388-af62-2ceff7a89bdf),
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);
2011-11-09 18:11:42 +01:00
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);
2011-11-09 18:11:42 +01:00
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);
2011-08-23 14:07:02 +02:00
nsresult GetInputEncoding(nsAString *aInputEncoding);
nsresult GetDocumentURI(nsAString *aDocumentURI);
2013-05-17 12:34:34 +02:00
nsresult GetURL(nsAString *aURL);
2011-08-23 14:07:02 +02:00
nsresult AdoptNode(nsIDOMNode *source, nsIDOMNode **_retval);
nsresult CreateRange(nsIDOMRange **_retval);
nsresult CreateNodeIterator(nsIDOMNode *root, uint32_t whatToShow, nsIDOMNodeFilter *filter, uint8_t _argc,
2012-06-11 15:32:18 +02:00
nsIDOMNodeIterator **_retval);
nsresult CreateTreeWalker(nsIDOMNode *root, uint32_t whatToShow, nsIDOMNodeFilter *filter, uint8_t _argc,
2012-06-11 15:32:18 +02:00
nsIDOMTreeWalker **_retval);
2011-08-23 14:07:02 +02:00
cpp_quote("#undef CreateEvent")
nsresult CreateEvent(const nsAString *eventType, nsIDOMEvent **_retval);
nsresult GetDefaultView(mozIDOMWindowProxy **aDefaultView);
2008-12-30 06:48:59 +01:00
nsresult GetCharacterSet(nsAString *aCharacterSet);
nsresult GetDir(nsAString *aDir);
nsresult SetDir(const nsAString *aDir);
nsresult GetLocation(nsIDOMLocation **aLocation);
nsresult GetTitle(nsAString *aTitle);
nsresult SetTitle(const nsAString *aTitle);
2009-08-04 14:05:05 +02:00
nsresult GetReadyState(nsAString *aReadyState);
2008-12-30 06:48:59 +01:00
nsresult GetLastModified(nsAString *aLastModified);
nsresult GetReferrer(nsAString *aReferrer);
nsresult HasFocus(bool *_retval);
2008-12-30 06:48:59 +01:00
nsresult GetActiveElement(nsIDOMElement **aActiveElement);
nsresult GetElementsByClassName(const nsAString *classes, nsIDOMNodeList **_retval);
2011-11-09 18:11:42 +01:00
nsresult GetStyleSheets(nsIDOMStyleSheetList **aStyleSheets);
nsresult GetPreferredStyleSheetSet(nsAString *aPreferredStyleSheetSet);
nsresult GetSelectedStyleSheetSet(nsAString *aSelectedStyleSheetSet);
nsresult SetSelectedStyleSheetSet(const nsAString *aSelectedStyleSheetSet);
nsresult GetLastStyleSheetSet(nsAString *aLastStyleSheetSet);
2014-11-03 12:39:59 +01:00
nsresult GetStyleSheetSets(nsISupports **aStyleSheetSets);
2011-11-09 18:11:42 +01:00
nsresult EnableStyleSheetsForSet(const nsAString *name);
2010-08-25 14:22:25 +02:00
nsresult ElementFromPoint(float x, float y, nsIDOMElement **_retval);
2011-11-09 18:11:42 +01:00
nsresult GetContentType(nsAString *aContentType);
nsresult GetMozSyntheticDocument(bool *aMozSyntheticDocument);
2011-11-09 18:11:42 +01:00
nsresult GetCurrentScript(nsIDOMElement **aCurrentScript);
2010-08-25 14:22:25 +02:00
nsresult ReleaseCapture();
nsresult MozSetImageElement(const nsAString *aImageElementId, nsIDOMElement *aImageElement);
2012-07-18 12:50:04 +02:00
nsresult GetMozFullScreenElement(nsIDOMElement **aMozFullScreenElement);
2012-03-14 14:45:32 +01:00
nsresult MozCancelFullScreen();
nsresult GetMozFullScreen(bool *aMozFullScreen);
nsresult GetMozFullScreenEnabled(bool *aMozFullScreenEnabled);
2012-07-18 12:50:04 +02:00
nsresult GetMozPointerLockElement(nsIDOMElement **aMozPointerLockElement);
2013-05-17 12:34:34 +02:00
nsresult CaretPositionFromPoint(float x, float y, nsISupports **_retval);
2012-07-18 12:50:04 +02:00
nsresult MozExitPointerLock();
2013-01-09 14:21:18 +01:00
nsresult GetHidden(bool *aHidden);
nsresult GetMozHidden(bool *aMozHidden);
2013-01-09 14:21:18 +01:00
nsresult GetVisibilityState(nsAString *aVisibilityState);
2012-03-14 14:45:32 +01:00
nsresult GetMozVisibilityState(nsAString *aMozVisibilityState);
2013-05-17 12:34:34 +02:00
nsresult GetCompatMode(nsAString *aCompatMode);
2014-11-03 12:39:59 +01:00
nsresult QuerySelector(const nsAString *selectors, nsIDOMElement **_retval);
nsresult QuerySelectorAll(const nsAString *selectors, nsIDOMNodeList **_retval);
2008-12-30 06:48:59 +01:00
}
2006-04-28 19:58:38 +02:00
[
object,
uuid(cd31e61f-cfc2-4b91-9385-17b6a2d0633d),
local
2006-04-28 19:58:38 +02:00
]
interface nsIDOMHTMLDocument : nsIDOMDocument
{
2011-11-09 18:11:42 +01:00
nsresult GetDomain(nsAString *aDomain);
nsresult SetDomain(const nsAString *aDomain);
nsresult GetCookie(nsAString *aCookie);
nsresult SetCookie(const nsAString *aCookie);
nsresult GetHead(nsIDOMHTMLHeadElement **aHead);
2006-04-28 19:58:38 +02:00
nsresult GetBody(nsIDOMHTMLElement **aBody);
nsresult SetBody(nsIDOMHTMLElement *aBody);
nsresult GetImages(nsIDOMHTMLCollection **aImages);
2011-11-09 18:11:42 +01:00
nsresult GetEmbeds(nsIDOMHTMLCollection **aEmbeds);
nsresult GetPlugins(nsIDOMHTMLCollection **aPlugins);
2006-04-28 19:58:38 +02:00
nsresult GetLinks(nsIDOMHTMLCollection **aLinks);
nsresult GetForms(nsIDOMHTMLCollection **aForms);
2012-03-14 14:45:32 +01:00
nsresult GetScripts(nsIDOMHTMLCollection **aScripts);
2006-04-28 19:58:38 +02:00
nsresult GetElementsByName(const nsAString *elementName, nsIDOMNodeList **_retval);
2012-10-09 11:26:18 +02:00
nsresult GetItems(const nsAString *types, nsIDOMNodeList **_retval);
2011-11-09 18:11:42 +01:00
nsresult Open(const nsAString *aContentTypeOrUrl, const nsAString *aReplaceOrName, const nsAString *aFeatures,
JSContext *cx, uint8_t _argc, nsISupports **_retval);
2011-11-09 18:11:42 +01:00
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);
2011-11-09 18:11:42 +01:00
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);
2014-11-03 12:39:59 +01:00
nsresult CaptureEvents();
nsresult ReleaseEvents();
}
[
object,
2013-01-09 14:21:18 +01:00
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);
2013-01-09 14:21:18 +01:00
nsresult IntersectsNode(nsIDOMNode *node, bool *_retval);
2010-08-25 14:22:25 +02:00
nsresult GetClientRects(nsIDOMClientRectList **_retval);
nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(e0a4d4b3-f34e-44bd-b1f2-4e3bde9b6915),
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);
2012-10-09 11:26:18 +02:00
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();
2012-10-09 11:26:18 +02:00
nsresult ToString(nsAString *_retval);
2011-11-09 18:11:42 +01:00
nsresult Modify(const nsAString *alter, const nsAString *direction, const nsAString *granularity);
}
[
object,
uuid(8d64f457-fb8c-49ea-a359-cef30eed9774),
local
]
interface nsIDOMWindowCollection : nsISupports
{
nsresult GetLength(uint32_t *aLength);
nsresult Item(uint32_t index, mozIDOMWindowProxy **_retval);
nsresult NamedItem(const nsAString *name, mozIDOMWindowProxy **_retval);
}
[
object,
uuid(75fbabd6-7a2e-4787-aa33-449a33512135),
local
]
interface mozIDOMWindow : nsISupports
{
}
[
object,
uuid(53ca090c-e739-48b9-8911-208c72f9191e),
local
]
interface mozIDOMWindowProxy : nsISupports
{
}
[
object,
uuid(ab30b7cc-f7f9-4b9b-befb-7dbf6cf86d46),
local
]
interface nsIDOMWindow : nsISupports
{
nsresult GetDocument(nsIDOMDocument **aDocument);
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
2011-11-09 18:11:42 +01:00
nsresult GetLocation(nsIDOMLocation **aLocation);
nsresult Close();
nsresult Stop();
nsresult Focus();
nsresult Blur();
nsresult GetLength(uint32_t *aLength);
2012-10-09 11:26:18 +02:00
nsresult GetRealTop(nsIDOMWindow **aTop);
nsresult GetRealParent(nsIDOMWindow **aParent);
nsresult GetOpener(mozIDOMWindowProxy **aOpenerWindow);
nsresult SetOpener(mozIDOMWindowProxy *aOpenerWindow);
2012-10-09 11:26:18 +02:00
nsresult GetRealFrameElement(nsIDOMElement **aFrameElement);
2011-11-09 18:11:42 +01:00
nsresult GetNavigator(nsIDOMNavigator **aNavigator);
nsresult Print();
2014-11-03 12:39:59 +01:00
nsresult GetSessionStorage(nsISupports **aSessionStorage);
nsresult GetLocalStorage(nsISupports **aLocalStorage);
nsresult GetIndexedDB(nsISupports **aIndexedDB);
2011-11-09 18:11:42 +01:00
nsresult GetSelection(nsISelection **_retval);
2014-11-03 12:39:59 +01:00
nsresult MatchMedia(const nsAString *media_query_list, nsISupports **_retval);
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);
2011-11-09 18:11:42 +01:00
nsresult GetComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
2013-05-17 12:34:34 +02:00
nsresult GetDefaultComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
2011-11-09 18:11:42 +01:00
nsresult GetFrames(nsIDOMWindowCollection **aFrames);
nsresult GetTextZoom(float *aTextZoom);
nsresult SetTextZoom(float aTextZoom);
nsresult ScrollByLines(int32_t numLines);
nsresult ScrollByPages(int32_t numPages);
2011-11-09 18:11:42 +01:00
nsresult GetMozInnerScreenX(float *aMozInnerScreenX);
nsresult GetMozInnerScreenY(float *aMozInnerScreenY);
2013-01-09 14:21:18 +01:00
nsresult GetDevicePixelRatio(float *aDevicePixelRatio);
nsresult GetScrollMaxX(int32_t *aScrollMaxX);
nsresult GetScrollMaxY(int32_t *aScrollMaxY);
nsresult GetFullScreen(bool *aFullScreen);
nsresult SetFullScreen(bool aFullScreen);
2011-11-09 18:11:42 +01:00
nsresult Back();
nsresult Forward();
nsresult Home();
nsresult Open(const nsAString *url, const nsAString *name, const nsAString *options, nsIDOMWindow **_retval);
nsresult Find(const nsAString *str, bool caseSensitive, bool backwards, bool wrapAround, bool wholeWord,
bool searchInFrames, bool showDialog, bool *_retval);
nsresult GetInnerWindow(mozIDOMWindow **aInnerWindow);
nsresult GetOuterWindow(mozIDOMWindowProxy **aOuterWindow);
2012-03-14 14:45:32 +01:00
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(068630db-2c00-43dd-b167-495757a88236),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLBodyElement : nsISupports
{
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);
2012-03-14 14:45:32 +01:00
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(ad9b2ad0-9d29-43f6-b1a2-a1fd24627e6b),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLFormElement : nsISupports
{
nsresult GetAcceptCharset(nsAString *aAcceptCharset);
nsresult SetAcceptCharset(const nsAString *aAcceptCharset);
nsresult GetAction(nsAString *aAction);
nsresult SetAction(const nsAString *aAction);
2011-03-15 13:45:29 +01:00
nsresult GetAutocomplete(nsAString *aAutocomplete);
nsresult SetAutocomplete(const nsAString *aAutocomplete);
nsresult GetEnctype(nsAString *aEnctype);
nsresult SetEnctype(const nsAString *aEnctype);
2011-11-09 18:11:42 +01:00
nsresult GetEncoding(nsAString *aEncoding);
nsresult SetEncoding(const nsAString *aEncoding);
nsresult GetMethod(nsAString *aMethod);
nsresult SetMethod(const nsAString *aMethod);
2011-11-09 18:11:42 +01:00
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);
2011-03-15 13:45:29 +01:00
nsresult GetElements(nsIDOMHTMLCollection **aElements);
nsresult GetLength(int32_t *aLength);
nsresult Submit();
nsresult Reset();
nsresult CheckValidity(bool *_retval);
2013-09-25 14:17:08 +02:00
nsresult GetFormData(nsIDOMHTMLElement *aOriginatingElement, nsAString *aActionURI, nsIInputStream **aPostDataStream);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(64aeda0b-e9b5-4868-a4f9-e4776e32e733),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLInputElement : nsISupports
{
nsresult GetAccept(nsAString *aAccept);
nsresult SetAccept(const nsAString *aAccept);
nsresult GetAlt(nsAString *aAlt);
nsresult SetAlt(const nsAString *aAlt);
2011-03-15 13:45:29 +01:00
nsresult GetAutocomplete(nsAString *aAutocomplete);
nsresult SetAutocomplete(const nsAString *aAutocomplete);
nsresult GetAutofocus(bool *aAutofocus);
nsresult SetAutofocus(bool aAutofocus);
nsresult GetDefaultChecked(bool *aDefaultChecked);
nsresult SetDefaultChecked(bool aDefaultChecked);
nsresult GetChecked(bool *aChecked);
nsresult SetChecked(bool aChecked);
nsresult GetDisabled(bool *aDisabled);
nsresult SetDisabled(bool aDisabled);
2010-08-25 14:22:25 +02:00
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
2011-03-15 13:45:29 +01:00
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);
2011-03-15 13:45:29 +01:00
nsresult GetFormTarget(nsAString *aFormTarget);
nsresult SetFormTarget(const nsAString *aFormTarget);
2010-08-25 14:22:25 +02:00
nsresult GetFiles(nsIDOMFileList **aFiles);
nsresult GetHeight(uint32_t *aHeight);
nsresult SetHeight(uint32_t aHeight);
nsresult GetIndeterminate(bool *aIndeterminate);
nsresult SetIndeterminate(bool aIndeterminate);
2013-09-25 14:17:08 +02:00
nsresult GetInputMode(nsAString *aInputMode);
nsresult SetInputMode(const nsAString *aInputMode);
2011-03-15 13:45:29 +01:00
nsresult GetList(nsIDOMHTMLElement **aList);
2012-10-09 11:26:18 +02:00
nsresult GetMax(nsAString *aMax);
nsresult SetMax(const nsAString *aMax);
nsresult GetMaxLength(int32_t *aMaxLength);
nsresult SetMaxLength(int32_t aMaxLength);
2012-10-09 11:26:18 +02:00
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);
2011-03-15 13:45:29 +01:00
nsresult GetPattern(nsAString *aPattern);
nsresult SetPattern(const nsAString *aPattern);
2010-08-25 14:22:25 +02:00
nsresult GetPlaceholder(nsAString *aPlaceholder);
nsresult SetPlaceholder(const nsAString *aPlaceholder);
nsresult GetReadOnly(bool *aReadOnly);
nsresult SetReadOnly(bool aReadOnly);
nsresult GetRequired(bool *aRequired);
nsresult SetRequired(bool aRequired);
2012-10-09 11:26:18 +02:00
nsresult GetStep(nsAString *aStep);
nsresult SetStep(const nsAString *aStep);
2010-08-25 14:22:25 +02:00
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);
2010-08-25 14:22:25 +02:00
nsresult GetDefaultValue(nsAString *aDefaultValue);
nsresult SetDefaultValue(const nsAString *aDefaultValue);
nsresult GetValue(nsAString *aValue);
nsresult SetValue(const nsAString *aValue);
2012-10-09 11:26:18 +02:00
nsresult GetValueAsNumber(double *aValueAsNumber);
nsresult SetValueAsNumber(double aValueAsNumber);
nsresult StepDown(int32_t n, uint8_t _argc);
nsresult StepUp(int32_t n, uint8_t _argc);
nsresult GetWillValidate(bool *aWillValidate);
2011-03-15 13:45:29 +01:00
nsresult GetValidity(nsIDOMValidityState **aValidity);
nsresult GetValidationMessage(nsAString *aValidationMessage);
nsresult CheckValidity(bool *_retval);
2011-03-15 13:45:29 +01:00
nsresult SetCustomValidity(const nsAString *error);
2010-08-25 14:22:25 +02:00
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);
2011-11-09 18:11:42 +01:00
nsresult GetSelectionDirection(nsAString *aSelectionDirection);
nsresult SetSelectionDirection(const nsAString *aSelectionDirection);
2010-08-25 14:22:25 +02:00
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,
2014-11-03 12:39:59 +01:00
uuid(c2b3e9ff-6b36-4158-ace3-05a9c5b8e1c1),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLOptionElement : nsISupports
{
nsresult GetDisabled(bool *aDisabled);
nsresult SetDisabled(bool aDisabled);
2010-08-25 14:22:25 +02:00
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);
2010-08-25 14:22:25 +02:00
nsresult GetText(nsAString *aText);
nsresult SetText(const nsAString *aText);
nsresult GetIndex(int32_t *aIndex);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(44b7a468-7dba-4f0c-9b4e-ee46dc0f26c7),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLButtonElement : nsISupports
{
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,
2013-05-17 12:34:34 +02:00
uuid(4173cc53-30f6-4d12-a770-981ba53164e2),
local
]
interface nsIDOMHTMLOptionsCollection : nsISupports
{
2012-03-14 14:45:32 +01:00
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);
2012-03-14 14:45:32 +01:00
nsresult GetSelect(nsIDOMHTMLSelectElement **aSelect);
nsresult Add(nsIDOMHTMLOptionElement *option, nsIVariant *before);
nsresult Remove(int32_t index);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(d8914a2d-3556-4b66-911c-a84c4394e7fa),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLSelectElement : nsISupports
{
nsresult GetAutofocus(bool *aAutofocus);
nsresult SetAutofocus(bool aAutofocus);
nsresult GetDisabled(bool *aDisabled);
nsresult SetDisabled(bool aDisabled);
2010-08-25 14:22:25 +02:00
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);
2010-08-25 14:22:25 +02:00
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);
2010-08-25 14:22:25 +02:00
nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
2011-11-09 18:11:42 +01:00
nsresult Add(nsIDOMHTMLElement *element, nsIVariant *before);
nsresult select_Remove(int32_t index);
2014-11-03 12:39:59 +01:00
nsresult GetSelectedOptions(nsIDOMHTMLCollection **aSelectedOptions);
nsresult GetSelectedIndex(int32_t *aSelectedIndex);
nsresult SetSelectedIndex(int32_t aSelectedIndex);
2010-08-25 14:22:25 +02:00
nsresult GetValue(nsAString *aValue);
nsresult SetValue(const nsAString *aValue);
nsresult GetWillValidate(bool *aWillValidate);
2011-03-15 13:45:29 +01:00
nsresult GetValidity(nsIDOMValidityState **aValidity);
nsresult GetValidationMessage(nsAString *aValidationMessage);
nsresult CheckValidity(bool *_retval);
2011-03-15 13:45:29 +01:00
nsresult SetCustomValidity(const nsAString *error);
nsresult GetRequired(bool *aRequired);
nsresult SetRequired(bool aRequired);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(7a4aeb2e-fcf3-443e-b002-ca1c8ea322e9),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLTextAreaElement : nsISupports
{
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);
2011-11-09 18:11:42 +01:00
nsresult GetForm(nsIDOMHTMLFormElement **aForm);
nsresult GetMaxLength(int32_t *aMaxLength);
nsresult SetMaxLength(int32_t aMaxLength);
nsresult GetName(nsAString *aName);
nsresult SetName(const nsAString *aName);
2011-11-09 18:11:42 +01:00
nsresult GetPlaceholder(nsAString *aPlaceholder);
nsresult SetPlaceholder(const nsAString *aPlaceholder);
nsresult GetReadOnly(bool *aReadOnly);
nsresult SetReadOnly(bool aReadOnly);
nsresult GetRequired(bool *aRequired);
nsresult SetRequired(bool aRequired);
nsresult GetRows(uint32_t *aRows);
nsresult SetRows(uint32_t aRows);
2011-11-09 18:11:42 +01:00
nsresult GetWrap(nsAString *aWrap);
nsresult SetWrap(const nsAString *aWrap);
nsresult GetType(nsAString *aType);
2011-11-09 18:11:42 +01:00
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);
2011-11-09 18:11:42 +01:00
nsresult GetValidity(nsIDOMValidityState **aValidity);
nsresult GetValidationMessage(nsAString *aValidationMessage);
nsresult CheckValidity(bool *_retval);
2011-11-09 18:11:42 +01:00
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);
2011-11-09 18:11:42 +01:00
nsresult GetSelectionDirection(nsAString *aSelectionDirection);
nsresult SetSelectionDirection(const nsAString *aSelectionDirection);
nsresult GetControllers(nsIControllers **aControllers);
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(fe96dc1c-40e4-4974-9354-e3fce663c3d5),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLScriptElement : nsISupports
{
2010-08-25 14:22:25 +02:00
nsresult GetSrc(nsAString *aSrc);
nsresult SetSrc(const nsAString *aSrc);
nsresult GetAsync(bool *aAsync);
nsresult SetAsync(bool aAsync);
nsresult GetDefer(bool *aDefer);
nsresult SetDefer(bool aDefer);
2010-08-25 14:22:25 +02:00
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);
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(ec18e71c-4f5c-4cc3-aa36-5273168644dc),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLImageElement : nsISupports
{
2010-08-25 14:22:25 +02:00
nsresult GetAlt(nsAString *aAlt);
nsresult SetAlt(const nsAString *aAlt);
nsresult GetSrc(nsAString *aSrc);
nsresult SetSrc(const nsAString *aSrc);
2014-11-03 12:39:59 +01:00
nsresult GetSrcset(nsAString *aSrcset);
nsresult SetSrcset(const nsAString *aSrcset) ;
nsresult GetSizes(nsAString *aSizes);
nsresult SetSizes(const nsAString *aSizes);
2010-08-25 14:22:25 +02:00
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);
2010-08-25 14:22:25 +02:00
nsresult GetLowsrc(nsAString *aLowsrc);
nsresult SetLowsrc(const nsAString *aLowsrc);
2014-11-03 12:39:59 +01:00
nsresult GetCurrentSrc(nsAString *aCurrentSrc);
nsresult GetX(int32_t *aX);
nsresult GetY(int32_t *aY);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(339c01c8-2d41-4626-b231-eec63f0241b6),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLAnchorElement : nsISupports
{
2010-08-25 14:22:25 +02:00
nsresult GetHref(nsAString *aHref);
nsresult SetHref(const nsAString *aHref);
nsresult GetTarget(nsAString *aTarget);
nsresult SetTarget(const nsAString *aTarget);
nsresult GetPing(nsAString *aPing);
nsresult SetPing(const nsAString *aPing);
2013-05-17 12:34:34 +02:00
nsresult GetDownload(nsAString *aPing);
nsresult SetDownload(const nsAString *aPing);
2010-08-25 14:22:25 +02:00
nsresult GetRel(nsAString *aRel);
nsresult SetRel(const nsAString *aRel);
nsresult GetHreflang(nsAString *aHreflang);
nsresult SetHreflang(const nsAString *aHreflang);
nsresult GetType(nsAString *aType);
nsresult SetType(const nsAString *aType);
nsresult GetText(nsAString *aText);
nsresult SetText(const nsAString *aText);
nsresult GetProtocol(nsAString *aProtocol);
nsresult SetProtocol(const nsAString *aProtocol);
nsresult GetHost(nsAString *aHost);
nsresult SetHost(const nsAString *aHost);
nsresult GetHostname(nsAString *aHostname);
nsresult SetHostname(const nsAString *aHostname);
nsresult GetPort(nsAString *aPort);
nsresult SetPort(const nsAString *aPort);
nsresult GetPathname(nsAString *aPathname);
nsresult SetPathname(const nsAString *aPathname);
nsresult GetSearch(nsAString *aSearch);
nsresult SetSearch(const nsAString *aSearch);
nsresult GetHash(nsAString *aHash);
nsresult SetHash(const nsAString *aHash);
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);
2010-08-25 14:22:25 +02:00
nsresult ToString(nsAString *_retval);
}
2015-08-04 16:59:39 +02:00
[
object,
uuid(40c78026-36dc-40ca-9221-de73267e9e99),
local
]
interface nsIDOMHTMLAreaElement : nsISupports
{
nsresult GetAlt(const nsAString *aAlt);
nsresult SetAlt(nsAString *aAlt);
nsresult GetCoords(const nsAString *aCoords);
nsresult SetCoords(nsAString *aCoords);
nsresult GetShape(const nsAString *aShape);
nsresult SetShape(nsAString *aShape);
nsresult GetHref(const nsAString *aHref);
nsresult SetHref(nsAString *aHref);
nsresult GetTarget(const nsAString *aTarget);
nsresult SetTarget(nsAString *aTarget);
nsresult GetPing(const nsAString *aPing);
nsresult SetPing(nsAString *aPing);
nsresult GetDownload(const nsAString *aDownload);
nsresult SetDownload(nsAString *aDownload);
nsresult GetProtocol(const nsAString *aProtocol);
nsresult SetProtocol(nsAString *aProtocol);
nsresult GetHost(const nsAString *aHost);
nsresult SetHost(nsAString *aHost);
nsresult GetPort(const nsAString *aPort);
nsresult SetPort(nsAString *aPort);
nsresult GetPathname(const nsAString *aPathname);
nsresult SetPathname(nsAString *aPathname);
nsresult GetSearch(const nsAString *aSearch);
nsresult SetSearch(nsAString *aSearch);
nsresult GetHash(const nsAString *aHash);
nsresult SetHash(nsAString *aHash);
nsresult GetNoHref(const nsAString *aNoHref);
nsresult SetNoHref(nsAString *aNoHref);
nsresult ToString(nsAString *_retval);
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(ee50b7ab-0015-4fbe-89e0-e3feacd4ffde),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLLinkElement : nsISupports
{
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);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(135a30ee-0374-4ee7-9d36-91736bff5fb1),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLTableElement : nsISupports
{
2015-08-11 15:11:35 +02:00
nsresult GetCaption(nsIDOMHTMLElement **aCaption);
nsresult SetCaption(nsIDOMHTMLElement *aCaption);
2014-11-03 12:39:59 +01:00
nsresult GetTHead(nsIDOMHTMLElement **aTHead);
nsresult SetTHead(nsIDOMHTMLElement *aTHead);
nsresult GetTFoot(nsIDOMHTMLElement **aTFoot);
nsresult SetTFoot(nsIDOMHTMLElement *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);
2014-11-03 12:39:59 +01:00
nsresult xpidlDeleteTHead();
nsresult CreateTFoot(nsIDOMHTMLElement **_retval);
2014-11-03 12:39:59 +01:00
nsresult xpidlDeleteTFoot();
nsresult CreateCaption(nsIDOMHTMLElement **_retval);
2014-11-03 12:39:59 +01:00
nsresult xpidlDeleteCaption();
nsresult InsertRow(int32_t index, nsIDOMHTMLElement **_retval);
nsresult DeleteRow(int32_t index);
}
[
object,
2013-09-25 14:17:08 +02:00
uuid(02094366-0d3d-47e3-949c-89113a9bcc15),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLTableRowElement : nsISupports
{
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);
2014-11-03 12:39:59 +01:00
nsresult InsertCell(int32_t index, nsIDOMHTMLElement * *_retval);
nsresult DeleteCell(int32_t index);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(3203c36f-33fd-4628-8c88-77e82d38df1e),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLTableCellElement : nsISupports
{
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,
2014-11-03 12:39:59 +01:00
uuid(9fd7b656-1055-4cb2-b8b1-ed13efe24457),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLIFrameElement : nsISupports
{
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);
2014-11-03 12:39:59 +01:00
nsresult GetSrcdoc(nsAString *aSrcdoc);
nsresult SetSrcdoc(const nsAString *aSrcdoc);
nsresult GetWidth(nsAString *aWidth);
nsresult SetWidth(const nsAString *aWidth);
nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
2013-09-25 14:17:08 +02:00
nsresult GetAllowFullscreen(bool *aAllowFullscreen);
nsresult SetAllowFullscreen(bool aAllowFullscreen);
}
2009-10-27 21:17:08 +01:00
[
object,
uuid(012a8982-c9d3-4614-91e2-18ee51c97c06),
2009-10-27 21:17:08 +01:00
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLFrameElement : nsISupports
2009-10-27 21:17:08 +01:00
{
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);
2009-10-27 21:17:08 +01:00
nsresult GetScrolling(nsAString *aScrolling);
nsresult SetScrolling(const nsAString *aScrolling);
nsresult GetSrc(nsAString *aSrc);
nsresult SetSrc(const nsAString *aSrc);
nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(baf443d2-da5d-40c9-be3c-c65a69a25250),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLObjectElement : nsISupports
{
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);
2011-03-15 13:45:29 +01:00
nsresult GetValidity(nsIDOMValidityState **aValidity);
nsresult GetValidationMessage(nsAString *aValidationMessage);
nsresult CheckValidity(bool *_retval);
2011-03-15 13:45:29 +01:00
nsresult SetCustomValidity(const nsAString *error);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(fa326d22-8739-4eef-a80e-6449bde605d2),
local
]
2014-11-03 12:39:59 +01:00
interface nsIDOMHTMLStyleElement : nsISupports
{
nsresult GetDisabled(bool *aDisabled);
nsresult SetDisabled(bool aDisabled);
nsresult GetMedia(nsAString *aMedia);
nsresult SetMedia(const nsAString *aMedia);
nsresult GetType(nsAString *aType);
nsresult SetType(const nsAString *aType);
2013-05-17 12:34:34 +02:00
nsresult GetScoped(bool *aScoped);
nsresult SetScoped(bool aScoped);
2012-10-09 11:26:18 +02:00
nsresult GetDOMStyleSheet(nsIDOMStyleSheet **aDOMStyleSheet);
}
[
object,
2015-08-11 15:11:35 +02:00
uuid(10a28f38-32e8-4c63-8aa1-12eaaebc369a),
local
]
interface nsIURIContentListener : nsISupports
{
nsresult OnStartURIOpen(nsIURI *aURI, bool *_retval);
2015-08-11 15:11:35 +02:00
nsresult DoContent(const nsACString *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);
}
2006-03-27 21:02:28 +02:00
[
object,
uuid(44b78386-1dd2-11b2-9ad2-e4eee2ca1916),
local
2006-03-27 21:02:28 +02:00
]
interface nsITooltipListener : nsISupports
{
nsresult OnShowTooltip(int32_t aXCoords, int32_t aYCoords, const PRUnichar *aTipText);
2006-03-27 21:02:28 +02:00
nsresult OnHideTooltip();
}
[
object,
uuid(4052b6da-4faa-4646-b3a1-7e16a01c2dc2),
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(mozIDOMWindowProxy **aContentDOMWindow);
nsresult GetIsActive(bool *aIsActive);
nsresult SetIsActive(bool aIsActive);
}
cpp_quote("#define SETUP_ALLOW_JAVASCRIPT 2")
cpp_quote("#define SETUP_IS_CHROME_WRAPPER 7")
2012-10-09 11:26:18 +02:00
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(ca635529-a977-4552-9b8a-66187e54d882),
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 SetPositionDesktopPix(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);
2011-08-23 14:07:02 +02:00
nsresult GetParentWidget(nsIWidget **aParentWidget);
nsresult SetParentWidget(nsIWidget *aParentWidget);
nsresult GetParentNativeWindow(nativeWindow *aParentNativeWindow);
nsresult SetParentNativeWindow(nativeWindow aParentNativeWindow);
2013-01-09 14:21:18 +01:00
nsresult GetNativeHandle(nsAString *aNativeHandle);
nsresult GetVisibility(bool *aVisibility);
nsresult SetVisibility(bool aVisibility);
nsresult GetEnabled(bool *aEnabled);
nsresult SetEnabled(bool aEnabled);
nsresult GetMainWidget(nsIWidget **aMainWidget);
2013-01-09 14:21:18 +01:00
nsresult GetUnscaledDevicePixelsPerCSSPixel(double *aUnscaledDevicePixelsPerCSSPixel);
nsresult GetDevicePixelsPerDesktopPixel(double *aDevicePixelsPerDesktopPixel);
nsresult SetFocus();
nsresult GetTitle(PRUnichar **aTitle);
nsresult SetTitle(const PRUnichar *aTitle);
}
[
object,
uuid(3ade79d4-8cb9-4952-b18d-4f9b63ca0d31),
local
]
interface nsIWebNavigation : nsISupports
{
2013-04-04 16:15:16 +02:00
const UINT LOAD_FLAGS_MASK = 0xffff;
const UINT LOAD_FLAGS_NONE = 0;
const UINT LOAD_FLAGS_IS_REFRESH = 0x0010;
const UINT LOAD_FLAGS_IS_LINK = 0x0020;
const UINT LOAD_FLAGS_BYPASS_HISTORY = 0x0040;
const UINT LOAD_FLAGS_REPLACE_HISTORY = 0x0080;
const UINT LOAD_FLAGS_BYPASS_CACHE = 0x0100;
const UINT LOAD_FLAGS_BYPASS_PROXY = 0x0200;
const UINT LOAD_FLAGS_CHARSET_CHANGE = 0x0400;
const UINT LOAD_FLAGS_STOP_CONTENT = 0x0800;
const UINT LOAD_FLAGS_FROM_EXTERNAL = 0x1000;
const UINT LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP = 0x2000;
const UINT LOAD_FLAGS_FIRST_LOAD = 0x4000;
const UINT LOAD_FLAGS_ALLOW_POPUPS = 0x8000;
const UINT LOAD_FLAGS_BYPASS_CLASSIFIER = 0x10000;
const UINT LOAD_FLAGS_FORCE_ALLOW_COOKIES = 0x20000;
const UINT LOAD_FLAGS_DISALLOW_INHERIT_OWNER = 0x40000;
const UINT LOAD_FLAGS_ERROR_LOAD_CHANGES_RV = 0x80000;
2013-04-04 16:15:16 +02:00
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);
2015-08-11 15:11:35 +02:00
nsresult LoadURIWithOptions(const PRUnichar *aURI, uint32_t aLoadFlags, nsIURI *aReferrer, uint32_t aReferrerPolicy,
2014-11-03 12:39:59 +01:00
nsIInputStream *aPostData, nsIInputStream *aHeaders, nsIURI *aBaseURI);
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(c4d64640-b332-4db6-a2a5-e08566000dc9),
local
]
interface nsIWebProgress : nsISupports
{
nsresult AddProgressListener(nsIWebProgressListener *aListener, uint32_t aNotifyMask);
nsresult RemoveProgressListener(nsIWebProgressListener *aListener);
nsresult GetDOMWindow(mozIDOMWindowProxy **aDOMWindow);
2013-09-25 14:17:08 +02:00
nsresult GetDOMWindowID(uint64_t *aDOMWindowID);
nsresult GetIsTopLevel(bool *aIsTopLevel);
nsresult GetIsLoadingDocument(bool *aIsLoadingDocument);
2014-11-03 12:39:59 +01:00
nsresult GetLoadType(uint32_t *aLoadType);
}
[
object,
uuid(ecc5cbad-57fc-4731-b0bd-09e865bd62ad),
local
]
interface nsIPrintSettings : nsISupports
{
2009-08-04 14:05:05 +02:00
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 SetPrintOptionsBits(int32_t bits);
2008-12-30 06:48:59 +01:00
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);
2008-12-30 06:48:59 +01:00
nsresult GetEdgeTop(double *aEdgeTop);
nsresult SetEdgeTop(double aEdgeTop);
nsresult GetEdgeLeft(double *aEdgeLeft);
nsresult SetEdgeLeft(double aEdgeLeft);
nsresult GetEdgeBottom(double *aEdgeBottom);
nsresult SetEdgeBottom(double aEdgeBottom);
nsresult GetEdgeRight(double *aEdgeRight);
nsresult SetEdgeRight(double aEdgeRight);
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);
2008-12-30 06:48:59 +01:00
nsresult GetUnwriteableMarginTop(double *aUnwriteableMarginTop);
nsresult SetUnwriteableMarginTop(double aUnwriteableMarginTop);
nsresult GetUnwriteableMarginLeft(double *aUnwriteableMarginLeft);
nsresult SetUnwriteableMarginLeft(double aUnwriteableMarginLeft);
nsresult GetUnwriteableMarginBottom(double *aUnwriteableMarginBottom);
nsresult SetUnwriteableMarginBottom(double aUnwriteableMarginBottom);
nsresult GetUnwriteableMarginRight(double *aUnwriteableMarginRight);
nsresult SetUnwriteableMarginRight(double aUnwriteableMarginRight);
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 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 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 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);
2013-09-25 14:17:08 +02:00
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);
2013-05-17 12:34:34 +02:00
nsresult GetPersistMarginBoxSettings(bool *aPersistMarginBoxSettings);
nsresult SetPersistMarginBoxSettings(bool aPersistMarginBoxSettings);
2009-08-04 14:05:05 +02:00
nsresult SetMarginInTwips(nsIntMargin *aMargin);
nsresult SetEdgeInTwips(nsIntMargin *aEdge);
nsresult GetMarginInTwips(nsIntMargin *aMargin);
nsresult GetEdgeInTwips(nsIntMargin *aEdge);
2008-12-30 06:48:59 +01:00
nsresult SetupSilentPrinting();
2009-08-04 14:05:05 +02:00
nsresult SetUnwriteableMarginInTwips(nsIntMargin *aEdge);
nsresult GetUnwriteableMarginInTwips(nsIntMargin *aEdge);
2014-11-03 12:39:59 +01:00
nsresult GetPageRanges(void * /*nsTArray<int32_t>*/ aPages);
}
[
object,
uuid(c9a934ed-fff1-4971-bfba-6c25ad70e1e6),
local
]
interface nsIWebBrowserPrint : nsISupports
{
nsresult GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings);
nsresult GetCurrentPrintSettings(nsIPrintSettings **aCurrentPrintSettings);
nsresult GetCurrentChildDOMWindow(mozIDOMWindowProxy **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, mozIDOMWindowProxy *aChildDOMWin,
nsIWebProgressListener *aWPListener);
nsresult PrintPreviewNavigate(int16_t aNavType, int32_t aPageNum);
nsresult Cancel();
nsresult EnumerateDocumentNames(uint32_t *aCount, PRUnichar ***aResult);
nsresult ExitPrintPreview();
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(3507fc93-313e-4a4c-8ca8-4d0ea0f97315),
local
]
interface nsIScrollable : nsISupports
{
enum {
ScrollOrientation_X = 1,
ScrollOrientation_Y = 2
};
enum {
Scrollbar_Auto = 1,
Scrollbar_Never = 2,
Scrollbar_Always = 3
};
2014-11-03 12:39:59 +01:00
nsresult GetDefaultScrollbarPreferences(int32_t scrollOrientation, int32_t *_retval);
nsresult SetDefaultScrollbarPreferences(int32_t scrollOrientation, int32_t scrollbarPref);
nsresult GetScrollbarVisibility(bool *verticalVisible, bool *horizontalVisible);
}
[
object,
uuid(2fa6884a-ae65-412a-9d4c-ce6e34544ba1),
local
]
interface nsIFile : nsISupports
{
2012-07-18 12:50:04 +02:00
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);
2014-11-03 12:39:59 +01:00
nsresult RenameTo(nsIFile *newParentDir, const nsAString *newName);
nsresult RenameToNative(nsIFile *newParentDir, const nsACString *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);
2013-01-09 14:21:18 +01:00
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);
2014-11-03 12:39:59 +01:00
nsresult Contains(nsIFile *inFile, bool *_retval);
nsresult GetParent(nsIFile **aParent);
nsresult GetDirectoryEntries(nsISimpleEnumerator **aDirectoryEntries);
2012-07-18 12:50:04 +02:00
nsresult InitWithPath(const nsAString *filePath);
nsresult InitWithNativePath(const nsACString *filePath);
nsresult InitWithFile(nsIFile *aFile);
nsresult GetFollowLinks(bool *aFollowLinks);
nsresult SetFollowLinks(bool aFollowLinks);
nsresult OpenNSPRFileDesc(int32_t flags, int32_t mode, PRFileDesc **_retval);
2012-07-18 12:50:04 +02:00
nsresult OpenANSIFileDesc(const char *mode, FILE **_retval);
nsresult Load(PRLibrary **_retval);
nsresult GetDiskSpaceAvailable(int64_t *aDiskSpaceAvailable);
2012-07-18 12:50:04 +02:00
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);
nsresult GetRelativePath(nsIFile *fromFile, nsACString *_retval);
nsresult SetRelativePath(nsIFile *fromFile, const nsACString *relativeDesc);
}
2005-08-11 20:36:48 +02:00
2012-10-09 11:26:18 +02:00
[
object,
2014-11-03 12:39:59 +01:00
uuid(d604ffc3-1ba3-4f6c-b65f-1ed4199364c3),
2012-10-09 11:26:18 +02:00
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);
2014-11-03 12:39:59 +01:00
nsresult GetManifestLocations(nsIArray **_retval);
2012-10-09 11:26:18 +02:00
}
2007-11-04 17:04:41 +01:00
[
object,
2013-05-17 12:34:34 +02:00
uuid(55d25e49-793f-4727-a69f-de8b15f4b985),
local
2007-11-04 17:04:41 +01:00
]
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);
2013-01-09 14:21:18 +01:00
nsresult GetFloatPref(const char *aPrefName, float *_retval);
2007-11-04 17:04:41 +01:00
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);
2007-11-04 17:04:41 +01:00
nsresult GetComplexValue(const char *aPrefName, const nsIID *aType, void **aValue);
nsresult SetComplexValue(const char *aPrefName, const nsIID *aType, nsISupports *aValue);
nsresult ClearUserPref(const char *aPrefName);
nsresult LockPref(const char *aPrefName);
nsresult PrefHasUserValue(const char *aPrefName, bool *_retval);
nsresult PrefIsLocked(const char *aPrefName, bool *_retval);
2007-11-04 17:04:41 +01:00
nsresult UnlockPref(const char *aPrefName);
nsresult DeleteBranch(const char *aStartingAt);
nsresult GetChildList(const char *aStartingAt, uint32_t *aCount, char ***aChildArray);
2007-11-04 17:04:41 +01:00
nsresult ResetBranch(const char *aStartingAt);
2012-06-11 15:32:18 +02:00
nsresult AddObserver(const char *aDomain, nsIObserver *aObserver, bool aHoldWeak);
nsresult RemoveObserver(const char *aDomain, nsIObserver *aObserver);
2007-11-04 17:04:41 +01:00
}
[
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(a87210e6-7c8c-41f7-864d-df809015193e),
local
]
interface nsIProtocolHandler : nsISupports
{
const unsigned long URI_STD = 0;
const unsigned long URI_NORELATIVE = (1<<0);
const unsigned long URI_NOAUTH = (1<<1);
const unsigned long ALLOWS_PROXY = (1<<2);
const unsigned long ALLOWS_PROXY_HTTP = (1<<3);
const unsigned long URI_INHERITS_SECURITY_CONTEXT = (1<<4);
const unsigned long URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT = (1<<5);
const unsigned long URI_LOADABLE_BY_ANYONE = (1<<6);
const unsigned long URI_DANGEROUS_TO_LOAD = (1<<7);
const unsigned long URI_IS_UI_RESOURCE = (1<<8);
const unsigned long URI_IS_LOCAL_FILE = (1<<9);
const unsigned long URI_LOADABLE_BY_SUBSUMERS = (1<<10);
const unsigned long URI_DOES_NOT_RETURN_DATA = (1<<11);
const unsigned long URI_IS_LOCAL_RESOURCE = (1<<12);
const unsigned long URI_OPENING_EXECUTES_SCRIPT = (1<<13);
const unsigned long URI_NON_PERSISTABLE = (1<<14);
const unsigned long URI_FORBIDS_COOKIE_ACCESS = (1<<15);
const unsigned long URI_CROSS_ORIGIN_NEEDS_WEBAPPS_PERM = (1<<16);
const unsigned long URI_SYNC_LOAD_IS_OK = (1<<17);
const unsigned long URI_SAFE_TO_LOAD_IN_SECURE_CONTEXT = (1<<18);
const unsigned long URI_FETCHABLE_BY_ANYONE = (1 << 19);
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);
2015-02-24 14:19:41 +01:00
nsresult NewChannel2(nsIURI *aURI, nsILoadInfo *aLoadinfo, nsIChannel **_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(d13c21ca-7329-45a5-8912-9d2e2fef1231),
local
]
interface nsIIOServiceHook : nsISupports
{
nsresult NewChannel(nsIURI *aURI, nsILoadInfo *aLoadInfo, nsIChannel **_retval);
nsresult GetProtocolHandler(nsIProtocolHandler *aHandler, nsIProtocolHandler **_retval);
nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval);
nsresult ProtocolHasFlags(nsIURI *aURI, uint32_t aFlag, bool *_retval);
nsresult URIChainHasFlags(nsIURI *aURI, uint32_t aFlags, bool *_retval);
}
2005-08-11 20:36:48 +02:00
[
object,
2015-08-11 15:11:35 +02:00
uuid(4286de5a-b2ea-446f-8f70-e2a461f42694),
local
2005-08-11 20:36:48 +02:00
]
interface nsIIOService : nsISupports
{
nsresult GetProtocolHandler(const char *aScheme, nsIProtocolHandler **_retval);
nsresult GetProtocolFlags(const char *aScheme, uint32_t *_retval);
2006-02-09 12:17:08 +01:00
nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
nsIURI **_retval);
2005-08-11 20:36:48 +02:00
nsresult NewFileURI(nsIFile *aFile, nsIURI **_retval);
2015-02-24 14:19:41 +01:00
nsresult NewChannelFromURI2(nsIURI *aURI, nsIDOMNode *aLoadingNode, nsIPrincipal *aLoadingPrincipal,
nsIPrincipal *aTriggeringPrincipal, uint32_t aSecurityFlags, uint32_t aContentPolicyType,
nsIChannel **_retval);
2015-08-11 15:11:35 +02:00
nsresult NewChannelFromURIWithLoadInfo(nsIURI *aURI, nsILoadInfo *aLoadInfo, nsIChannel **_retval);
2005-08-11 20:36:48 +02:00
nsresult NewChannelFromURI(nsIURI *aURI, nsIChannel **_retval);
2015-02-24 14:19:41 +01:00
nsresult NewChannel2(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
nsIDOMNode *aLoadingNode, nsIPrincipal *aLoadingPrincipal, nsIPrincipal *aTriggeringPrincipal,
uint32_t aSecurityFlags, uint32_t aContentPolicyType, nsIChannel **_retval);
2006-02-09 12:17:08 +01:00
nsresult NewChannel(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
nsIChannel **_retval);
nsresult GetOffline(bool *aOffline);
nsresult SetOffline(bool aOffline);
2015-08-11 15:11:35 +02:00
nsresult GetConnectivity(bool *aConnectivity);
2015-02-24 14:19:41 +01:00
nsresult SetAppOffline(uint32_t appId, int32_t state);
nsresult IsAppOffline(uint32_t appId, bool *_retval);
nsresult GetAppOfflineState(uint32_t appId, int32_t *_retval);
nsresult AllowPort(int32_t aPort, const char *aScheme, bool *_retval);
2011-11-09 18:11:42 +01:00
nsresult ExtractScheme(const nsACString *urlString, nsACString *_retval);
nsresult SetHook(nsIIOServiceHook *aHook);
}
[
object,
uuid(7f8c754e-5b36-44be-bc96-191b49f08ea6),
local
]
interface nsIWebBrowserFocus : nsISupports
{
nsresult Activate();
nsresult Deactivate();
nsresult SetFocusAtFirstElement();
nsresult SetFocusAtLastElement();
nsresult GetFocusedWindow(mozIDOMWindowProxy **aFocusedWindow);
nsresult SetFocusedWindow(mozIDOMWindowProxy *aFocusedWindow);
nsresult GetFocusedElement(nsIDOMElement **aFocusedElement);
nsresult SetFocusedElement(nsIDOMElement *aFocusedElement);
}
[
object,
2012-06-11 15:32:18 +02:00
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,
2014-11-03 12:39:59 +01:00
uuid(9a78ac3c-9507-4d00-b2d6-10b508d2ec31),
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);
2011-11-09 18:11:42 +01:00
/* Followed by methods we should try to avoid using */
}
[
object,
uuid(f58daacf-4d1a-4002-8fd7-06b614dfbcf6),
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();
void /* thiscall */ InitEvent(const nsAString *eventTypeArg, bool canBubbleArg, bool cancelableArg);
nsresult GetDefaultPrevented(bool *aDefaultPrevented);
2012-03-14 14:45:32 +01:00
nsresult StopImmediatePropagation();
2013-01-09 14:21:18 +01:00
nsresult GetOriginalTarget(nsIDOMEventTarget **aOriginalTarget);
nsresult GetExplicitOriginalTarget(nsIDOMEventTarget * *aExplicitOriginalTarget);
nsresult GetPreventDefault(bool *_retval);
nsresult GetIsTrusted(bool *aIsTrusted);
2012-10-09 11:26:18 +02:00
nsresult DuplicatePrivateData();
nsresult SetTarget(nsIDOMEventTarget *aTarget);
bool IsDispatchStopped();
/*WidgedEvent*/ void *WidgetEventPtr();
2013-05-17 12:34:34 +02:00
void SetTrusted(bool aTrusted);
2012-10-09 11:26:18 +02:00
void Serialize(/*IPC::Message*/ void *aMsg, bool aSerializeInterfaceType);
bool Deserialize(const /*IPC::Message*/ void *aMsg, void **aIter);
2013-09-25 14:17:08 +02:00
void SetOwner(void /*mozilla::dom::EventTarget*/ *aOwner);
void /*nsDOMEvent*/ *InternalDOMEvent();
nsresult StopCrossProcessForwarding();
}
[
object,
uuid(46b44e33-13c2-4eb3-bf80-76a4e0857ccc),
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);
2015-02-24 14:19:41 +01:00
nsresult UpdateLayerTree();
2013-01-09 14:21:18 +01:00
nsresult GetViewportInfo(uint32_t aDisplayWidth, uint32_t aDisplayHeight, double *aDefaultZoom, bool *aAllowZoom,
2014-11-03 12:39:59 +01:00
double *aMinZoom, double *aMaxZoom, uint32_t *aWidth, uint32_t *aHeight, bool *aAutoSize);
nsresult SetDisplayPortForElement(float aXPx, float aYPx, float aWidthPx, float aHeightPx,
nsIDOMElement *aElement, uint32_t aPriority);
nsresult SetDisplayPortMarginsForElement(float aLeftMargin, float aTopMargin, float aRightMargin, float aBottomMargin,
nsIDOMElement *aElement, uint32_t aPriority);
2014-11-03 12:39:59 +01:00
nsresult SetDisplayPortBaseForElement(int32_t aX, int32_t aY, int32_t aWidth, int32_t aHeight, nsIDOMElement *aElement);
2015-08-11 15:11:35 +02:00
nsresult SetResolution(float aResolution);
nsresult GetResolution(float *aResolution);
nsresult SetResolutionAndScaleTo(float aResolution);
2014-11-03 12:39:59 +01:00
nsresult GetIsResolutionSet(bool *aIsResolutionSet);
2012-07-18 12:50:04 +02:00
nsresult GetIsFirstPaint(bool *aIsFirstPaint);
nsresult SetIsFirstPaint(bool aIsFirstPaint);
2013-09-25 14:17:08 +02:00
nsresult GetPresShellId(uint32_t *aPresShellId);
2013-01-09 14:21:18 +01:00
nsresult SendMouseEvent(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
2014-11-03 12:39:59 +01:00
int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, bool aIsSynthesized,
uint8_t _argc, bool *_retval);
nsresult SendPointerEvent(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, int32_t aPointerId,
int32_t aWidth, int32_t aHeight, int32_t tiltX, int32_t tiltY, bool aIsPrimary, bool aIsSynthesized,
uint8_t _argc, bool *_retval);
nsresult SendTouchEvent(const nsAString *aType, uint32_t *aIdentifiers, int32_t *aXs, int32_t *aYs,
2014-11-03 12:39:59 +01:00
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,
2014-11-03 12:39:59 +01:00
int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, bool aIsSynthesized,
uint8_t _argc);
nsresult SendPointerEventToWindow(const nsAString *aType, float aX, float aY, int32_t aButton, int32_t aClickCount,
int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, uint16_t aInputSourceArg, int32_t aPointerId,
int32_t aWidth, int32_t aHeight, int32_t aTiltX, int32_t aTiltY, bool aIsPrimary, bool aIsSynthesized, uint8_t _argc);
nsresult SendTouchEventToWindow(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);
2013-01-09 14:21:18 +01:00
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,
2015-08-11 15:11:35 +02:00
const nsAString *aCharacters, const nsAString *aUnmodifiedCharacters, nsIObserver *aObserver);
nsresult SendNativeMouseEvent(int32_t aScreenX, int32_t aScreenY, int32_t aNativeMessage, int32_t aModifierFlags,
2015-08-11 15:11:35 +02:00
nsIDOMElement *aElement, nsIObserver *aObserver);
nsresult SendNativeMouseMove(int32_t aScreenX, int32_t aScreenY, nsIDOMElement *aElement, nsIObserver *aObserver);
nsresult SendNativeMouseScrollEvent(int32_t aScreenX, int32_t aScreenY, uint32_t aNativeMessage, double aDeltaX,
2015-08-11 15:11:35 +02:00
double aDeltaY, double aDeltaZ, uint32_t aModifierFlags, uint32_t aAdditionalFlags, nsIDOMElement *aElement,
nsIObserver *aObserver);
2014-11-03 12:39:59 +01:00
nsresult SendNativeTouchPoint(uint32_t aPointerId, uint32_t aTouchState, int32_t aScreenX, int32_t aScreenY,
2015-08-11 15:11:35 +02:00
double aPressure, uint32_t aOrientation, nsIObserver *aObserver);
nsresult SendNativeTouchTap(int32_t aScreenX, int32_t aScreenY, bool aLongTap, nsIObserver *aObserver);
nsresult ClearNativeTouchSequence(nsIObserver *aObserver);
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);
2014-11-03 12:39:59 +01:00
nsresult RunNextCollectorTimer();
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);
2014-11-03 12:39:59 +01:00
nsresult GetTranslationNodes(nsIDOMNode *aRoot, int /*nsITranslationNodeList*/ **_retval);
nsresult CompareCanvases(nsIDOMHTMLCanvasElement *aCanvas1, nsIDOMHTMLCanvasElement *aCanvas2,
uint32_t *aMaxDifference, uint32_t *_retval);
nsresult GetIsMozAfterPaintPending(bool *aIsMozAfterPaintPending);
nsresult SuppressEventHandling(bool aSuppress);
nsresult ClearMozAfterPaintEvents();
nsresult DisableNonTestMouseEvents(bool aDisable);
nsresult GetScrollXY(bool aFlushLayout, int32_t *aScrollX, int32_t *aScrollY);
2014-11-03 12:39:59 +01:00
nsresult GetScrollXYFloat(bool aFlushLayout, float *aScrollX, float *aScrollY);
2013-09-25 14:17:08 +02:00
nsresult GetScrollbarSize(bool aFlushLayout, int32_t *aWidth, int32_t *aHeight);
nsresult GetBoundsWithoutFlushing(nsIDOMElement *aElement, nsIDOMClientRect **_retval);
2012-07-18 12:50:04 +02:00
nsresult GetRootBounds(nsIDOMClientRect **_retval);
nsresult GetIMEIsOpen(bool *aIMEIsOpen);
nsresult GetIMEStatus(uint32_t *aIMEStatus);
nsresult GetScreenPixelsPerCSSPixel(float *aScreenPixelsPerCSSPixel);
2013-01-09 14:21:18 +01:00
nsresult GetFullZoom(float *aFullZoom);
nsresult DispatchDOMEventViaPresShell(nsIDOMNode *aTarget, nsIDOMEvent *aEvent, bool aTrusted, bool *_retval);
2013-05-17 12:34:34 +02:00
nsresult DispatchEventToChromeOnly(nsIDOMEventTarget *aTarget, nsIDOMEvent *aEvent, bool *_retval);
2012-07-18 12:50:04 +02:00
nsresult GetClassName(const /*JS::Value*/ void *aObject, JSContext *cx, char **_retval);
nsresult SendContentCommandEvent(const nsAString *aType, nsITransferable *aTransferable);
nsresult SendQueryContentEvent(uint32_t aType, uint32_t aOffset, uint32_t aLength, int32_t aX, int32_t aY,
2014-11-03 12:39:59 +01:00
uint32_t aAdditionalFlags, nsIQueryContentEventResult **_retval);
nsresult RemoteFrameFullscreenChanged(nsIDOMElement *aFrameElement);
2013-01-09 14:21:18 +01:00
nsresult RemoteFrameFullscreenReverted();
nsresult HandleFullscreenRequests(bool *_retval);
2013-01-09 14:21:18 +01:00
nsresult ExitFullscreen();
2014-11-03 12:39:59 +01:00
nsresult SendSelectionSetEvent(uint32_t aOffset, uint32_t aLength, uint32_t aAdditionalFlags, bool *_retval);
2013-01-09 14:21:18 +01:00
nsresult SelectAtPoint(float aX, float aY, uint32_t aSelectBehavior, bool *_retval);
nsresult GetVisitedDependentComputedStyle(nsIDOMElement *aElement, const nsAString *aPseudoElement,
const nsAString *aPropertyName, nsAString *_retval);
nsresult GetOuterWindowID(uint64_t *aOuterWindowID);
nsresult GetCurrentInnerWindowID(uint64_t *aCurrentInnerWindowID);
nsresult EnterModalState();
nsresult LeaveModalState();
nsresult IsInModalState(bool *_retval);
2015-08-11 15:11:35 +02:00
nsresult SetDesktopModeViewport(bool aDesktopModeViewport);
nsresult SuspendTimeouts();
nsresult ResumeTimeouts();
nsresult GetLayerManagerType(nsAString *aLayerManagerType);
2013-09-25 14:17:08 +02:00
nsresult GetLayerManagerRemote(bool *aLayerManagerRemote);
nsresult GetSupportsHardwareH264Decoding(void /* JS::MutableHandleValue */ *aSupportsHardwareH264Decoding);
2013-05-17 12:34:34 +02:00
nsresult StartFrameTimeRecording(uint32_t *startIndex);
2014-11-03 12:39:59 +01:00
nsresult StopFrameTimeRecording(uint32_t startIndex, uint32_t *frameCount, float **frameIntervals);
2013-01-09 14:21:18 +01:00
nsresult BeginTabSwitch();
nsresult GetDisplayDPI(float *aDisplayDPI);
nsresult GetOuterWindowWithId(uint64_t aOuterWindowID, nsIDOMWindow **_retval);
2014-11-03 12:39:59 +01:00
nsresult GetContainerElement(nsIDOMElement **aContainerElement);
nsresult RenderDocument(const void /*nsRect*/ *aRect, uint32_t aFlags, int /*nscolor*/ aBackgroundColor,
void /*gfxContext*/ *aThebesContext);
nsresult AdvanceTimeAndRefresh(int64_t aMilliseconds);
nsresult RestoreNormalRefresh();
2013-09-25 14:17:08 +02:00
nsresult GetIsTestControllingRefreshes(bool *aIsTestControllingRefreshes);
nsresult GetAsyncPanZoomEnabled(bool *aAsyncPanZoomEnabled);
nsresult SetAsyncScrollOffset(nsIDOMNode *aNode, float aX, float aY);
nsresult SetAsyncZoom(nsIDOMNode *aRootElement, float aValue);
nsresult FlushApzRepaints(bool *_retval);
nsresult ZoomToFocusedInput();
nsresult ComputeAnimationDistance(nsIDOMElement *element, const nsAString *property, const nsAString *value1,
const nsAString *value2, double *_retval);
nsresult WrapDOMFile(nsIFile *aFile, nsISupports **_retval);
nsresult GetFocusedInputType(char **aFocusedInputType);
2014-11-03 12:39:59 +01:00
nsresult GetViewId(nsIDOMElement *aElement, long /*nsViewID*/ *_retval);
nsresult LeafLayersPartitionWindow(bool *_retval);
nsresult CheckAndClearPaintedState(nsIDOMElement *aElement, bool *_retval);
2015-08-11 15:11:35 +02:00
nsresult IsPartOfOpaqueLayer(nsIDOMElement *aElement, bool *_retval);
nsresult NumberOfAssignedPaintedLayers(nsIDOMElement **aElements, uint32_t count, uint32_t *_retval);
nsresult GetFileId(const /*JS::Value*/ void *aFile, JSContext *cx, int64_t *_retval);
2015-02-24 14:19:41 +01:00
nsresult GetFilePath(void /*JS::HandleValue*/ *aFile, JSContext *cx, nsAString *_retval);
2014-11-03 12:39:59 +01:00
nsresult GetFileReferences(const nsAString *aDatabaseName, int64_t aId, void /*JS::HandleValue*/ *aOptions,
int32_t *aRefCnt, int32_t *aDBRefCnt, int32_t *aSliceRefCnt, JSContext* cx, bool *_retval);
nsresult FlushPendingFileDeletions();
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);
2012-07-18 12:50:04 +02:00
nsresult GetPlugins(JSContext *cx, /*JS::Value*/ void *aPlugins);
nsresult SetScrollPositionClampingScrollPortSize(float aWidth, float aHeight);
2014-11-03 12:39:59 +01:00
nsresult DisableDialogs();
nsresult EnableDialogs();
nsresult AreDialogsEnabled(bool *_retval);
2013-01-09 14:21:18 +01:00
nsresult LoadSheet(nsIURI *sheetURI, uint32_t type);
2015-02-24 14:19:41 +01:00
nsresult LoadSheetUsingURIString(const nsACString *sheetURI, uint32_t type);
2014-11-03 12:39:59 +01:00
nsresult AddSheet(nsIDOMStyleSheet *sheet, uint32_t type);
2013-01-09 14:21:18 +01:00
nsresult RemoveSheet(nsIURI *sheetURI, uint32_t type);
2015-02-24 14:19:41 +01:00
nsresult RemoveSheetUsingURIString(const nsACString *sheetURI, uint32_t type);
2013-01-09 14:21:18 +01:00
nsresult GetIsHandlingUserInput(bool *aIsHandlingUserInput);
nsresult AllowScriptsToClose();
2013-09-25 14:17:08 +02:00
nsresult GetIsParentWindowMainWidgetVisible(bool *aIsParentWindowMainWidgetVisible);
2013-05-17 12:34:34 +02:00
nsresult IsNodeDisabledForEvents(nsIDOMNode *aNode, bool *_retval);
2013-09-25 14:17:08 +02:00
nsresult GetPaintFlashing(bool *aPaintFlashing);
nsresult SetPaintFlashing(bool aPaintFlashing);
nsresult GetOMTAStyle(nsIDOMElement *aElement, const nsAString *aProperty,
const nsAString *aPseudoElement, nsAString *_retval);
2015-02-24 14:19:41 +01:00
nsresult RequestCompositorProperty(const nsAString *aProperty, float *_retval);
2014-11-03 12:39:59 +01:00
nsresult SetHandlingUserInput(bool aHandlingInput, void /*nsIJSRAIIHelper*/ **_retval);
nsresult GetContentAPZTestData(JSContext *cx, int /*JS::MutableHandleValue*/ _retval);
nsresult GetCompositorAPZTestData(JSContext *cx, void /*JS::MutableHandleValue*/ *_retval);
2015-08-11 15:11:35 +02:00
nsresult PostRestyleSelfEvent(nsIDOMElement *aElement);
2014-11-03 12:39:59 +01:00
nsresult GetAudioMuted(bool *aAudioMuted) ;
nsresult SetAudioMuted(bool aAudioMuted);
nsresult GetAudioVolume(float *aAudioVolume);
nsresult SetAudioVolume(float aAudioVolume);
nsresult XpconnectArgument(nsIDOMWindowUtils *aThis);
nsresult AskPermission(void /*nsIContentPermissionRequest*/ *aRequest);
2015-08-11 15:11:35 +02:00
nsresult GetFramesConstructed(uint64_t *aFramesConstructed);
nsresult GetFramesReflowed(uint64_t *aFramesReflowed);
nsresult SetChromeMargin(int32_t aTop, int32_t aRight, int32_t aBottom, int32_t aLeft);
nsresult GetServiceWorkersTestingEnabled(bool *aServiceWorkersTestingEnabled);
nsresult SetServiceWorkersTestingEnabled(bool aServiceWorkersTestingEnabled);
nsresult GetFrameUniformityTestData(JSContext* cx, int /*JS::MutableHandleValue*/ *_retval);
nsresult EnterChaosMode();
nsresult LeaveChaosMode();
nsresult HasRuleProcessorUsedByMultipleStyleSets(uint32_t aSheetType, bool *_retval);
nsresult ForceUseCounterFlush(nsIDOMNode *aNode);
nsresult SetNextPaintSyncId(int32_t aSyncId);
}
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(85ae52eb-37fa-4fd9-a2e6-c7d0f2a521b3),
local
]
interface nsIDOMUIEvent : nsISupports
{
nsresult GetView(mozIDOMWindowProxy **aView);
nsresult GetDetail(int32_t *aDetail);
nsresult InitUIEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
mozIDOMWindowProxy *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);
void* /* mozilla::dom::Event thiscall */ AsEvent();
}
[
object,
uuid(5bdab8d8-7933-4c5c-b6d1-ab34481237f7),
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);
2014-11-03 12:39:59 +01:00
nsresult GetButton(int16_t *aButton);
nsresult GetButtons(uint16_t *aButtons);
nsresult GetRelatedTarget(nsIDOMEventTarget **aRelatedTarget);
nsresult InitMouseEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
mozIDOMWindow *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);
2012-03-14 14:45:32 +01:00
nsresult GetMozPressure(float *aMozPressure);
nsresult GetMozInputSource(uint16_t *aMozInputSource);
2012-10-09 11:26:18 +02:00
nsresult GetModifierState(const nsAString *keyArg, bool *_retval);
}
[
object,
uuid(2e52eb99-670d-469a-b51f-8efee2dd091d),
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, mozIDOMWindowProxy *viewArg, bool ctrlKeyArg,
bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, uint32_t keyCodeArg,
uint32_t charCodeArg);
2012-10-09 11:26:18 +02:00
nsresult GetModifierState(const nsAString *keyArg, bool *_retval);
nsresult GetLocation(uint32_t *aLocation);
2014-11-03 12:39:59 +01:00
nsresult GetRepeat(bool *aRepeat);
2013-09-25 14:17:08 +02:00
nsresult GetKey(nsAString *aKey);
}
[
object,
2012-10-09 11:26:18 +02:00
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);
2012-10-09 11:26:18 +02:00
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(404ebfa2-d8f4-4c94-8416-e65a55f9df5a),
local
]
interface nsIPromptService : nsISupports
{
nsresult Alert(mozIDOMWindowProxy *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText);
nsresult AlertCheck(mozIDOMWindowProxy *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState);
nsresult Confirm(mozIDOMWindowProxy *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, bool *_retval);
nsresult ConfirmCheck(mozIDOMWindowProxy *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState,
bool *_retval);
nsresult ConfirmEx(mozIDOMWindowProxy *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(mozIDOMWindowProxy *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, PRUnichar **aValue, const PRUnichar *aCheckMsg,
bool *aCheckState, bool *_retval);
nsresult PromptUsernameAndPassword(mozIDOMWindowProxy *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, PRUnichar **aUsername, PRUnichar **aPassword,
const PRUnichar *aCheckMsg, bool *aCheckState, bool *_retval);
nsresult PromptPassword(mozIDOMWindowProxy *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, PRUnichar **aPassword, const PRUnichar *aCheckMsg,
bool *aCheckState, bool *_retval);
nsresult Select(mozIDOMWindowProxy *aParent, const PRUnichar *aDialogTitle,
const PRUnichar *aText, uint32_t aCount, const PRUnichar **aSelectList,
int32_t *aOutSelection, bool *_retval);
}
2006-03-27 21:02:28 +02:00
[
object,
uuid(b128a1e6-44f3-4331-8fbe-5af360ff21ee),
local
2006-03-27 21:02:28 +02:00
]
interface nsITooltipTextProvider : nsISupports
{
nsresult GetNodeText(nsIDOMNode *aNode, PRUnichar **aText, bool *_retval);
2006-03-27 21:02:28 +02:00
}
[
object,
uuid(24f963d1-e6fc-43ea-a206-99ac5fcc5265),
local
]
interface nsIEditingSession : nsISupports
{
nsresult GetEditorStatus(uint32_t *aEditorStatus);
nsresult MakeWindowEditable(mozIDOMWindowProxy *window, const char *aEditorType,
bool doAfterUriLoad, bool aMakeWholeDocumentEditable, bool aInteractive);
nsresult WindowIsEditable(mozIDOMWindowProxy *window, bool *_retval);
nsresult GetEditorForWindow(mozIDOMWindowProxy *window, nsIEditor **_retval);
nsresult SetupEditorOnWindow(mozIDOMWindowProxy *window);
nsresult TearDownEditorOnWindow(mozIDOMWindowProxy *window);
nsresult SetEditorOnControllers(mozIDOMWindowProxy *aWindow, nsIEditor *aEditor);
nsresult DisableJSAndPlugins(mozIDOMWindowProxy *aWindow);
nsresult RestoreJSAndPlugins(mozIDOMWindowProxy *aWindow);
nsresult DetachFromWindow(mozIDOMWindowProxy *aWindow);
nsresult ReattachToWindow(mozIDOMWindowProxy *aWindow);
nsresult GetJsAndPluginsDisabled(bool *aJsAndPluginsDisabled);
}
[
object,
2014-11-03 12:39:59 +01:00
uuid(b1fdf3c4-74e3-4f7d-a14d-2b76bcf53482),
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);
}
2006-08-18 23:14:44 +02:00
[
object,
uuid(bb5a1730-d83b-4fa2-831b-35b9d5842e84),
local
2006-08-18 23:14:44 +02:00
]
interface nsICommandManager : nsISupports
{
nsresult AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve);
nsresult RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved);
nsresult IsCommandSupported(const char *aCommandName, mozIDOMWindowProxy *aTargetWindow, bool *_retval);
nsresult IsCommandEnabled(const char *aCommandName, mozIDOMWindowProxy *aTargetWindow, bool *_retval);
nsresult GetCommandState(const char *aCommandName, mozIDOMWindowProxy *aTargetWindow,
2006-08-18 23:14:44 +02:00
nsICommandParams *aCommandParams);
nsresult DoCommand(const char *aCommandName, nsICommandParams *aCommandParams,
mozIDOMWindowProxy *aTargetWindow);
2006-08-18 23:14:44 +02:00
}
[
object,
uuid(3275b2cd-af6d-429a-80d7-f0c5120342ac),
local
]
interface nsICategoryManager : nsISupports
{
nsresult GetCategoryEntry(const char *aCategory, const char *aEntry, char **_retval);
nsresult AddCategoryEntry(const char *aCategory, const char *aEntry, const char *aValue, bool aPersist,
bool aReplace, char **_retval);
nsresult DeleteCategoryEntry(const char *aCategory, const char *aEntry, bool aPersist);
nsresult DeleteCategory(const char *aCategory);
nsresult EnumerateCategory(const char *aCategory, nsISimpleEnumerator **_retval);
nsresult EnumerateCategories(nsISimpleEnumerator **_retval);
}
[
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(8e1bab9d-8815-4d2c-a24d-7aba5239dc22),
2010-08-25 14:22:25 +02:00
local
]
interface nsIContent : nsISupports
{
/* This is not a real interface declaration. It's too internal for us. */
}
[
object,
uuid(ce1f7627-7109-4977-ba77-490ffde07aaa),
2010-08-25 14:22:25 +02:00
local
]
interface nsIDocument : nsISupports
{
/* This is not a real interface declaration. It's too internal for us. */
}
[
object,
uuid(b1ee32f2-b8c4-49b9-93df-b6fab5d54688),
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);
2010-08-25 14:22:25 +02:00
nsresult AppendDoctype(nsIContent *aDoctype, nsAString *aStr);
nsresult AppendElementStart(nsIContent *aElement, nsIContent *aOriginalElement,
2011-08-23 14:07:02 +02:00
nsAString *aStr);
2010-08-25 14:22:25 +02:00
nsresult AppendElementEnd(nsIContent *aElement, nsAString *aStr);
nsresult Flush(nsAString *aStr);
2010-08-25 14:22:25 +02:00
nsresult AppendDocumentStart(nsIDocument *aDocument, nsAString *aStr);
}
[
object,
2015-02-24 14:19:41 +01:00
uuid(094be624-f0bf-400f-89e2-6a84baab9474),
local
]
interface nsIEditor : nsISupports
{
nsresult GetSelection([out] nsISelection *_retval);
2015-02-24 14:19:41 +01:00
nsresult FinalizeSelection();
2014-11-03 12:39:59 +01:00
nsresult Init([in] nsIDOMDocument *doc, nsIContent *aRoot, nsISelectionController *aSelCon, uint32_t aFlags, nsAString *initialValue);
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);
2008-12-30 06:48:59 +01:00
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);
2008-12-30 06:48:59 +01:00
nsresult SyncRealTimeSpell();
nsresult SetSpellcheckUserOverride(bool enable);
nsresult Cut();
nsresult CanCut([out] bool *_retval);
nsresult Copy();
nsresult CanCopy([out] bool *_retval);
2015-02-24 14:19:41 +01:00
nsresult CanDelete(bool *_retval);
nsresult Paste([in] int32_t aSelectionType);
2010-08-25 14:22:25 +02:00
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);
2012-10-09 11:26:18 +02:00
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);
2014-11-03 12:39:59 +01:00
nsresult AddEditorObserver(nsIEditorObserver *observer);
2013-05-17 12:34:34 +02:00
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);
2014-11-03 12:39:59 +01:00
nsresult GetSuppressDispatchingInputEvent(bool *aSuppressDispatchingInputEvent);
2012-07-18 12:50:04 +02:00
nsresult SetSuppressDispatchingInputEvent(bool aSuppressDispatchingInputEvent);
2014-11-03 12:39:59 +01:00
nsresult GetIsInEditAction(bool *aIsInEditAction);
}
2007-09-12 11:41:49 +02:00
[
object,
2015-08-11 15:11:35 +02:00
uuid(87ee993e-985f-4a43-a974-0d9512da2fb0),
local
2007-09-12 11:41:49 +02:00
]
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);
2007-09-12 11:41:49 +02:00
nsresult RemoveAllInlineProperties();
nsresult RemoveInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute);
nsresult IncreaseFontSize();
nsresult DecreaseFontSize();
nsresult NodeIsBlock([in] nsIDOMNode *node, bool *_retval);
2007-09-12 11:41:49 +02:00
nsresult InsertHTML([in] nsAString *aInputString);
nsresult PasteNoFormatting([in] int32_t aSelectionType);
2007-09-12 11:41:49 +02:00
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);
2007-09-12 11:41:49 +02:00
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);
2007-09-12 11:41:49 +02:00
nsresult RemoveList([in] nsAString *aListType);
nsresult Indent([in] nsAString *aIndent);
nsresult Align([in] nsAString *aAlign);
nsresult GetElementOrParentByTagName([in] nsAString *aTagName, [in] nsIDOMNode *aNode, [out] nsIDOMElement **_retval);
nsresult GetSelectedElement([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
nsresult GetHeadContentsAsHTML([out] nsAString *_retval);
nsresult ReplaceHeadContentsWithHTML([in] nsAString *aSourceToInsert);
nsresult CreateElementWithDefaults([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
nsresult InsertLinkAroundSelection([in] nsIDOMElement *aAnchorElement);
nsresult SetBackgroundColor([in] nsAString *aColor);
nsresult SetBodyAttribute([in] nsAString *aAttr, [in] nsAString *aValue);
nsresult GetLinkedObjects([out] nsISupportsArray **_retval);
nsresult GetIsCSSEnabled([out] bool *_retval);
nsresult SetIsCSSEnabled([in] bool prb);
2007-09-12 11:41:49 +02:00
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);
2007-09-12 11:41:49 +02:00
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);
2012-10-09 11:26:18 +02:00
void /*Element*/ *GetActiveEditingHost();
2007-09-12 11:41:49 +02:00
}
[
object,
uuid(b8100c90-73be-11d2-92a5-00105a1b0d64),
local
]
interface nsIClipboardCommands : nsISupports
{
nsresult CanCutSelection(bool *_retval);
nsresult CanCopySelection(bool *_retval);
nsresult CanCopyLinkLocation(bool *_retval);
nsresult CanCopyImageLocation(bool *_retval);
nsresult CanCopyImageContents(bool *_retval);
nsresult CanPaste(bool *_retval);
nsresult CutSelection();
nsresult CopySelection();
nsresult CopyLinkLocation();
nsresult CopyImageLocation();
nsresult CopyImageContents();
nsresult Paste();
nsresult SelectAll();
nsresult SelectNone();
}
2013-05-17 12:34:34 +02:00
[
object,
uuid(9b7c586f-9214-480c-a2c4-49b526fff1a6),
2013-05-17 12:34:34 +02:00
local
]
2014-11-03 12:39:59 +01:00
interface nsIDocShellTreeItem : nsISupports
2013-05-17 12:34:34 +02:00
{
2014-11-03 12:39:59 +01:00
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);
int32_t ItemType();
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);
2013-05-17 12:34:34 +02:00
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);
2014-11-03 12:39:59 +01:00
nsIDocument /* thiscall */ *GetDocument();
void /* thiscall nsPIDOMWindowOuter */ *GetWindow();
2013-05-17 12:34:34 +02:00
}
[
object,
uuid(2da17016-7851-4a45-a7a8-00b360e01595),
2013-05-17 12:34:34 +02:00
local
]
2014-11-03 12:39:59 +01:00
interface nsIContentViewer : nsISupports
2013-05-17 12:34:34 +02:00
{
2014-11-03 12:39:59 +01:00
nsresult Init(nsIWidget *aParentWidget, const void /*nsIntRect*/ *aBounds);
nsresult GetContainer(nsIDocShell **aContainer);
nsresult SetContainer(nsIDocShell *aContainer);
void /* thiscall */ LoadStart(nsIDocument *aDoc);
nsresult LoadComplete(nsresult aStatus);
nsresult PermitUnload(bool *_retval);
2014-11-03 12:39:59 +01:00
nsresult GetInPermitUnload(bool *aInPermitUnload);
nsresult /* thiscall */ PermitUnloadInternal(bool *aShouldPrompt, bool *_retval);
2014-11-03 12:39:59 +01:00
nsresult GetBeforeUnloadFiring(bool *aBeforeUnloadFiring);
nsresult PageHide(bool isUnload);
nsresult Close(nsISHEntry *historyEntry);
nsresult Destroy();
nsresult Stop();
nsresult GetDOMDocument(nsIDOMDocument **aDOMDocument);
nsresult SetDOMDocument(nsIDOMDocument *aDOMDocument);
void /* thiscall nsresult_(nsIDocument *) */ GetDocument();
nsresult GetBounds(void /*nsIntRect*/ *aBounds);
nsresult SetBounds(const void /*nsIntRect*/ *aBounds);
nsresult GetPreviousViewer(nsIContentViewer **aPreviousViewer);
nsresult SetPreviousViewer(nsIContentViewer *aPreviousViewer);
nsresult Move(int32_t aX, int32_t aY);
nsresult Show();
nsresult Hide();
nsresult GetSticky(bool *aSticky);
nsresult SetSticky(bool aSticky);
nsresult RequestWindowClose(bool *_retval);
nsresult Open(nsISupports *aState, nsISHEntry *aSHEntry);
nsresult ClearHistoryEntry();
nsresult SetPageMode(bool aPageMode, nsIPrintSettings *aPrintSettings);
nsresult GetHistoryEntry(nsISHEntry **aHistoryEntry);
nsresult GetIsTabModalPromptAllowed(bool *aIsTabModalPromptAllowed);
nsresult GetIsHidden(bool *aIsHidden);
nsresult SetIsHidden(bool aIsHidden);
nsresult GetPresShell(nsIPresShell **aPresShell);
nsresult GetPresContext(void /*nsPresContext*/ **aPresContext);
nsresult SetDocumentInternal(nsIDocument *aDocument, bool aForceReuseInnerWindow);
void /* thiscall nsView */ *FindContainerView(void);
void /* thiscall */ SetNavigationTiming(void /*nsDOMNavigationTiming*/ *aTiming);
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 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 GetContentSize(int32_t *width, int32_t *height);
nsresult GetMinFontSize(int32_t *aMinFontSize);
nsresult SetMinFontSize(int32_t aMinFontSize);
nsresult AppendSubtree(void /*nsTArray<nsCOMPtr<nsIContentViewer> >*/ *array);
nsresult PausePainting();
nsresult ResumePainting();
nsresult EmulateMedium(const nsAString *aMediaType);
nsresult StopEmulatingMedium();
2013-05-17 12:34:34 +02:00
}
[
object,
uuid(e7570e5a-f1d6-452d-b4f8-b35fdc63aa03),
local
]
interface nsIDocShellLoadInfo : nsISupports
{
typedef uint32_t nsDocShellInfoReferrerPolicy;
typedef enum {
loadNormal = 0,
loadNormalReplace = 1,
loadHistory = 2,
loadReloadNormal = 3,
loadReloadBypassCache = 4,
loadReloadBypassProxy = 5,
loadReloadBypassProxyAndCache = 6,
loadLink = 7,
loadRefresh = 8,
loadReloadCharsetChange = 9,
loadBypassHistory = 10,
loadStopContent = 11,
loadStopContentAndReplace = 12,
loadNormalExternal = 13,
loadNormalBypassCache = 14,
loadNormalBypassProxy = 15,
loadNormalBypassProxyAndCache = 16,
loadPushState = 17,
loadReplaceBypassCache = 18,
loadReloadMixedContent = 19,
loadNormalAllowMixedContent = 20
} nsDocShellInfoLoadType;
nsresult GetReferrer(nsIURI **aReferrer);
nsresult SetReferrer(nsIURI *aReferrer);
nsresult GetOriginalURI(nsIURI **aOriginalURI);
nsresult SetOriginalURI(nsIURI *aOriginalURI);
nsresult GetLoadReplace(bool *aLoadReplace);
nsresult SetLoadReplace(bool aLoadReplace);
nsresult GetOwner(nsISupports **aOwner);
nsresult SetOwner(nsISupports *aOwner);
nsresult GetInheritOwner(bool *aInheritOwner);
nsresult SetInheritOwner(bool aInheritOwner);
nsresult GetOwnerIsExplicit(bool *aOwnerIsExplicit);
nsresult SetOwnerIsExplicit(bool aOwnerIsExplicit);
nsresult GetLoadType(nsDocShellInfoLoadType *aLoadType);
nsresult SetLoadType(nsDocShellInfoLoadType aLoadType);
nsresult GetSHEntry(nsISHEntry **aSHEntry);
nsresult SetSHEntry(nsISHEntry *aSHEntry);
nsresult GetTarget(char16_t **aTarget);
nsresult SetTarget(const char16_t * aTarget);
nsresult GetPostDataStream(nsIInputStream **aPostDataStream);
nsresult SetPostDataStream(nsIInputStream *aPostDataStream);
nsresult GetHeadersStream(nsIInputStream * *aHeadersStream);
nsresult SetHeadersStream(nsIInputStream *aHeadersStream);
nsresult GetSendReferrer(bool *aSendReferrer);
nsresult SetSendReferrer(bool aSendReferrer);
nsresult GetReferrerPolicy(nsDocShellInfoReferrerPolicy *aReferrerPolicy);
nsresult SetReferrerPolicy(nsDocShellInfoReferrerPolicy aReferrerPolicy);
nsresult GetIsSrcdocLoad(bool *aIsSrcdocLoad);
nsresult GetSrcdocData(nsAString *aSrcdocData);
nsresult SetSrcdocData(const nsAString *aSrcdocData);
nsresult GetSourceDocShell(nsIDocShell * *aSourceDocShell);
nsresult SetSourceDocShell(nsIDocShell *aSourceDocShell);
nsresult GetBaseURI(nsIURI **aBaseURI);
nsresult SetBaseURI(nsIURI *aBaseURI);
}
[
object,
uuid(049234fe-da10-478b-bc5d-bc6f9a1ba63d),
local
]
2013-05-17 12:34:34 +02:00
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 *aOriginalURI, bool aLoadReplace, nsIURI *aReferrer,
uint32_t aReferrerPolicy, nsISupports *aOwner, uint32_t aFlags, const PRUnichar *aWindowTarget,
const char *aTypeHint, nsACString *aFileName, nsIInputStream *aPostDataStream,
nsIInputStream *aHeadersStream, uint32_t aLoadFlags, nsISHEntry *aSHEntry, bool firstParty,
const nsAString *aSrcdoc, nsIDocShell *aSourceDocShell, nsIURI *aBaseURI, nsIDocShell **aDocShell,
nsIRequest **aRequest);
2014-11-03 12:39:59 +01:00
nsresult AddState(jsval *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);
2013-05-17 12:34:34 +02:00
nsIPresShell *GetPresShell();
nsresult GetEldestPresShell(nsIPresShell **aEldestPresShell);
nsresult GetContentViewer(nsIContentViewer **aContentViewer);
nsresult GetChromeEventHandler(nsIDOMEventTarget **aChromeEventHandler);
nsresult SetChromeEventHandler(nsIDOMEventTarget *aChromeEventHandler);
nsresult GetCustomUserAgent(nsAString *aCustomUserAgent);
nsresult SetCustomUserAgent(const nsAString *aCustomUserAgent);
nsresult GetAllowPlugins(bool *aAllowPlugins);
nsresult SetAllowPlugins(bool aAllowPlugins);
nsresult GetAllowJavascript(bool *aAllowJavascript);
nsresult SetAllowJavascript(bool aAllowJavascript);
2012-10-09 11:26:18 +02:00
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);
2013-09-25 14:17:08 +02:00
nsresult GetAllowMedia(bool *aAllowMedia);
nsresult SetAllowMedia(bool aAllowMedia);
nsresult GetAllowDNSPrefetch(bool *aAllowDNSPrefetch);
nsresult SetAllowDNSPrefetch(bool aAllowDNSPrefetch);
nsresult GetAllowWindowControl(bool *aAllowWindowControl);
nsresult SetAllowWindowControl(bool aAllowWindowControl);
2014-11-03 12:39:59 +01:00
nsresult GetAllowContentRetargeting(bool *aAllowContentRetargeting);
nsresult SetAllowContentRetargeting(bool aAllowContentRetargeting);
2015-08-11 15:11:35 +02:00
nsresult GetAllowContentRetargetingOnChildren(bool *aAllowContentRetargetingOnChildren);
nsresult SetAllowContentRetargetingOnChildren(bool aAllowContentRetargetingOnChildren);
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 forDocumentNavigation, bool *_retval);
nsresult GetBusyFlags(uint32_t *aBusyFlags);
nsresult GetLoadType(uint32_t *aLoadType);
nsresult SetLoadType(uint32_t aLoadType);
2014-11-03 12:39:59 +01:00
nsresult GetDefaultLoadFlags(nsLoadFlags *aDefaultLoadFlags);
nsresult SetDefaultLoadFlags(nsLoadFlags aDefaultLoadFlags);
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 DisplayLoadError(nsresult aError, nsIURI *aURI, const char16_t *aURL, nsIChannel *aFailedChannel, bool *_retval);
2014-11-03 12:39:59 +01:00
nsresult GetFailedChannel(nsIChannel **aFailedChannel);
nsresult GetPreviousTransIndex(int32_t *aPreviousTransIndex);
nsresult GetLoadedTransIndex(int32_t *aLoadedTransIndex);
nsresult HistoryPurged(int32_t numEntries);
2010-08-25 14:22:25 +02:00
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);
2013-05-17 12:34:34 +02:00
nsresult GetHasMixedActiveContentLoaded(bool *aHasMixedActiveContentLoaded);
nsresult GetHasMixedActiveContentBlocked(bool *aHasMixedActiveContentBlocked);
nsresult GetHasMixedDisplayContentLoaded(bool *aHasMixedDisplayContentLoaded);
nsresult GetHasMixedDisplayContentBlocked(bool *aHasMixedDisplayContentBlocked);
2014-11-03 12:39:59 +01:00
nsresult GetHasTrackingContentBlocked(bool *aHasTrackingContentBlocked);
nsresult GetHasTrackingContentLoaded(bool *aHasTrackingContentLoaded);
void DetachEditorFromWindow();
nsresult GetIsOffScreenBrowser(bool *aIsOffScreenBrowser);
nsresult SetIsOffScreenBrowser(bool aIsOffScreenBrowser);
2010-08-25 14:22:25 +02:00
nsresult GetPrintPreview(nsIWebBrowserPrint **aPrintPreview);
nsresult GetCanExecuteScripts(bool *aCanExecuteScripts);
nsresult GetIsActive(bool *aIsActive);
nsresult SetIsActive(bool aIsActive);
nsresult SetIsActiveAndForeground(bool aIsActive);
2015-08-11 15:11:35 +02:00
nsresult SetIsPrerendered(bool prerendered);
nsresult GetIsPrerendered(bool *aIsPrerendered);
nsresult GetHistoryID(uint64_t *aHistoryID);
nsresult GetIsAppTab(bool *aIsAppTab);
nsresult SetIsAppTab(bool aIsAppTab);
2011-08-23 14:07:02 +02:00
nsresult CreateAboutBlankContentViewer(nsIPrincipal *aPrincipal);
2014-11-03 12:39:59 +01:00
nsresult GetCharset(nsACString *aCharset);
nsresult SetCharset(nsACString *aCharset);
2013-09-25 14:17:08 +02:00
nsresult GatherCharsetMenuTelemetry();
2012-06-11 15:32:18 +02:00
nsresult GetForcedCharset(nsIAtom **aForcedCharset);
nsresult SetForcedCharset(nsIAtom *aForcedCharset);
void /* thiscall */ SetParentCharset(const nsACString *parentCharset, int32_t parentCharsetSource, nsIPrincipal *parentCharsetPrincipal);
void /* thiscall */ GetParentCharset(nsACString *parentCharset, int32_t *parentCharsetSource, nsIPrincipal **parentCharsetPrincipal);
2015-02-24 14:19:41 +01:00
nsresult GetRecordProfileTimelineMarkers(bool *aRecordProfileTimelineMarkers);
nsresult SetRecordProfileTimelineMarkers(bool aRecordProfileTimelineMarkers);
nsresult Now(int /* DOMHighResTimeStamp */ *_retval);
nsresult PopProfileTimelineMarkers(JSContext *cx, void /*JS::MutableHandleValue*/ *_retval);
2012-10-09 11:26:18 +02:00
nsresult AddWeakPrivacyTransitionObserver(nsIPrivacyTransitionObserver *obs);
2013-09-25 14:17:08 +02:00
nsresult AddWeakReflowObserver(nsISupports /*nsIReflowObserver*/ *obs);
nsresult RemoveWeakReflowObserver(nsISupports /*nsIReflowObserver*/ *obs);
nsresult NotifyReflowObservers(bool interruptible, int /*DOMHighResTimeStamp*/ start, int /*DOMHighResTimeStamp*/ end);
2014-11-03 12:39:59 +01:00
nsresult AddWeakScrollObserver(void /*nsIScrollObserver*/ *obs);
nsresult RemoveWeakScrollObserver(void /*nsIScrollObserver*/ *obs);
nsresult NotifyScrollObservers();
2013-01-09 14:21:18 +01:00
nsresult GetIsApp(bool *aIsApp);
nsresult GetFrameType(uint32_t *aFrameType);
nsresult SetFrameType(uint32_t aFrameType);
nsresult GetIsMozBrowserOrApp(bool *aIsMozBrowserOrApp);
nsresult GetIsIsolatedMozBrowserElement(bool *aIsIsolatedMozBrowserElement);
nsresult GetIsInIsolatedMozBrowserElement(bool *aIsInIsolatedMozBrowserElement);
nsresult SetIsInIsolatedMozBrowserElement(bool aIsInIsolatedMozBrowserElement);
nsresult GetIsInMozBrowserOrApp(bool *aIsInMozBrowserOrApp);
2013-01-09 14:21:18 +01:00
nsresult GetAppId(uint32_t *aAppId);
2014-11-03 12:39:59 +01:00
nsresult GetAppManifestURL(nsAString *aAppManifestURL);
2013-01-09 14:21:18 +01:00
nsresult GetSameTypeParentIgnoreBrowserAndAppBoundaries(nsIDocShell **_retval);
nsresult GetSameTypeRootTreeItemIgnoreBrowserAndAppBoundaries(nsIDocShell **_retval);
2013-01-09 14:21:18 +01:00
nsresult GetAsyncPanZoomEnabled(bool *aAsyncPanZoomEnabled);
nsresult GetSandboxFlags(uint32_t *aSandboxFlags);
nsresult SetSandboxFlags(uint32_t aSandboxFlags);
2014-11-03 12:39:59 +01:00
nsresult GetOnePermittedSandboxedNavigator(nsIDocShell **aOnePermittedSandboxedNavigator);
nsresult SetOnePermittedSandboxedNavigator(nsIDocShell *aOnePermittedSandboxedNavigator);
bool /* thiscall */ IsSandboxedFrom(nsIDocShell *aTargetDocShell);
2013-05-17 12:34:34 +02:00
nsresult GetMixedContentChannel(nsIChannel **aMixedContentChannel);
nsresult SetMixedContentChannel(nsIChannel *aMixedContentChannel);
nsresult GetAllowMixedContentAndConnectionData(bool *rootHasSecureConnection, bool *allowMixedContent, bool *isRootDocShell);
2013-01-09 14:21:18 +01:00
bool PluginsAllowedInCurrentDoc();
nsresult GetFullscreenAllowed(bool *aFullscreenAllowed);
nsresult SetFullscreenAllowed(bool allowed);
uint32_t OrientationLock();
void SetOrientationLock(uint32_t orientationLock);
2013-05-17 12:34:34 +02:00
nsresult GetAffectPrivateSessionLifetime(bool *aAffectPrivateSessionLifetime);
nsresult SetAffectPrivateSessionLifetime(bool aAffectPrivateSessionLifetime);
nsresult GetMayEnableCharacterEncodingMenu(bool *aMayEnableCharacterEncodingMenu);
nsresult GetEditor(nsIEditor **aEditor);
nsresult SetEditor(nsIEditor *aEditor);
nsresult GetEditable(bool *aEditable);
nsresult GetHasEditingSession(bool *aHasEditingSession);
nsresult MakeEditable(bool inWaitForUriLoad);
2013-09-25 14:17:08 +02:00
nsresult GetChildSHEntry(int32_t aChildOffset, nsISHEntry **_retval);
2013-10-01 17:02:00 +02:00
nsresult AddChildSHEntry(nsISHEntry *aCloneReference, nsISHEntry *aHistoryEntry, int32_t aChildOffset, uint32_t aLoadType, bool aCloneChildren);
2013-09-25 14:17:08 +02:00
nsresult GetUseGlobalHistory(bool *aUseGlobalHistory);
nsresult SetUseGlobalHistory(bool aUseGlobalHistory);
nsresult RemoveFromSessionHistory();
nsresult GetCreatedDynamically(bool *aCreatedDynamically);
nsresult SetCreatedDynamically(bool aCreatedDynamically);
nsresult GetCurrentSHEntry(nsISHEntry **aEntry, bool *_retval);
2014-11-03 12:39:59 +01:00
nsresult IsCommandEnabled(const char *command, bool *_retval);
nsresult DoCommand(const char *command);
bool IsInvisible();
void SetInvisible(bool aIsInvisibleDochsell);
void /* nsIScriptGlobalObject thiscall */ *GetScriptGlobalObject();
2014-11-03 12:39:59 +01:00
nsresult GetDeviceSizeIsPageSize(bool *aDeviceSizeIsPageSize);
nsresult SetDeviceSizeIsPageSize(bool aDeviceSizeIsPageSize);
void /* thiscall */ SetOpener(void /*nsITabParent*/ *aOpener);
2015-02-24 14:19:41 +01:00
void /* thiscall nsITabParent */ *GetOpener();
2015-08-11 15:11:35 +02:00
void /* thiscall */ NotifyJSRunToCompletionStart(const char *aReason, const char16_t *functionName,
const char16_t *fileName, uint32_t lineNumber);
2015-02-24 14:19:41 +01:00
void /* thiscall */ NotifyJSRunToCompletionStop();
nsresult GetHasLoadedNonBlankURI(bool *aHasLoadedNonBlankURI);
2015-08-11 15:11:35 +02:00
nsresult GetPaymentRequestId(nsAString *aPaymentRequestId);
nsresult SetPaymentRequestId(const nsAString *aPaymentRequestId);
nsresult GetWindowDraggingAllowed(bool *aWindowDraggingAllowed);
nsresult SetWindowDraggingAllowed(bool aWindowDraggingAllowed);
nsresult GetCurrentScrollRestorationIsManual(bool *aCurrentScrollRestorationIsManual);
nsresult SetCurrentScrollRestorationIsManual(bool aCurrentScrollRestorationIsManual);
nsresult GetOriginAttributes(JSContext* cx, void* /* JS::MutableHandleValue */ _retval);
nsresult SetOriginAttributes(int /* JS::HandleValue */ aAttrs, JSContext *cx);
}
2008-12-30 06:48:59 +01:00
[
object,
uuid(6d674c17-0fbc-4633-8f46-734e87ebf0c7),
2008-12-30 06:48:59 +01:00
local
]
interface nsIMutationObserver : nsISupports
{
typedef struct {} nsAttrValue;
2008-12-30 06:48:59 +01:00
void CharacterDataWillChange(nsIDocument *aDocument, nsIContent *aContent,
void /*CharacterDataChangeInfo*/ *aInfo);
void CharacterDataChanged(nsIDocument *aDocument, nsIContent *aContent,
void /*CharacterDataChangeInfo*/ *aInfo);
void AttributeWillChange(nsIDocument *aDocument, /*mozilla::dom::Element*/ void *aElement, int32_t aNameSpaceID,
nsIAtom *aAttribute, int32_t aModType, const nsAttrValue *aNewValue);
void AttributeChanged(nsIDocument *aDocument, /*mozilla::dom::Element*/ void *aElement, int32_t aNameSpaceID,
nsIAtom *aAttribute, int32_t aModType, const nsAttrValue *aOldValue);
void NativeAnonymousChildListChange(nsIDocument *aDocument, nsIContent *aContent, bool aIsRemove);
2013-01-09 14:21:18 +01:00
void AttributeSetToCurrentValue(nsIDocument *aDocument, /*mozilla::dom::Element*/ void *aElement,
int32_t aNameSpaceID, nsIAtom *aAttribute);
2011-11-09 18:11:42 +01:00
void ContentAppended(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aFirstNewContent,
int32_t aNewIndexInContainer);
2008-12-30 06:48:59 +01:00
void ContentInserted(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
int32_t aIndexInContainer);
2008-12-30 06:48:59 +01:00
void ContentRemoved(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
int32_t aIndexInContainer, nsIContent *aPreviousSibling);
2008-12-30 06:48:59 +01:00
void NodeWillBeDestroyed(const nsINode *aNode);
void ParentChainChanged(nsIContent *aContent);
}
[
object,
2012-07-18 12:50:04 +02:00
uuid(2c4ad90a-740e-4212-ba3f-feacda4b929e),
local
]
interface nsIParser : nsISupports
{
typedef int nsDTDMode;
typedef int eParserCommands;
2012-06-11 15:32:18 +02:00
/* 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);
2014-11-03 12:39:59 +01:00
/* nsresult GetChannel(nsIChannel **aChannel); in nsParserBase */
nsresult GetDTD(nsIDTD **aDTD);
2012-03-14 14:45:32 +01:00
nsIStreamListener *GetStreamListener();
nsresult ContinueInterruptedParsing();
void BlockParser();
void UnblockParser();
2012-06-11 15:32:18 +02:00
void ContinueInterruptedParsingAsync();
2014-11-03 12:39:59 +01:00
/* bool IsParserEnabled(); in nsParserBase */
bool IsComplete();
nsresult Parse(nsIURI *aURL, nsIRequestObserver *aListener, void *aKey, nsDTDMode aMode);
nsresult Terminate();
2011-11-09 18:11:42 +01:00
nsresult ParseFragment(const nsAString *aSourceBuffer, void /*nsTArray<nsString>*/ *aTagStack);
nsresult BuildModel();
nsresult CancelParsingEvents();
2011-08-23 14:07:02 +02:00
void Reset();
bool IsInsertionPointDefined();
2011-08-23 14:07:02 +02:00
void BeginEvaluatingParserInsertedScript();
void EndEvaluatingParserInsertedScript();
2012-03-14 14:45:32 +01:00
void MarkAsNotScriptCreated(const char *aCommand);
bool IsScriptCreated();
}
2008-12-30 06:48:59 +01:00
[
object,
uuid(71041fa3-6dd7-4cde-bb76-aecc69e17578),
2008-12-30 06:48:59 +01:00
local
]
interface nsIDocumentObserver : nsIMutationObserver
{
typedef uint32_t nsUpdateType;
2008-12-30 06:48:59 +01:00
typedef struct {
void *dummy;
} mozilla_StyleSheetHandle;
2011-03-15 13:45:29 +01:00
typedef struct {
uint64_t mStates;
2014-11-03 12:39:59 +01:00
} EventStates;
2011-03-15 13:45:29 +01:00
2008-12-30 06:48:59 +01:00
void BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
void EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
void BeginLoad(nsIDocument *aDocument);
void EndLoad(nsIDocument *aDocument);
2014-11-03 12:39:59 +01:00
void ContentStatesChanged(nsIDocument *aDocument, nsIContent *aContent, EventStates aStateMask);
void DocumentStatesChanged(nsIDocument *aDocument, EventStates aStateMask);
void StyleSheetAdded(mozilla_StyleSheetHandle aStyleSheet, bool aDocumentSheet);
void StyleSheetRemoved(mozilla_StyleSheetHandle aStyleSheet, bool aDocumentSheet);
void StyleSheetApplicableStateChanged(mozilla_StyleSheetHandle aStyleSheet);
void StyleRuleChanged(mozilla_StyleSheetHandle aStyleSheet);
void StyleRuleAdded(mozilla_StyleSheetHandle aStyleSheet);
void StyleRuleRemoved(mozilla_StyleSheetHandle aStyleSheet);
2008-12-30 06:48:59 +01:00
void BindToDocument(nsIDocument *aDocument, nsIContent *aContent);
void AttemptToExecuteScript(nsIContent *aContent, nsIParser *aParser, bool *aBlock);
2011-03-15 13:45:29 +01:00
}
[
object,
uuid(3682dd99-8560-44f4-9b8f-ccce9d7b96fb),
local
]
interface nsIContentUtils : nsISupports
{
bool IsSafeToRunScript();
2011-03-15 13:45:29 +01:00
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);
2012-10-09 11:26:18 +02:00
JSContext *GetContextFromDocument(nsIDocument *aDocument);
2008-12-30 06:48:59 +01:00
}
[
object,
uuid(15c05894-408e-4798-b527-a8c32d9c5f8c),
local
]
interface nsIAudioChannelAgentCallback : nsISupports
{
nsresult WindowVolumeChanged(float aVolume, bool aMuted);
nsresult WindowAudioCaptureChanged(bool aCapture);
}
[
object,
2011-08-23 14:07:02 +02:00
uuid(8f672000-bab9-4c60-aaaf-2673c4e2a4c6),
local
]
interface nsIPluginInstance : nsIAudioChannelAgentCallback
{
nsresult GetDOMElement(nsIDOMElement **aDOMElement);
}
[
object,
2015-08-11 15:11:35 +02:00
uuid(11afa8be-d997-4e07-a6a3-6f872ec3ee7f),
local
]
interface nsIGlobalObject : nsISupports
{
}
[
object,
uuid(3eedba38-8d22-41e1-817a-0e43e165b664),
local
]
interface nsIScriptObjectPrincipal : nsISupports
{
nsIPrincipal* /* thiscall */ GetPrincipal();
}
[
object,
2015-08-11 15:11:35 +02:00
uuid(6f54214c-7175-498d-9d2d-0429e38c2869),
local
]
interface nsIXMLHttpRequest : nsISupports
{
nsresult GetChannel(nsIChannel **aChannel);
nsresult GetResponseXML(nsIDOMDocument **aResponseXML);
nsresult GetResponseText(nsAString *aResponseText);
nsresult GetResponseType(nsAString *aResponseType);
nsresult SetResponseType(const nsAString *aResponseType);
nsresult GetResponse(JSContext*cx, int /*JS::MutableHandleValue*/ aResponse);
nsresult GetStatus(uint32_t *aStatus);
nsresult GetStatusText(nsACString *aStatusText);
nsresult SlowAbort();
nsresult GetAllResponseHeaders(nsACString *_retval);
nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
nsresult Open(const nsACString *method, const nsACString *url, bool async, const nsAString *user, const nsAString *password, uint8_t _argc);
nsresult Send(nsIVariant *body);
nsresult SetRequestHeader(const nsACString *header, const nsACString *value);
nsresult GetTimeout(uint32_t *aTimeout);
nsresult SetTimeout(uint32_t aTimeout);
nsresult GetReadyState(uint16_t *aReadyState);
nsresult SlowOverrideMimeType(const nsAString *mimetype);
nsresult GetMozBackgroundRequest(bool *aMozBackgroundRequest);
nsresult SetMozBackgroundRequest(bool aMozBackgroundRequest);
nsresult GetWithCredentials(bool *aWithCredentials);
nsresult SetWithCredentials(bool aWithCredentials);
2015-08-11 15:11:35 +02:00
nsresult Init(nsIPrincipal *principal, nsIScriptContext *scriptContext, nsIGlobalObject *globalObject, nsIURI *baseURI, nsILoadGroup *loadGroup);
nsresult GetUpload(nsIXMLHttpRequestUpload **aUpload);
nsresult GetOnreadystatechange(JSContext*cx, int /*JS::MutableHandleValue*/ aOnreadystatechange);
nsresult SetOnreadystatechange(JSContext*cx, int /*JS::HandleValue*/ aOnreadystatechange);
nsresult GetMozAnon(bool *aMozAnon);
nsresult GetMozSystem(bool *aMozSystem);
}
cpp_quote("DEFINE_GUID(IID_nsCycleCollectionISupports, 0xc61eac14,0x5f7a,0x4481,0x96,0x5e,0x7e,0xaa,0x6e,0xff,0xa8,0x5f);")