nsiface.idl 135 KB
Newer Older
1
/*
2
 * Copyright 2005-2011 Jacek Caban for CodeWeavers
3 4 5 6 7 8 9 10 11 12 13 14 15
 *
 * 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
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 18
 */

19
/*
20
 * NOTE:
21 22 23
 * 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.
24 25
 */

26
cpp_quote("#define GECKO_VERSION \"1.5\"")
27
cpp_quote("#define GECKO_VERSION_STRING \"Wine Gecko \" GECKO_VERSION")
28

29 30
import "wtypes.idl";

31 32 33 34 35
cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
cpp_quote("#undef GetForm")
cpp_quote("#undef SetPort")
cpp_quote("#endif")

36 37 38
typedef HRESULT nsresult;
typedef ULONG nsrefcnt;

39
typedef IID nsID;
40 41 42 43 44 45 46 47
typedef IID nsIID;
typedef nsIID nsCID;
typedef REFIID nsIIDRef;
typedef nsIIDRef nsCIDRef;

typedef WCHAR PRUnichar;
typedef ULONG PRUint32;
typedef LONG PRInt32;
48
typedef WORD PRUint16;
49
typedef INT16 PRInt16;
50
typedef BYTE PRUint8;
51 52
typedef LONGLONG PRInt64;
typedef ULONGLONG PRUint64;
53
typedef PRUint64 DOMTimeStamp;
54
typedef PRUint32 nsLoadFlags;
55

56 57
typedef unsigned char cpp_bool;
#define bool cpp_bool
58

59 60 61 62 63 64 65
typedef struct {
    void *v;
    void *d1;
    PRUint32 d2;
    void *d3;
} nsCStringContainer;

66 67 68 69 70 71 72
typedef struct {
    void *v;
    void *d1;
    PRUint32 d2;
    void *d3;
} nsStringContainer;

73
typedef nsCStringContainer nsACString;
74 75
typedef nsStringContainer nsAString;

76
interface nsIWebBrowserChrome;
77
interface nsILoadGroup;
78
interface nsIDOMNode;
79
interface nsIDOMDocument;
80
interface nsIDOMEvent;
81 82 83 84 85 86 87 88 89
interface nsIEditor;
interface nsISelectionController;
interface nsITransactionManager;
interface nsITransaction;
interface nsIInlineSpellChecker;
interface nsIOutputStream;
interface nsIEditorObserver;
interface nsIEditActionListener;
interface nsIDocumentStateListener;
90
interface nsIDOMCSSStyleSheet;
91
interface nsIDOMDocumentView;
92
interface nsIDOMWindow;
93
interface nsIDOMElement;
94
interface nsIDOMRange;
95 96
interface nsIDOMEventTarget;
interface nsISelection;
97
interface nsIDOMHTMLSelectElement;
98

99 100
interface IMoniker;

101 102
[
    object,
103 104
    uuid(00000000-0000-0000-c000-000000000046),
    local
105 106 107
]
interface nsISupports
{
108
    nsresult QueryInterface(nsIIDRef riid, void **result);
109 110 111 112 113 114 115
    nsrefcnt AddRef();
    nsrefcnt Release();
}

/* Currently we don't need a full declaration of these interfaces */
typedef nsISupports nsISHistory;
typedef nsISupports nsIWidget;
116
typedef nsISupports nsIDOMBarProp;
117 118
typedef nsISupports nsIPrompt;
typedef nsISupports nsIAuthPrompt;
119 120 121 122 123
typedef nsISupports nsIDOMDocumentType;
typedef nsISupports nsIDOMDOMImplementation;
typedef nsISupports nsIDOMCDATASection;
typedef nsISupports nsIDOMProcessingInstruction;
typedef nsISupports nsIDOMEntityReference;
124
typedef nsISupports nsIWebProgressListener;
125
typedef nsISupports nsIDOMCSSValue;
126
typedef nsISupports nsIPrintSession;
127
typedef nsISupports nsIControllerCommandTable;
128 129
typedef nsISupports nsIPrincipal;
typedef nsISupports nsIAtom;
130 131
typedef nsISupports nsISupportsArray;
typedef nsISupports nsIContentFilter;
132
typedef nsISupports nsIDOMMediaList;
133 134
typedef nsISupports nsIDOMHTMLTableCaptionElement;
typedef nsISupports nsIDOMHTMLTableSectionElement;
135 136 137 138
typedef nsISupports nsIDOMClientRectList;
typedef nsISupports nsINode;
typedef nsISupports nsIStyleSheet;
typedef nsISupports nsIStyleRule;
139
typedef nsISupports nsIDOMUserDataHandler;
140 141 142 143 144 145 146 147
typedef nsISupports nsIDocShellLoadInfo;
typedef nsISupports nsISHEntry;
typedef nsISupports nsIPresShell;
typedef nsISupports nsIContentViewer;
typedef nsISupports nsIDocumentCharsetInfo;
typedef nsISupports nsILayoutHistoryState;
typedef nsISupports nsISecureBrowserUI;
typedef nsISupports nsIDOMStorage;
148 149 150 151 152
typedef nsISupports nsIDOMDOMTokenList;
typedef nsISupports nsITransferable;
typedef nsISupports nsIDOMHTMLHeadElement;
typedef nsISupports nsIDOMFileList;
typedef nsISupports nsIControllers;
153
typedef nsISupports nsIDOMValidityState;
154 155
typedef nsISupports nsIPluginInstanceOwner;
typedef nsISupports nsIPluginStreamListener;
156 157 158
typedef nsISupports nsIContentSink;
typedef nsISupports nsIParserFilter;
typedef nsISupports nsIDTD;
159
typedef nsISupports nsIObserver;
160 161 162 163 164
typedef nsISupports nsIDOMNodeFilter;
typedef nsISupports nsIDOMNodeIterator;
typedef nsISupports nsIDOMTreeWalker;
typedef nsISupports nsIHttpUpgradeListener;
typedef nsISupports nsIDOMDOMStringMap;
165 166 167 168 169 170 171 172 173 174 175 176 177 178
typedef nsISupports nsIDOMDOMStringList;
typedef nsISupports nsIDOMOfflineResourceList;
typedef nsISupports nsIDOMHistory;
typedef nsISupports nsIDOMNavigator;
typedef nsISupports nsIDOMMediaQueryList;
typedef nsISupports nsIDOMScreen;
typedef nsISupports nsIDOMCrypto;
typedef nsISupports nsIDOMPkcs11;
typedef nsISupports nsIAnimationFrameListener;
typedef nsISupports nsIDOMMozURLProperty;
typedef nsISupports nsIDOMStorageList;
typedef nsISupports nsILocalFile;
typedef nsISupports nsIDOMHTMLMenuElement;
typedef nsISupports nsIDOMCaretPosition;
179
typedef nsISupports nsIFrameRequestCallback;
180 181 182

typedef void *JSContext;
typedef void *JSObject;
183
typedef PRUint64 jsval;
184 185 186

[
    object,
187 188
    uuid(8bb35ed9-e332-462d-9155-4a002ab5c958),
    local
189 190 191 192
]
interface nsIServiceManager : nsISupports
{
    nsresult GetService(nsCIDRef aClass, nsIIDRef aIID, void **result);
Jacek Caban's avatar
Jacek Caban committed
193
    nsresult GetServiceByContractID(const char *aContractID, nsIIDRef aIID, void **result);
194
    nsresult IsServiceInstantiated(nsCIDRef aClass, nsIIDRef aIID, BOOL *_retval);
195
    nsresult IsServiceInstantiatedByContractID(const char *aContractID, nsIIDRef aIID, BOOL *_retval);
196 197
}

198 199
[
    object,
200 201
    uuid(00000001-0000-0000-c000-000000000046),
    local
202 203 204 205
]
interface nsIFactory : nsISupports
{
    nsresult CreateInstance(nsISupports *aOuter, const nsIID *iid, void **result);
206
    nsresult LockFactory(bool lock);
207 208
}

209 210
[
    object,
211
    uuid(1d940426-5fe5-42c3-84ae-a300f2d9ebd5),
212
    local
213 214 215
]
interface nsIComponentManager : nsISupports
{
216 217
    nsresult GetClassObject(nsCIDRef aClass, nsIIDRef aIID, void **result);
    nsresult GetClassObjectByContractID(const char *aContractID, nsIIDRef aIID, void **result);
218
    nsresult CreateInstance(nsCIDRef aClass, nsISupports *aDelegate, nsIIDRef aIID,
219
            void **result);
220
    nsresult CreateInstanceByContractID(const char *aContractID, nsISupports *aDelegate,
221
            nsIIDRef aIID, void **result);
222 223
    nsresult AddBootstrappedManifestLocation(nsILocalFile *aLocation);
    nsresult RemoveBootstrappedManifestLocation(nsILocalFile *aLocation);
224 225
}

226 227
[
    object,
228 229
    uuid(59e7e77a-38e4-11d4-8cf5-0060b0fc14a3),
    local
230 231 232 233 234 235
]
interface nsIMemory : nsISupports
{
    void *Alloc(/*size_t*/ int size);
    void *Realloc(void *_ptr, /*size_t*/ int newSize);
    void Free(void *_ptr);
236 237
    nsresult HeapMinimize(bool immediate);
    nsresult IsLowMemory(bool *_retval);
238 239 240 241
}

[
    object,
242 243
    uuid(9188bc85-f92e-11d2-81ef-0060083a0bcf),
    local
244 245 246 247 248 249 250 251
]
interface nsIWeakReference : nsISupports
{
    nsresult QueryReferent(const nsIID *riid, void **result);
}

[
    object,
252 253
    uuid(9188bc86-f92e-11d2-81ef-0060083a0bcf),
    local
254 255 256 257 258 259
]
interface nsISupportsWeakReference : nsISupports
{
    nsresult GetWeakReference(nsIWeakReference **_retval);
}

260 261
[
    object,
262 263
    uuid(033a1470-8b2a-11d3-af88-00a024ffc08c),
    local
264 265 266 267 268 269
]
interface nsIInterfaceRequestor : nsISupports
{
    nsresult GetInterface(const nsIID *riid, void **result);
}

270 271 272 273 274 275 276 277 278 279
[
    object,
    uuid(4a2abaf0-6886-11d3-9382-00104ba0fd40),
    local
]
interface nsIRunnable : nsISupports
{
    nsresult Run();
}

280 281
[
    object,
282 283
    uuid(d1899240-f9d2-11d2-bdd6-000064657374),
    local
284 285 286
]
interface nsISimpleEnumerator : nsISupports
{
287
    nsresult HasMoreElements(bool *_retval);
288 289 290
    nsresult GetNext(nsISupports **_retval);
}

291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
[
    object,
    uuid(81e4c2de-acac-4ad6-901a-b5fb1b851a0d),
    local
]
interface nsIVariant : nsISupports
{
    nsresult GetDataType(PRUint16 *aDataType);
    nsresult GetAsInt8(PRUint8 *_retval);
    nsresult GetAsInt16(PRInt16 *_retval);
    nsresult GetAsInt32(PRInt32 *_retval);
    nsresult GetAsInt64(PRInt64 *_retval);
    nsresult GetAsUint8(PRUint8 *_retval);
    nsresult GetAsUint16(PRUint16 *_retval);
    nsresult GetAsUint32(PRUint32 *_retval);
    nsresult GetAsUint64(PRUint64 *_retval);
    nsresult GetAsFloat(float *_retval);
    nsresult GetAsDouble(double *_retval);
309
    nsresult GetAsBool(bool *_retval);
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
    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(PRUint16 *type, nsIID *iid, PRUint32 *count, void **ptr);
    nsresult GetAsStringWithSize(PRUint32 *size, char **str);
    nsresult GetAsWStringWithSize(PRUint32 *size, PRUnichar **str);
}

[
    object,
    uuid(5586a590-8c82-11d5-90f3-0010a4e73d9a),
    local
]
interface nsIWritableVariant : nsIVariant
{
334 335
    nsresult GetWritable(bool *aWritable);
    nsresult SetWritable(bool aWritable);
336 337 338 339 340 341 342 343 344 345
    nsresult SetAsInt8(PRUint8 aValue);
    nsresult SetAsInt16(PRInt16 aValue);
    nsresult SetAsInt32(PRInt32 aValue);
    nsresult SetAsInt64(PRInt64 aValue);
    nsresult SetAsUint8(PRUint8 aValue);
    nsresult SetAsUint16(PRUint16 aValue);
    nsresult SetAsUint32(PRUint32 aValue);
    nsresult SetAsUint64(PRUint64 aValue);
    nsresult SetAsFloat(float aValue);
    nsresult SetAsDouble(double aValue);
346
    nsresult SetAsBool(bool aValue);
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
    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(PRUint16 type, const nsIID *iid, PRUint32 count, void *ptr);
    nsresult SetAsStringWithSize(PRUint32 size, const char *str);
    nsresult SetAsWStringWithSize(PRUint32 size, const PRUnichar *str);
    nsresult SetAsVoid();
    nsresult SetAsEmpty();
    nsresult SetAsEmptyArray();
    nsresult SetFromVariant(nsIVariant *aValue);
}

367 368
[
    object,
369 370
    uuid(fa9c7f6c-61b3-11d4-9877-00c04fa0cf4a),
    local
371 372 373 374 375 376
]
interface nsIInputStream : nsISupports
{
    nsresult Close();
    nsresult Available(PRUint32 *_retval);
    nsresult Read(char *aBuf, PRUint32 aCount, PRUint32 *_retval);
377
    nsresult ReadSegments(nsresult (*aWriter)(nsIInputStream *aInStream,
378 379 380
            void *aClosure, const char *aFromSegment, PRUint32 aToOffset,
            PRUint32 aCount, PRUint32 *aWriteCount),
            void *aClosure, PRUint32 aCount, PRUint32 *_retval);
381
    nsresult IsNonBlocking(bool *_retval);
382 383
}

384 385
[
    object,
386
    uuid(395fe045-7d18-4adb-a3fd-af98c8a1af11),
387
    local
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
]
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(PRInt32 *aPort);
    nsresult SetPort(PRInt32 aPort);
    nsresult GetPath(nsACString *aPath);
    nsresult SetPath(const nsACString *aPath);
410 411
    nsresult Equals(nsIURI *other, bool *_retval);
    nsresult SchemeIs(const char *scheme, bool *_retval);
412 413 414 415 416
    nsresult Clone(nsIURI **_retval);
    nsresult Resolve(const nsACString *relativePath, nsACString *_retval);
    nsresult GetAsciiSpec(nsACString *aAsciiSpec);
    nsresult GetAsciiHost(nsACString *aAsciiHost);
    nsresult GetOriginCharset(nsACString *aOriginCharset);
417 418
    nsresult GetRef(nsACString *aRef);
    nsresult SetRef(const nsACString *aRef);
419
    nsresult EqualsExceptRef(nsIURI *other, bool *_retval);
420 421
    nsresult CloneIgnoringRef(nsIURI **_retval);
    nsresult GetSpecIgnoringRef(nsACString *aSpecIgnoringRef);
422
    nsresult GetHasRef(bool *aHasRef);
423 424
}

425 426
[
    object,
427
    uuid(1419aa16-f134-4154-9886-00c7c5147a13),
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
    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);
}

448 449 450 451 452 453 454
[
    object,
    uuid(321578d0-03c1-4d95-8821-021ac612d18d),
    local
]
interface nsIMutable : nsISupports
{
455 456
    nsresult GetMutable(bool *aMutable);
    nsresult SetMutable(bool aMutable);
457 458 459 460 461 462 463 464 465 466 467 468
}

[
    object,
    uuid(babd6cca-ebe7-4329-967c-d6b9e33caa81),
    local
]
interface nsIStandardURL : nsIMutable
{
    nsresult Init(PRUint32 aUrlType, PRInt32 aDefaultPort, const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI);
}

469 470
[
    object,
471 472
    uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe),
    local
473 474 475 476
]
interface nsIRequest : nsISupports
{
    nsresult GetName(nsACString *aName);
477
    nsresult IsPending(bool *_retval);
478 479 480 481 482 483 484 485 486 487
    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);
}

488 489
[
    object,
490 491
    uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40),
    local
492 493 494 495 496 497 498 499 500
]
interface nsIRequestObserver : nsISupports
{
    nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext);
    nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode);
}

[
    object,
501 502
    uuid(1a637020-1482-11d3-9333-00104ba0fd40),
    local
503
]
504 505 506 507 508 509
interface nsIStreamListener : nsIRequestObserver
{
    nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
                             nsIInputStream *aInputStream, PRUint32 aOffset, PRUint32 aCount);
}

510 511
[
    object,
512 513
    uuid(3de0a31c-feaf-400f-9f1e-4ef71f8b20cc),
    local
514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
]
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(PRUint32 *aActiveCount);
    nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
    nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
}

529 530
[
    object,
531
    uuid(06f6ada3-7729-4e72-8d3f-bf8ba630ff9b),
532
    local
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
]
interface nsIChannel : nsIRequest
{
    nsresult GetOriginalURI(nsIURI **aOriginalURI);
    nsresult SetOriginalURI(nsIURI *aOriginalURI);
    nsresult GetURI(nsIURI **aURI);
    nsresult GetOwner(nsISupports **aOwner);
    nsresult SetOwner(nsISupports *aOwner);
    nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
    nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
    nsresult GetSecurityInfo(nsISupports **aSecurityInfo);
    nsresult GetContentType(nsACString *aContentType);
    nsresult SetContentType(const nsACString *aContentType);
    nsresult GetContentCharset(nsACString *aContentCharset);
    nsresult SetContentCharset(const nsACString *aContentCharset);
    nsresult GetContentLength(PRInt32 *aContentLength);
    nsresult SetContentLength(PRInt32 aContentLength);
    nsresult Open(nsIInputStream **_retval);
    nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext);
552 553 554
    nsresult GetContentDisposition(PRUint32 *aContentDisposition);
    nsresult GetContentDispositionFilename(nsAString *aContentDispositionFilename);
    nsresult GetContentDispositionHeader(nsACString *aContentDispositionHeader);
555 556
}

557 558
[
    object,
559
    uuid(35412859-b9d9-423c-8866-2d4559fdd2be),
560 561 562 563 564 565 566
    local
]
interface nsIHttpHeaderVisitor : nsISupports
{
    nsresult VisitHeader(const nsACString *aHeader, const nsACString *aValue);
}

567 568
[
    object,
569 570
    uuid(9277fe09-f0cc-4cd9-bbce-581dd94b0260),
    local
571 572 573 574 575 576 577 578
]
interface nsIHttpChannel : nsIChannel
{
    nsresult GetRequestMethod(nsACString *aRequestMethod);
    nsresult SetRequestMethod(const nsACString *aRequestMethod);
    nsresult GetReferrer(nsIURI **aReferrer);
    nsresult SetReferrer(nsIURI *aReferrer);
    nsresult GetRequestHeader(const nsACString *aHeader, nsACString *_retval);
579
    nsresult SetRequestHeader(const nsACString *aHeader, const nsACString *aValue, bool aMerge);
580
    nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
581 582
    nsresult GetAllowPipelining(bool *aAllowPipelining);
    nsresult SetAllowPipelining(bool aAllowPipelining);
583 584 585 586
    nsresult GetRedirectionLimit(PRUint32 *aRedirectionLimit);
    nsresult SetRedirectionLimit(PRUint32 aRedirectionLimit);
    nsresult GetResponseStatus(PRUint32 *aResponseStatus);
    nsresult GetResponseStatusText(nsACString *aResponseStatusText);
587
    nsresult GetRequestSucceeded(bool *aRequestSucceeded);
588
    nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
589
    nsresult SetResponseHeader(const nsACString *header, const nsACString *value, bool merge);
590
    nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor);
591 592
    nsresult IsNoStoreResponse(bool *_retval);
    nsresult IsNoCacheResponse(bool *_retval);
593 594
}

595 596
[
    object,
597
    uuid(9363fd96-af59-47e8-bddf-1d5e91acd336),
598 599 600 601 602 603 604 605 606 607
    local
]
interface nsIHttpChannelInternal : nsISupports
{
    nsresult GetDocumentURI(nsIURI **aDocumentURI);
    nsresult SetDocumentURI(nsIURI *aDocumentURI);
    nsresult GetRequestVersion(PRUint32 *major, PRUint32 *minor);
    nsresult GetResponseVersion(PRUint32 *major, PRUint32 *minor);
    nsresult SetCookie(const char *aCookieHeader);
    nsresult SetupFallbackChannel(const char *aFallbackKey);
608 609 610 611 612
    nsresult GetForceAllowThirdPartyCookie(bool *aForceAllowThirdPartyCookie);
    nsresult SetForceAllowThirdPartyCookie(bool aForceAllowThirdPartyCookie);
    nsresult GetCanceled(bool *aCanceled);
    nsresult GetChannelIsForDownload(bool *aChannelIsForDownload);
    nsresult SetChannelIsForDownload(bool aChannelIsForDownload);
613 614 615 616 617 618
    nsresult GetLocalAddress(nsACString *aLocalAddress);
    nsresult GetLocalPort(PRInt32 *aLocalPort);
    nsresult GetRemoteAddress(nsACString *aRemoteAddress);
    nsresult GetRemotePort(PRInt32 *aRemotePort);
    nsresult SetCacheKeysRedirectChain(void /*nsTArray<nsCString>*/ *cacheKeys);
    nsresult HTTPUpgrade(const nsACString *aProtocolName, nsIHttpUpgradeListener *aListener);
619 620
    nsresult GetAllowSpdy(bool *aAllowSpdy);
    nsresult SetAllowSpdy(bool aAllowSpdy);
621 622
}

623 624
[
    object,
625 626
    uuid(ddf633d8-e9a4-439d-ad88-de636fd9bb75),
    local
627 628 629 630 631 632 633 634
]
interface nsIUploadChannel : nsISupports
{
    nsresult SetUploadStream(nsIInputStream *aStream, const nsACString *aContentType,
                             PRInt32 aContentLength);
    nsresult GetUploadStream(nsIInputStream **aUploadStream);
}

635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
[
    object,
    uuid(8d171460-a716-41f1-92be-8c659db39b45),
    local
]
interface nsIAsyncVerifyRedirectCallback : nsISupports
{
    nsresult OnRedirectVerifyCallback(nsresult result);
}

[
    object,
    uuid(a430d870-df77-4502-9570-d46a8de33154),
    local
]
interface nsIChannelEventSink : nsISupports
{
    cpp_quote("#define REDIRECT_TEMPORARY 1")
    cpp_quote("#define REDIRECT_PERMANENT 2")
    cpp_quote("#define REDIRECT_INTERNAL  4")

    nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, PRUint32 flags,
                                    nsIAsyncVerifyRedirectCallback *callback);
}

660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
[
    object,
    uuid(a6cf906d-15b3-11d2-932e-00805f8add32),
    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);
683
    nsresult Reload(bool forceget);
684 685 686 687 688
    nsresult Replace(const nsAString *url);
    nsresult Assign(const nsAString *url);
    nsresult ToString(nsAString *_retval);
}

689 690
[
    object,
691
    uuid(2938307a-9d70-4b63-8afc-0197e82318ad),
692
    local
693 694 695 696 697 698 699 700 701 702
]
interface nsIDOMCSSRule : nsISupports
{
    nsresult GetType(PRUint16 *aType);
    nsresult GetCssText(nsAString *aCssText);
    nsresult SetCssText(const nsAString *aCssText);
    nsresult GetParentStyleSheet(nsIDOMCSSStyleSheet **aParentStyleSheet);
    nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
}

703 704
[
    object,
705 706
    uuid(a6cf90be-15b3-11d2-932e-00805f8add32),
    local
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
]
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(PRUint32 *aLength);
    nsresult Item(PRUint32 index, nsAString *_retval);
    nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
}

723 724
[
    object,
725 726
    uuid(a6cf90c0-15b3-11d2-932e-00805f8add32),
    local
727 728 729 730 731 732 733
]
interface nsIDOMCSSRuleList : nsISupports
{
    nsresult GetLength(PRUint32 *aLength);
    nsresult Item(PRUint32 index, nsIDOMCSSRule **_retval);
}

734 735
[
    object,
736 737
    uuid(a6cf9080-15b3-11d2-932e-00805f8add32),
    local
738 739 740 741
]
interface nsIDOMStyleSheet : nsISupports
{
    nsresult GetType(nsAString *aType);
742 743
    nsresult GetDisabled(bool *aDisabled);
    nsresult SetDisabled(bool aDisabled);
744 745 746 747 748 749 750 751 752
    nsresult GetOwnerNode(nsIDOMNode **aOwnerNode);
    nsresult GetParentStyleSheet(nsIDOMStyleSheet **aParentStyleSheet);
    nsresult GetHref(nsAString *aHref);
    nsresult GetTitle(nsAString *aTitle);
    nsresult GetMedia(nsIDOMMediaList **aMedia);
}

[
    object,
753 754
    uuid(a6cf90c2-15b3-11d2-932e-00805f8add32),
    local
755 756 757 758 759 760 761 762 763
]
interface nsIDOMCSSStyleSheet : nsIDOMStyleSheet
{
    nsresult GetOwnerRule(nsIDOMCSSRule **aOwnerRule);
    nsresult GetCssRules(nsIDOMCSSRuleList **aCssRules);
    nsresult InsertRule(const nsAString *rule, PRUint32 index, PRUint32 *_retval);
    nsresult DeleteRule(PRUint32 index);
}

764 765
[
    object,
766 767
    uuid(a6cf9081-15b3-11d2-932e-00805f8add32),
    local
768 769 770 771 772 773 774
]
interface nsIDOMStyleSheetList : nsISupports
{
    nsresult GetLength(PRUint32 *aLength);
    nsresult Item(PRUint32 index, nsIDOMStyleSheet **_retval);
}

775 776
[
    object,
777
    uuid(496852ba-e48d-4fa5-982e-e0dc1b475bf1),
778
    local
779 780 781 782 783
]
interface nsIDOMNodeList : nsISupports
{
    nsresult Item(PRUint32 index, nsIDOMNode **_retval);
    nsresult GetLength(PRUint32 *aLength);
784
    /* Followed by semi-internal API that we don't want to use */
785 786
}

787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
[
    object,
    uuid(a6cf907b-15b3-11d2-932e-00805f8add32),
    local
]
interface nsIDOMNamedNodeMap : nsISupports
{
    nsresult GetNamedItem(const nsAString *name, nsIDOMNode **_retval);
    nsresult SetNamedItem(nsIDOMNode *arg, nsIDOMNode **_retval);
    nsresult RemoveNamedItem(const nsAString *name, nsIDOMNode **_retval);
    nsresult Item(PRUint32 index, nsIDOMNode **_retval);
    nsresult GetLength(PRUint32 *aLength);
    nsresult GetNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMNode **_retval);
    nsresult SetNamedItemNS(nsIDOMNode *arg, nsIDOMNode **_retval);
    nsresult RemoveNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMNode **_retval);
}

804 805
[
    object,
806
    uuid(ce82fb71-60f2-4c38-be31-de5f2f90dada),
807
    local
808 809 810
]
interface nsIDOMNode : nsISupports
{
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825
    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
    };

826 827 828 829 830 831 832 833 834
    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
    };

835 836 837 838 839
    nsresult GetNodeName(nsAString *aNodeName);
    nsresult GetNodeValue(nsAString *aNodeValue);
    nsresult SetNodeValue(const nsAString *aNodeValue);
    nsresult GetNodeType(PRUint16 *aNodeType);
    nsresult GetParentNode(nsIDOMNode **aParentNode);
840
    nsresult GetParentElement(nsIDOMElement **aParentElement);
841 842 843 844 845 846 847 848 849 850 851
    nsresult GetChildNodes(nsIDOMNodeList **aChildNodes);
    nsresult GetFirstChild(nsIDOMNode **aFirstChild);
    nsresult GetLastChild(nsIDOMNode **aLastChild);
    nsresult GetPreviousSibling(nsIDOMNode **aPreviousSibling);
    nsresult GetNextSibling(nsIDOMNode **aNextSibling);
    nsresult GetAttributes(nsIDOMNamedNodeMap **aAttributes);
    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);
852 853
    nsresult HasChildNodes(bool *_retval);
    nsresult CloneNode(bool deep, nsIDOMNode **_retval);
854
    nsresult Normalize();
855
    nsresult IsSupported(const nsAString *feature, const nsAString *version, bool *_retval);
856 857 858
    nsresult GetNamespaceURI(nsAString *aNamespaceURI);
    nsresult GetPrefix(nsAString *aPrefix);
    nsresult GetLocalName(nsAString *aLocalName);
859
    nsresult HasAttributes(bool *_retval);
860 861 862 863 864
    nsresult GetDOMBaseURI(nsAString *aBaseURI);
    nsresult CompareDocumentPosition(nsIDOMNode *other, PRUint16 *_retval);
    nsresult GetTextContent(nsAString *aTextContent);
    nsresult SetTextContent(const nsAString *aTextContent);
    nsresult LookupPrefix(const nsAString *namespaceURI, nsAString *_retval);
865
    nsresult IsDefaultNamespace(const nsAString *namespaceURI, bool *_retval);
866
    nsresult LookupNamespaceURI(const nsAString *prefix, nsAString *_retval);
867
    nsresult IsEqualNode(nsIDOMNode *arg, bool *_retval);
868 869
    nsresult SetUserData(const nsAString *key, nsIVariant *data, nsIDOMUserDataHandler *handler, nsIVariant **_retval);
    nsresult GetUserData(const nsAString *key, nsIVariant **_retval);
870
    nsresult Contains(nsIDOMNode *aOther, bool *_retval);
871 872
}

873 874
[
    object,
875
    uuid(03da4bc9-1b9a-41dc-a1a4-32414d48d704),
876 877 878 879 880
    local
]
interface nsIDOMAttr : nsIDOMNode
{
    nsresult GetName(nsAString *aName);
881
    nsresult GetSpecified(bool *aSpecified);
882 883 884
    nsresult GetValue(nsAString *aValue);
    nsresult SetValue(const nsAString *aValue);
    nsresult GetOwnerElement(nsIDOMElement **aOwnerElement);
885
    nsresult GetIsId(bool *aIsId);
886 887
}

888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
[
    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);
}

903 904
[
    object,
905
    uuid(f561753a-1d4f-40c1-b147-ea955fc6fd94),
906 907
    local
]
908
interface nsIDOMElement : nsIDOMNode
909
{
910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
    nsresult GetTagName(nsAString *aTagName);
    nsresult GetClassList(nsIDOMDOMTokenList **aClassList);
    nsresult GetAttribute(const nsAString *name, nsAString *_retval);
    nsresult GetAttributeNS(const nsAString *namespaceURI, const nsAString *localName, nsAString *_retval);
    nsresult SetAttribute(const nsAString *name, const nsAString *value);
    nsresult SetAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName, const nsAString *value);
    nsresult RemoveAttribute(const nsAString *name);
    nsresult RemoveAttributeNS(const nsAString *namespaceURI, const nsAString *localName);
    nsresult HasAttribute(const nsAString *name, bool *_retval);
    nsresult HasAttributeNS(const nsAString *namespaceURI, const nsAString *localName, bool *_retval);
    nsresult GetAttributeNode(const nsAString *name, nsIDOMAttr **_retval);
    nsresult SetAttributeNode(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
    nsresult RemoveAttributeNode(nsIDOMAttr *oldAttr, nsIDOMAttr **_retval);
    nsresult GetAttributeNodeNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMAttr **_retval);
    nsresult SetAttributeNodeNS(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
    nsresult GetElementsByTagName(const nsAString *name, nsIDOMNodeList **_retval);
    nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMNodeList **_retval);
927
    nsresult GetElementsByClassName(const nsAString *classes, nsIDOMNodeList **_retval);
928 929 930 931 932 933 934 935 936 937
    nsresult GetChildElements(nsIDOMNodeList **aChildren);
    nsresult GetFirstElementChild(nsIDOMElement **aFirstElementChild);
    nsresult GetLastElementChild(nsIDOMElement **aLastElementChild);
    nsresult GetPreviousElementSibling(nsIDOMElement **aPreviousElementSibling);
    nsresult GetNextElementSibling(nsIDOMElement **aNextElementSibling);
    nsresult GetChildElementCount(PRUint32 *aChildElementCount);
    nsresult GetOnmouseenter(JSContext *cx, jsval *aOnmouseenter);
    nsresult SetOnmouseenter(JSContext *cx, const jsval *aOnmouseenter);
    nsresult GetOnmouseleave(JSContext *cx, jsval *aOnmouseleave);
    nsresult SetOnmouseleave(JSContext *cx, const jsval *aOnmouseleave);
938 939 940 941 942 943 944
    nsresult GetClientRects(nsIDOMClientRectList **_retval);
    nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
    nsresult GetScrollTop(PRInt32 *aScrollTop);
    nsresult SetScrollTop(PRInt32 aScrollTop);
    nsresult GetScrollLeft(PRInt32 *aScrollLeft);
    nsresult SetScrollLeft(PRInt32 aScrollLeft);
    nsresult GetScrollWidth(PRInt32 *aScrollWidth);
945
    nsresult GetScrollHeight(PRInt32 *aScrollHeight);
946 947 948
    nsresult GetClientTop(PRInt32 *aClientTop);
    nsresult GetClientLeft(PRInt32 *aClientLeft);
    nsresult GetClientWidth(PRInt32 *aClientWidth);
949 950 951
    nsresult GetClientHeight(PRInt32 *aClientHeight);
    nsresult MozMatchesSelector(const nsAString *selector, bool *_retval);
    nsresult SetCapture(bool retargetToElement);
952
    nsresult ReleaseCapture();
953 954 955 956 957 958 959 960 961 962
}

[
    object,
    uuid(99715845-95fc-4a56-aa53-214b65c26e22),
    local
]
interface nsIDOMElementCSSInlineStyle : nsISupports
{
    nsresult GetStyle(nsIDOMCSSStyleDeclaration **aStyle);
963 964
}

965
cpp_quote("#undef GetClassName")
966 967 968

[
    object,
969
    uuid(3de9f8c1-5d76-4d2e-b6b9-334c6eb0c113),
970
    local
971 972 973 974 975 976 977 978 979 980 981 982 983
]
interface nsIDOMHTMLElement : nsIDOMElement
{
    nsresult GetId(nsAString *aId);
    nsresult SetId(const nsAString *aId);
    nsresult GetTitle(nsAString *aTitle);
    nsresult SetTitle(const nsAString *aTitle);
    nsresult GetLang(nsAString *aLang);
    nsresult SetLang(const nsAString *aLang);
    nsresult GetDir(nsAString *aDir);
    nsresult SetDir(const nsAString *aDir);
    nsresult GetClassName(nsAString *aClassName);
    nsresult SetClassName(const nsAString *aClassName);
984
    nsresult GetDataset(nsIDOMDOMStringMap **aDataset);
985 986
    nsresult GetHidden(bool *aHidden);
    nsresult SetHidden(bool aHidden);
987
    nsresult Click();
988 989
    nsresult GetTabIndex(PRInt32 *aTabIndex);
    nsresult SetTabIndex(PRInt32 aTabIndex);
990 991 992 993 994
    nsresult Focus();
    nsresult Blur();
    nsresult GetAccessKey(nsAString *aAccessKey);
    nsresult SetAccessKey(const nsAString *aAccessKey);
    nsresult GetAccessKeyLabel(nsAString *aAccessKeyLabel);
995 996
    nsresult GetDraggable(bool *aDraggable);
    nsresult SetDraggable(bool aDraggable);
997 998
    nsresult GetContentEditable(nsAString *aContentEditable);
    nsresult SetContentEditable(const nsAString *aContentEditable);
999
    nsresult GetIsContentEditable(bool *aIsContentEditable);
1000
    nsresult GetContextMenu(nsIDOMHTMLMenuElement **aContextMenu);
1001 1002
    nsresult GetSpellcheck(bool *aSpellcheck);
    nsresult SetSpellcheck(bool aSpellcheck);
1003 1004 1005 1006 1007
    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);
1008
    nsresult ScrollIntoView(bool top, PRUint8 _argc);
1009 1010 1011 1012 1013 1014
    nsresult GetOffsetParent(nsIDOMElement * *aOffsetParent);
    nsresult GetOffsetTop(PRInt32 *aOffsetTop);
    nsresult GetOffsetLeft(PRInt32 *aOffsetLeft);
    nsresult GetOffsetWidth(PRInt32 *aOffsetWidth);
    nsresult GetOffsetHeight(PRInt32 *aOffsetHeight);
    nsresult MozRequestFullScreen();
1015 1016
}

1017 1018
[
    object,
1019
    uuid(b7ccd7b3-86aa-4322-a50c-b972643bb662),
1020 1021 1022 1023 1024 1025 1026
    local
]
interface nsIDOMHTMLCollection : nsISupports
{
    nsresult GetLength(PRUint32 *aLength);
    nsresult Item(PRUint32 index, nsIDOMNode **_retval);
    nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
1027
    /* Followed by semi-internal API that we don't want to use */
1028 1029
}

1030 1031
[
    object,
1032
    uuid(cb75c251-afc7-444f-b2d6-b9635555f3ed),
1033
    local
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
]
interface nsIDOMCharacterData : nsIDOMNode
{
    nsresult GetData(nsAString *aData);
    nsresult SetData(const nsAString *aData);
    nsresult GetLength(PRUint32 *aLength);
    nsresult SubstringData(PRUint32 offset, PRUint32 count, nsAString *_retval);
    nsresult AppendData(const nsAString *arg);
    nsresult InsertData(PRUint32 offset, const nsAString *arg);
    nsresult DeleteData(PRUint32 offset, PRUint32 count);
    nsresult ReplaceData(PRUint32 offset, PRUint32 count, const nsAString *arg);
}

[
    object,
1049
    uuid(437ed60c-febd-4bd0-892f-cf358adc3c96),
1050
    local
1051 1052 1053 1054
]
interface nsIDOMText : nsIDOMCharacterData
{
    nsresult SplitText(PRUint32 offset, nsIDOMText **_retval);
1055
    nsresult GetWholeText(nsAString *aWholeText);
1056 1057
}

1058 1059
[
    object,
1060
    uuid(cea49a35-dac9-4c4d-9830-4660abb3b6bc),
1061
    local
1062 1063 1064 1065 1066
]
interface nsIDOMComment : nsIDOMCharacterData
{
}

1067 1068
[
    object,
1069
    uuid(4a15eb0c-d5bc-4902-9d50-21b12cab47e7),
1070
    local
1071 1072 1073 1074 1075
]
interface nsIDOMDocumentFragment : nsIDOMNode
{
}

1076 1077
[
    object,
1078
    uuid(5c3bff4d-ae7f-4c93-948c-519589672c30),
1079
    local
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
]
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);
1091
    nsresult CreateProcessingInstruction(const nsAString *target, const nsAString *data, nsIDOMProcessingInstruction **_retval);
1092 1093
    nsresult CreateAttribute(const nsAString *name, nsIDOMAttr **_retval);
    nsresult GetElementsByTagName(const nsAString *tagname, nsIDOMNodeList **_retval);
1094
    nsresult ImportNode(nsIDOMNode *importedNode, bool deep, PRUint8 _argc, nsIDOMNode **_retval);
1095 1096 1097
    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);
1098
    nsresult GetElementById(const nsAString *elementId, nsIDOMElement **_retval);
1099 1100 1101 1102 1103
    nsresult GetInputEncoding(nsAString *aInputEncoding);
    nsresult GetDocumentURI(nsAString *aDocumentURI);
    nsresult AdoptNode(nsIDOMNode *source, nsIDOMNode **_retval);
    nsresult CreateRange(nsIDOMRange **_retval);
    nsresult CreateNodeIterator(nsIDOMNode *root, PRUint32 whatToShow, nsIDOMNodeFilter *filter,
1104
            bool entityReferenceExpansion, nsIDOMNodeIterator **_retval);
1105
    nsresult CreateTreeWalker(nsIDOMNode *root, PRUint32 whatToShow, nsIDOMNodeFilter *filter,
1106
            bool entityReferenceExpansion, nsIDOMTreeWalker **_retval);
1107 1108
    cpp_quote("#undef CreateEvent")
    nsresult CreateEvent(const nsAString *eventType, nsIDOMEvent **_retval);
1109
    nsresult GetDefaultView(nsIDOMWindow **aDefaultView);
1110 1111 1112 1113 1114 1115
    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);
1116
    nsresult GetReadyState(nsAString *aReadyState);
1117 1118
    nsresult GetLastModified(nsAString *aLastModified);
    nsresult GetReferrer(nsAString *aReferrer);
1119
    nsresult HasFocus(bool *_retval);
1120 1121
    nsresult GetActiveElement(nsIDOMElement **aActiveElement);
    nsresult GetElementsByClassName(const nsAString *classes, nsIDOMNodeList **_retval);
1122 1123 1124 1125 1126 1127 1128
    nsresult GetStyleSheets(nsIDOMStyleSheetList **aStyleSheets);
    nsresult GetPreferredStyleSheetSet(nsAString *aPreferredStyleSheetSet);
    nsresult GetSelectedStyleSheetSet(nsAString *aSelectedStyleSheetSet);
    nsresult SetSelectedStyleSheetSet(const nsAString *aSelectedStyleSheetSet);
    nsresult GetLastStyleSheetSet(nsAString *aLastStyleSheetSet);
    nsresult GetStyleSheetSets(nsIDOMDOMStringList **aStyleSheetSets);
    nsresult EnableStyleSheetsForSet(const nsAString *name);
1129
    nsresult ElementFromPoint(float x, float y, nsIDOMElement **_retval);
1130
    nsresult GetContentType(nsAString *aContentType);
1131
    nsresult GetMozSyntheticDocument(bool *aMozSyntheticDocument);
1132
    nsresult GetCurrentScript(nsIDOMElement **aCurrentScript);
1133 1134
    nsresult ReleaseCapture();
    nsresult MozSetImageElement(const nsAString *aImageElementId, nsIDOMElement *aImageElement);
1135 1136
    nsresult GetMozFullScreenElement(nsIDOMHTMLElement **aMozFullScreenElement);
    nsresult MozCancelFullScreen();
1137 1138
    nsresult GetMozFullScreen(bool *aMozFullScreen);
    nsresult GetMozFullScreenEnabled(bool *aMozFullScreenEnabled);
1139 1140 1141 1142 1143 1144
    nsresult GetOnreadystatechange(JSContext* cx, jsval aOnreadystatechange);
    nsresult SetOnreadystatechange(JSContext* cx, const jsval *aOnreadystatechange);
    nsresult GetOnmouseenter(JSContext* cx, jsval *aOnmouseenter);
    nsresult SetOnmouseenter(JSContext* cx, const jsval *aOnmouseenter);
    nsresult GetOnmouseleave(JSContext* cx, jsval *aOnmouseleave) = 0;
    nsresult SetOnmouseleave(JSContext* cx, const jsval *aOnmouseleave);
1145
    nsresult GetMozHidden(bool *aMozHidden);
1146
    nsresult GetMozVisibilityState(nsAString *aMozVisibilityState);
1147 1148
}

1149 1150
[
    object,
1151
    uuid(cc1af020-6543-429c-82d7-840cda3be0b9),
1152
    local
1153 1154 1155 1156
]
interface nsIDOMHTMLDocument : nsIDOMDocument
{
    nsresult GetURL(nsAString *aURL);
1157 1158 1159 1160 1161 1162
    nsresult GetDomain(nsAString *aDomain);
    nsresult SetDomain(const nsAString *aDomain);
    nsresult GetCookie(nsAString *aCookie);
    nsresult SetCookie(const nsAString *aCookie);
    nsresult GetCompatMode(nsAString *aCompatMode);
    nsresult GetHead(nsIDOMHTMLHeadElement **aHead);
1163 1164 1165
    nsresult GetBody(nsIDOMHTMLElement **aBody);
    nsresult SetBody(nsIDOMHTMLElement *aBody);
    nsresult GetImages(nsIDOMHTMLCollection **aImages);
1166 1167
    nsresult GetEmbeds(nsIDOMHTMLCollection **aEmbeds);
    nsresult GetPlugins(nsIDOMHTMLCollection **aPlugins);
1168 1169
    nsresult GetLinks(nsIDOMHTMLCollection **aLinks);
    nsresult GetForms(nsIDOMHTMLCollection **aForms);
1170
    nsresult GetScripts(nsIDOMHTMLCollection **aScripts);
1171
    nsresult GetElementsByName(const nsAString *elementName, nsIDOMNodeList **_retval);
1172 1173 1174 1175 1176
    nsresult Open(const nsAString *aContentTypeOrUrl, const nsAString *aReplaceOrName, const nsAString *aFeatures,
            JSContext *cx, PRUint8 _argc, nsISupports **_retval);
    nsresult Close();
    nsresult Write(const nsAString *text, JSContext *cx);
    nsresult Writeln(const nsAString *text, JSContext *cx);
1177 1178
    nsresult GetDesignMode(nsAString *aDesignMode);
    nsresult SetDesignMode(const nsAString *aDesignMode);
1179 1180 1181 1182 1183 1184
    nsresult ExecCommand(const nsAString *commandID, bool doShowUI, const nsAString *value, bool *_retval);
    nsresult ExecCommandShowHelp(const nsAString *commandID, 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);
1185 1186
    nsresult QueryCommandText(const nsAString *commandID, nsAString *_retval);
    nsresult QueryCommandValue(const nsAString *commandID, nsAString *_retval);
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
    nsresult GetFgColor(nsAString *aFgColor);
    nsresult SetFgColor(const nsAString *aFgColor);
    nsresult GetBgColor(nsAString *aBgColor);
    nsresult SetBgColor(const nsAString *aBgColor);
    nsresult GetLinkColor(nsAString *aLinkColor);
    nsresult SetLinkColor(const nsAString *aLinkColor);
    nsresult GetVlinkColor(nsAString *aVlinkColor);
    nsresult SetVlinkColor(const nsAString *aVlinkColor);
    nsresult GetAlinkColor(nsAString *aAlinkColor);
    nsresult SetAlinkColor(const nsAString *aAlinkColor);
    nsresult GetAnchors(nsIDOMHTMLCollection **aAnchors);
    nsresult GetApplets(nsIDOMHTMLCollection **aApplets);
    nsresult Clear();
    nsresult GetSelection(nsISelection **_retval);
    nsresult CaptureEvents(PRInt32 eventFlags);
    nsresult ReleaseEvents(PRInt32 eventFlags);
    nsresult RouteEvent(nsIDOMEvent *evt);
1204 1205
}

1206 1207
[
    object,
1208 1209
    uuid(a6cf90ce-15b3-11d2-932e-00805f8add32),
    local
1210 1211 1212
]
interface nsIDOMRange : nsISupports
{
1213 1214 1215 1216 1217 1218 1219
    enum {
        NS_START_TO_START,
        NS_START_TO_END,
        NS_END_TO_END,
        NS_END_TO_START
    };

1220 1221 1222 1223
    nsresult GetStartContainer(nsIDOMNode **aStartContainer);
    nsresult GetStartOffset(PRInt32 *aStartOffset);
    nsresult GetEndContainer(nsIDOMNode **aEndContainer);
    nsresult GetEndOffset(PRInt32 *aEndOffset);
1224
    nsresult GetCollapsed(bool *aCollapsed);
1225 1226 1227 1228 1229 1230 1231
    nsresult GetCommonAncestorContainer(nsIDOMNode **aCommonAncestorContainer);
    nsresult SetStart(nsIDOMNode *refNode, PRInt32 offset);
    nsresult SetEnd(nsIDOMNode *refNode, PRInt32 offset);
    nsresult SetStartBefore(nsIDOMNode *refNode);
    nsresult SetStartAfter(nsIDOMNode *refNode);
    nsresult SetEndBefore(nsIDOMNode *refNode);
    nsresult SetEndAfter(nsIDOMNode *refNode);
1232
    nsresult Collapse(bool toStart);
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
    nsresult SelectNode(nsIDOMNode *refNode);
    nsresult SelectNodeContents(nsIDOMNode *refNode);
    nsresult CompareBoundaryPoints(PRUint16 how, nsIDOMRange *sourceRange, PRInt16 *_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();
}

1246 1247
[
    object,
1248
    uuid(fed93d11-f24d-41d8-ae55-4197927999bb),
1249
    local
1250 1251 1252 1253
]
interface nsIDOMNSRange : nsISupports
{
    nsresult CreateContextualFragment([in] const nsAString *fragment, [out] nsIDOMDocumentFragment **_retval);
1254
    nsresult IsPointInRange([in] nsIDOMNode *parent, [in] PRInt32 offset, [out] bool *_retval);
1255
    nsresult ComparePoint([in] nsIDOMNode *parent, [in] PRInt32 offset, [out] PRInt16 *_retval);
1256 1257
    nsresult GetClientRects(nsIDOMClientRectList **_retval);
    nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
1258 1259 1260
}


1261 1262
[
    object,
1263
    uuid(5ac0cd5d-3c08-4c4c-8e70-230c433f5d5c),
1264
    local
1265 1266 1267 1268 1269 1270 1271
]
interface nsISelection : nsISupports
{
    nsresult GetAnchorNode(nsIDOMNode **aAnchorNode);
    nsresult GetAnchorOffset(PRInt32 *aAnchorOffset);
    nsresult GetFocusNode(nsIDOMNode **aFocusNode);
    nsresult GetFocusOffset(PRInt32 *aFocusOffset);
1272
    nsresult GetIsCollapsed(bool *aIsCollapsed);
1273 1274 1275 1276 1277 1278
    nsresult GetRangeCount(PRInt32 *aRangeCount);
    nsresult GetRangeAt(PRInt32 index, nsIDOMRange **_retval);
    nsresult Collapse(nsIDOMNode *parentNode, PRInt32 offset);
    nsresult Extend(nsIDOMNode *parentNode, PRInt32 offset);
    nsresult CollapseToStart();
    nsresult CollapseToEnd();
1279
    nsresult ContainsNode(nsIDOMNode *node, bool entirelyContained, bool *_retval);
1280 1281 1282 1283 1284
    nsresult SelectAllChildren(nsIDOMNode *parentNode);
    nsresult AddRange(nsIDOMRange *range);
    nsresult RemoveRange(nsIDOMRange *range);
    nsresult RemoveAllRanges();
    nsresult DeleteFromDocument();
1285
    nsresult SelectionLanguageChange(bool langRTL);
1286
    nsresult ToString(PRUnichar **_retval);
1287
    nsresult Modify(const nsAString *alter, const nsAString *direction, const nsAString *granularity);
1288 1289
}

1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
[
    object,
    uuid(a6cf906f-15b3-11d2-932e-00805f8add32),
    local
]
interface nsIDOMWindowCollection : nsISupports
{
    nsresult GetLength(PRUint32 *aLength);
    nsresult Item(PRUint32 index, nsIDOMWindow **_retval);
    nsresult NamedItem(const nsAString *name, nsIDOMWindow **_retval);
}

1302 1303
[
    object,
1304
    uuid(f6e3b10d-d5f4-4fcd-aa4c-5f98626d428a),
1305
    local
1306 1307 1308
]
interface nsIDOMWindow : nsISupports
{
1309 1310
    nsresult GetWindow(nsIDOMWindow **aWindow);
    nsresult GetSelf(nsIDOMWindow **aSelf);
1311 1312 1313
    nsresult GetDocument(nsIDOMDocument **aDocument);
    nsresult GetName(nsAString *aName);
    nsresult SetName(const nsAString *aName);
1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
    nsresult GetLocation(nsIDOMLocation **aLocation);
    nsresult GetHistory(nsIDOMHistory **aHistory);
    nsresult GetLocationbar(nsIDOMBarProp **aLocationbar);
    nsresult GetMenubar(nsIDOMBarProp **aMenubar);
    nsresult GetPersonalbar(nsIDOMBarProp **aPersonalbar);
    nsresult GetScrollbars(nsIDOMBarProp **aScrollbars);
    nsresult GetStatusbar(nsIDOMBarProp **aStatusbar);
    nsresult GetToolbar(nsIDOMBarProp **aToolbar);
    nsresult GetStatus(nsAString *aStatus);
    nsresult SetStatus(const nsAString *aStatus);
    nsresult Close();
    nsresult Stop();
    nsresult Focus();
    nsresult Blur();
    nsresult GetLength(PRUint32 *aLength);
    nsresult GetTop(nsIDOMWindow **aTop);
    nsresult GetOpener(nsIDOMWindow **aOpener);
    nsresult SetOpener(nsIDOMWindow *aOpener);
    nsresult GetParent(nsIDOMWindow **aParent);
    nsresult GetFrameElement(nsIDOMElement **aFrameElement);
    nsresult GetNavigator(nsIDOMNavigator **aNavigator);
    nsresult GetApplicationCache(nsIDOMOfflineResourceList **aApplicationCache);
    nsresult Alert(const nsAString *text);
1337
    nsresult Confirm(const nsAString *text, bool *_retval);
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
    nsresult Prompt(const nsAString *aMessage, const nsAString *aInitial, nsAString *_retval);
    nsresult Print();
    nsresult ShowModalDialog(const nsAString *aURI, nsIVariant *aArgs, const nsAString *aOptions, nsIVariant **_retval);
    nsresult PostMessageMoz(const long /*jsval*/ *message, const nsAString *targetOrigin, JSContext *cx);
    nsresult Atob(const nsAString *aAsciiString, nsAString *_retval);
    nsresult Btoa(const nsAString *aBase64Data, nsAString *_retval);
    nsresult GetSessionStorage(nsIDOMStorage **aSessionStorage);
    nsresult GetLocalStorage(nsIDOMStorage **aLocalStorage);
    nsresult GetSelection(nsISelection **_retval);
    nsresult MatchMedia(const nsAString *media_query_list, nsIDOMMediaQueryList **_retval);
    nsresult GetScreen(nsIDOMScreen **aScreen);
    nsresult GetInnerWidth(PRInt32 *aInnerWidth);
    nsresult SetInnerWidth(PRInt32 aInnerWidth);
    nsresult GetInnerHeight(PRInt32 *aInnerHeight);
    nsresult SetInnerHeight(PRInt32 aInnerHeight);
1353
    nsresult GetScrollX(PRInt32 *aScrollX);
1354
    nsresult GetPageXOffset(PRInt32 *aPageXOffset);
1355
    nsresult GetScrollY(PRInt32 *aScrollY);
1356 1357
    nsresult GetPageYOffset(PRInt32 *aPageYOffset);
    nsresult Scroll(PRInt32 xScroll, PRInt32 yScroll);
1358 1359
    nsresult ScrollTo(PRInt32 xScroll, PRInt32 yScroll);
    nsresult ScrollBy(PRInt32 xScrollDif, PRInt32 yScrollDif);
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
    nsresult GetScreenX(PRInt32 *aScreenX);
    nsresult SetScreenX(PRInt32 aScreenX);
    nsresult GetScreenY(PRInt32 *aScreenY);
    nsresult SetScreenY(PRInt32 aScreenY);
    nsresult GetOuterWidth(PRInt32 *aOuterWidth);
    nsresult SetOuterWidth(PRInt32 aOuterWidth);
    nsresult GetOuterHeight(PRInt32 *aOuterHeight);
    nsresult SetOuterHeight(PRInt32 aOuterHeight);
    nsresult GetComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
    nsresult GetWindowRoot(nsIDOMEventTarget **aWindowRoot);
    nsresult GetFrames(nsIDOMWindowCollection **aFrames);
    nsresult GetTextZoom(float *aTextZoom);
    nsresult SetTextZoom(float aTextZoom);
1373 1374 1375
    nsresult ScrollByLines(PRInt32 numLines);
    nsresult ScrollByPages(PRInt32 numPages);
    nsresult SizeToContent();
1376 1377
    nsresult GetContent(nsIDOMWindow **aContent);
    nsresult GetPrompter(nsIPrompt **aPrompter);
1378
    nsresult GetClosed(bool *aClosed);
1379 1380 1381 1382 1383 1384 1385 1386 1387
    nsresult GetCrypto(nsIDOMCrypto **aCrypto);
    nsresult GetPkcs11(nsIDOMPkcs11 **aPkcs11);
    nsresult GetControllers(nsIControllers **aControllers);
    nsresult GetDefaultStatus(nsAString *aDefaultStatus);
    nsresult SetDefaultStatus(const nsAString *aDefaultStatus);
    nsresult GetMozInnerScreenX(float *aMozInnerScreenX);
    nsresult GetMozInnerScreenY(float *aMozInnerScreenY);
    nsresult GetScrollMaxX(PRInt32 *aScrollMaxX);
    nsresult GetScrollMaxY(PRInt32 *aScrollMaxY);
1388 1389
    nsresult GetFullScreen(bool *aFullScreen);
    nsresult SetFullScreen(bool aFullScreen);
1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
    nsresult Back();
    nsresult Forward();
    nsresult Home();
    nsresult MoveTo(PRInt32 xPos, PRInt32 yPos);
    nsresult MoveBy(PRInt32 xDif, PRInt32 yDif);
    nsresult ResizeTo(PRInt32 width, PRInt32 height);
    nsresult ResizeBy(PRInt32 widthDif, PRInt32 heightDif);
    nsresult Open(const nsAString *url, const nsAString *name, const nsAString *options, nsIDOMWindow **_retval);
    nsresult OpenDialog(const nsAString *url, const nsAString *name, const nsAString *options, nsISupports *aExtraArgument,
            nsIDOMWindow **_retval);
    nsresult UpdateCommands(const nsAString *action);
1401 1402
    nsresult Find(const nsAString *str, bool caseSensitive, bool backwards, bool wrapAround, bool wholeWord,
            bool searchInFrames, bool showDialog, bool *_retval);
1403
    nsresult GetMozPaintCount(PRUint64 *aMozPaintCount);
1404 1405 1406
    nsresult MozRequestAnimationFrame(nsIFrameRequestCallback *aCallback, PRInt32 *_retval);
    nsresult MozCancelAnimationFrame(PRInt32 aHandle);
    nsresult MozCancelRequestAnimationFrame(PRInt32 aHandle);
1407 1408 1409
    nsresult GetMozAnimationStartTime(PRInt64 *aMozAnimationStartTime);
    nsresult GetURL(nsIDOMMozURLProperty **aURL);
    nsresult GetGlobalStorage(nsIDOMStorageList **aGlobalStorage);
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
    nsresult GetOnafterprint(JSContext *cx, jsval *aOnafterprint);
    nsresult SetOnafterprint(JSContext *cx, const jsval *aOnafterprint);
    nsresult GetOnbeforeprint(JSContext *cx, jsval *aOnbeforeprint);
    nsresult SetOnbeforeprint(JSContext *cx, const jsval *aOnbeforeprint);
    nsresult GetOnbeforeunload(JSContext *cx, jsval *aOnbeforeunload);
    nsresult SetOnbeforeunload(JSContext *cx, const jsval *aOnbeforeunload);
    nsresult GetOnhashchange(JSContext *cx, jsval *aOnhashchange);
    nsresult SetOnhashchange(JSContext *cx, const jsval *aOnhashchange);
    nsresult GetOnmessage(JSContext *cx, jsval *aOnmessage);
    nsresult SetOnmessage(JSContext *cx, const jsval *aOnmessage);
    nsresult GetOnoffline(JSContext *cx, jsval *aOnoffline);
    nsresult SetOnoffline(JSContext *cx, const jsval *aOnoffline);
    nsresult GetOnonline(JSContext *cx, jsval *aOnonline);
    nsresult SetOnonline(JSContext *cx, const jsval *aOnonline);
    nsresult GetOnpopstate(JSContext *cx, jsval *aOnpopstate);
    nsresult SetOnpopstate(JSContext *cx, const jsval *aOnpopstate);
    nsresult GetOnpagehide(JSContext *cx, jsval *aOnpagehide);
    nsresult SetOnpagehide(JSContext *cx, const jsval *aOnpagehide);
    nsresult GetOnpageshow(JSContext *cx, jsval *aOnpageshow);
    nsresult SetOnpageshow(JSContext *cx, const jsval *aOnpageshow);
    nsresult GetOnresize(JSContext *cx, jsval *aOnresize);
    nsresult SetOnresize(JSContext *cx, const jsval *aOnresize);
    nsresult GetOnunload(JSContext *cx, jsval *aOnunload);
    nsresult SetOnunload(JSContext *cx, const jsval *aOnunload);
    nsresult GetOndevicemotion(JSContext *cx, jsval *aOndevicemotion);
    nsresult SetOndevicemotion(JSContext *cx, const jsval *aOndevicemotion);
    nsresult GetOndeviceorientation(JSContext *cx, jsval *aOndeviceorientation);
    nsresult SetOndeviceorientation(JSContext *cx, const jsval *aOndeviceorientation);
    nsresult GetOnmouseenter(JSContext* cx, jsval *aOnmouseenter);
    nsresult SetOnmouseenter(JSContext* cx, const jsval *aOnmouseenter);
    nsresult GetOnmouseleave(JSContext* cx, jsval *aOnmouseleave) = 0;
    nsresult SetOnmouseleave(JSContext* cx, const jsval *aOnmouseleave);
}

[
    object,
    uuid(fbc08701-776e-47d8-8b14-12b27aadc180),
1447
    local
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
]
interface nsIDOMHTMLBodyElement : nsIDOMHTMLElement
{
    nsresult GetALink(nsAString *aALink);
    nsresult SetALink(const nsAString *aALink);
    nsresult GetBackground(nsAString *aBackground);
    nsresult SetBackground(const nsAString *aBackground);
    nsresult GetBgColor(nsAString *aBgColor);
    nsresult SetBgColor(const nsAString *aBgColor);
    nsresult GetLink(nsAString *aLink);
    nsresult SetLink(const nsAString *aLink);
    nsresult GetText(nsAString *aText);
    nsresult SetText(const nsAString *aText);
    nsresult GetVLink(nsAString *aVLink);
    nsresult SetVLink(const nsAString *aVLink);
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
    nsresult GetOnafterprint(JSContext *cx, jsval *aOnafterprint);
    nsresult SetOnafterprint(JSContext *cx, const jsval *aOnafterprint);
    nsresult GetOnbeforeprint(JSContext *cx, jsval *aOnbeforeprint);
    nsresult SetOnbeforeprint(JSContext *cx, const jsval *aOnbeforeprint);
    nsresult GetOnbeforeunload(JSContext *cx, jsval *aOnbeforeunload);
    nsresult SetOnbeforeunload(JSContext *cx, const jsval *aOnbeforeunload);
    nsresult GetOnhashchange(JSContext *cx, jsval *aOnhashchange);
    nsresult SetOnhashchange(JSContext *cx, const jsval *aOnhashchange);
    nsresult GetOnmessage(JSContext *cx, jsval *aOnmessage);
    nsresult SetOnmessage(JSContext *cx, const jsval *aOnmessage);
    nsresult GetOnoffline(JSContext *cx, jsval *aOnoffline);
    nsresult SetOnoffline(JSContext *cx, const jsval *aOnoffline);
    nsresult GetOnonline(JSContext *cx, jsval *aOnonline);
    nsresult SetOnonline(JSContext *cx, const jsval *aOnonline);
    nsresult GetOnpagehide(JSContext *cx, jsval *aOnpagehide);
    nsresult SetOnpagehide(JSContext *cx, const jsval *aOnpagehide);
    nsresult GetOnpageshow(JSContext *cx, jsval *aOnpageshow);
    nsresult SetOnpageshow(JSContext *cx, const jsval *aOnpageshow);
    nsresult GetOnpopstate(JSContext *cx, jsval *aOnpopstate);
    nsresult SetOnpopstate(JSContext *cx, const jsval *aOnpopstate);
    nsresult GetOnresize(JSContext *cx, jsval *aOnresize);
    nsresult SetOnresize(JSContext *cx, const jsval *aOnresize);
    nsresult GetOnunload(JSContext *cx, jsval *aOnunload);
    nsresult SetOnunload(JSContext *cx, const jsval *aOnunload);
}

[
    object,
    uuid(b0fa651a-134c-4b20-ba4d-35b956a4fc50),
1492 1493 1494 1495 1496 1497 1498 1499
    local
]
interface nsIDOMHTMLFormElement : nsIDOMHTMLElement
{
    nsresult GetAcceptCharset(nsAString *aAcceptCharset);
    nsresult SetAcceptCharset(const nsAString *aAcceptCharset);
    nsresult GetAction(nsAString *aAction);
    nsresult SetAction(const nsAString *aAction);
1500 1501
    nsresult GetAutocomplete(nsAString *aAutocomplete);
    nsresult SetAutocomplete(const nsAString *aAutocomplete);
1502 1503
    nsresult GetEnctype(nsAString *aEnctype);
    nsresult SetEnctype(const nsAString *aEnctype);
1504 1505
    nsresult GetEncoding(nsAString *aEncoding);
    nsresult SetEncoding(const nsAString *aEncoding);
1506 1507
    nsresult GetMethod(nsAString *aMethod);
    nsresult SetMethod(const nsAString *aMethod);
1508 1509
    nsresult GetName(nsAString *aName);
    nsresult SetName(const nsAString *aName);
1510 1511
    nsresult GetNoValidate(bool *aNoValidate);
    nsresult SetNoValidate(bool aNoValidate);
1512 1513
    nsresult GetTarget(nsAString *aTarget);
    nsresult SetTarget(const nsAString *aTarget);
1514 1515
    nsresult GetElements(nsIDOMHTMLCollection **aElements);
    nsresult GetLength(PRInt32 *aLength);
1516 1517
    nsresult Submit();
    nsresult Reset();
1518
    nsresult CheckValidity(bool *_retval);
1519 1520
}

1521 1522
[
    object,
1523
    uuid(6b1175a5-70dd-4c26-be99-9e780c32550d),
1524
    local
1525 1526 1527 1528 1529 1530 1531
]
interface nsIDOMHTMLInputElement : nsIDOMHTMLElement
{
    nsresult GetAccept(nsAString *aAccept);
    nsresult SetAccept(const nsAString *aAccept);
    nsresult GetAlt(nsAString *aAlt);
    nsresult SetAlt(const nsAString *aAlt);
1532 1533
    nsresult GetAutocomplete(nsAString *aAutocomplete);
    nsresult SetAutocomplete(const nsAString *aAutocomplete);
1534 1535 1536 1537 1538 1539 1540 1541
    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);
1542
    nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1543 1544 1545 1546 1547 1548
    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);
1549 1550
    nsresult GetFormNoValidate(bool *aFormNoValidate);
    nsresult SetFormNoValidate(bool aFormNoValidate);
1551 1552
    nsresult GetFormTarget(nsAString *aFormTarget);
    nsresult SetFormTarget(const nsAString *aFormTarget);
1553
    nsresult GetFiles(nsIDOMFileList **aFiles);
1554 1555
    nsresult GetIndeterminate(bool *aIndeterminate);
    nsresult SetIndeterminate(bool aIndeterminate);
1556
    nsresult GetList(nsIDOMHTMLElement **aList);
1557 1558
    nsresult GetMaxLength(PRInt32 *aMaxLength);
    nsresult SetMaxLength(PRInt32 aMaxLength);
1559 1560
    nsresult GetMultiple(bool *aMultiple);
    nsresult SetMultiple(bool aMultiple);
1561 1562
    nsresult GetName(nsAString *aName);
    nsresult SetName(const nsAString *aName);
1563 1564
    nsresult GetPattern(nsAString *aPattern);
    nsresult SetPattern(const nsAString *aPattern);
1565 1566
    nsresult GetPlaceholder(nsAString *aPlaceholder);
    nsresult SetPlaceholder(const nsAString *aPlaceholder);
1567 1568 1569 1570
    nsresult GetReadOnly(bool *aReadOnly);
    nsresult SetReadOnly(bool aReadOnly);
    nsresult GetRequired(bool *aRequired);
    nsresult SetRequired(bool aRequired);
1571 1572
    nsresult GetAlign(nsAString *aAlign);
    nsresult SetAlign(const nsAString *aAlign);
1573 1574 1575 1576 1577 1578
    nsresult GetSize(PRUint32 *aSize);
    nsresult SetSize(PRUint32 aSize);
    nsresult GetSrc(nsAString *aSrc);
    nsresult SetSrc(const nsAString *aSrc);
    nsresult GetType(nsAString *aType);
    nsresult SetType(const nsAString *aType);
1579 1580
    nsresult GetDefaultValue(nsAString *aDefaultValue);
    nsresult SetDefaultValue(const nsAString *aDefaultValue);
1581 1582
    nsresult GetValue(nsAString *aValue);
    nsresult SetValue(const nsAString *aValue);
1583
    nsresult GetWillValidate(bool *aWillValidate);
1584 1585
    nsresult GetValidity(nsIDOMValidityState **aValidity);
    nsresult GetValidationMessage(nsAString *aValidationMessage);
1586
    nsresult CheckValidity(bool *_retval);
1587
    nsresult SetCustomValidity(const nsAString *error);
1588 1589 1590 1591 1592
    nsresult Select();
    nsresult GetSelectionStart(PRInt32 *aSelectionStart);
    nsresult SetSelectionStart(PRInt32 aSelectionStart);
    nsresult GetSelectionEnd(PRInt32 *aSelectionEnd);
    nsresult SetSelectionEnd(PRInt32 aSelectionEnd);
1593 1594 1595
    nsresult SetSelectionRange(PRInt32 selectionStart, PRInt32 selectionEnd, const nsAString *direction);
    nsresult GetSelectionDirection(nsAString *aSelectionDirection);
    nsresult SetSelectionDirection(const nsAString *aSelectionDirection);
1596 1597 1598 1599 1600 1601
    nsresult GetUseMap(nsAString *aUseMap);
    nsresult SetUseMap(const nsAString *aUseMap);
    nsresult GetControllers(nsIControllers **aControllers);
    nsresult GetTextLength(PRInt32 *aTextLength);
    nsresult MozGetFileNameArray(PRUint32 *aLength, PRUnichar ***aFileNames);
    nsresult MozSetFileNameArray(const PRUnichar **aFileNames, PRUint32 aLength);
1602
    nsresult MozIsTextField(bool aExcludePassword, bool *_retval);
1603 1604
}

1605 1606
[
    object,
1607
    uuid(ec3cfb59-a945-4821-8ea6-2448970e7639),
1608
    local
1609 1610 1611
]
interface nsIDOMHTMLOptionElement : nsIDOMHTMLElement
{
1612 1613
    nsresult GetDisabled(bool *aDisabled);
    nsresult SetDisabled(bool aDisabled);
1614
    nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1615 1616
    nsresult GetLabel(nsAString *aLabel);
    nsresult SetLabel(const nsAString *aLabel);
1617 1618 1619 1620
    nsresult GetDefaultSelected(bool *aDefaultSelected);
    nsresult SetDefaultSelected(bool aDefaultSelected);
    nsresult GetSelected(bool *aSelected);
    nsresult SetSelected(bool aSelected);
1621 1622
    nsresult GetValue(nsAString *aValue);
    nsresult SetValue(const nsAString *aValue);
1623 1624 1625
    nsresult GetText(nsAString *aText);
    nsresult SetText(const nsAString *aText);
    nsresult GetIndex(PRInt32 *aIndex);
1626 1627
}

1628 1629
[
    object,
1630
    uuid(429b041b-06df-486c-9a3a-a1d901cc76a2),
1631 1632 1633 1634
    local
]
interface nsIDOMHTMLOptionsCollection : nsISupports
{
1635 1636
    typedef int nsWrapperCache;

1637 1638 1639 1640
    nsresult GetLength(PRUint32 *aLength);
    nsresult SetLength(PRUint32 aLength);
    nsresult Item(PRUint32 index, nsIDOMNode **_retval);
    nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
1641 1642 1643 1644 1645 1646 1647
    nsISupports* __cdecl GetNamedItem(const nsAString *name, nsWrapperCache **cache);
    nsresult GetSelectedIndex(PRInt32 *aSelectedIndex);
    nsresult SetSelectedIndex(PRInt32 aSelectedIndex);
    nsresult SetOption(PRUint32 index, nsIDOMHTMLOptionElement *option);
    nsresult GetSelect(nsIDOMHTMLSelectElement **aSelect);
    nsresult Add(nsIDOMHTMLOptionElement *option, nsIVariant *before);
    nsresult Remove(PRInt32 index);
1648 1649
}

1650 1651
[
    object,
1652
    uuid(6f0a4fee-3aea-4bb7-85cb-d4881a55ca43),
1653
    local
1654 1655 1656
]
interface nsIDOMHTMLSelectElement : nsIDOMHTMLElement
{
1657 1658 1659 1660
    nsresult GetAutofocus(bool *aAutofocus);
    nsresult SetAutofocus(bool aAutofocus);
    nsresult GetDisabled(bool *aDisabled);
    nsresult SetDisabled(bool aDisabled);
1661
    nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1662 1663
    nsresult GetMultiple(bool *aMultiple);
    nsresult SetMultiple(bool aMultiple);
1664 1665 1666 1667
    nsresult GetName(nsAString *aName);
    nsresult SetName(const nsAString *aName);
    nsresult GetSize(PRInt32 *aSize);
    nsresult SetSize(PRInt32 aSize);
1668 1669 1670 1671 1672 1673
    nsresult GetType(nsAString *aType);
    nsresult GetOptions(nsIDOMHTMLOptionsCollection **aOptions);
    nsresult GetLength(PRUint32 *aLength);
    nsresult SetLength(PRUint32 aLength);
    nsresult Item(PRUint32 index, nsIDOMNode **_retval);
    nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
1674
    nsresult Add(nsIDOMHTMLElement *element, nsIVariant *before);
1675
    nsresult Remove(PRInt32 index);
1676 1677 1678 1679
    nsresult GetSelectedIndex(PRInt32 *aSelectedIndex);
    nsresult SetSelectedIndex(PRInt32 aSelectedIndex);
    nsresult GetValue(nsAString *aValue);
    nsresult SetValue(const nsAString *aValue);
1680
    nsresult GetWillValidate(bool *aWillValidate);
1681 1682
    nsresult GetValidity(nsIDOMValidityState **aValidity);
    nsresult GetValidationMessage(nsAString *aValidationMessage);
1683
    nsresult CheckValidity(bool *_retval);
1684
    nsresult SetCustomValidity(const nsAString *error);
1685 1686
    nsresult GetRequired(bool *aRequired);
    nsresult SetRequired(bool aRequired);
1687 1688
}

1689 1690
[
    object,
1691
    uuid(0ad0571c-f8ba-44e2-b5aa-5e1c93fae7c0),
1692
    local
1693 1694 1695
]
interface nsIDOMHTMLTextAreaElement : nsIDOMHTMLElement
{
1696 1697
    nsresult GetAutofocus(bool *aAutofocus);
    nsresult SetAutofocus(bool aAutofocus);
1698 1699
    nsresult GetCols(PRUint32 *aCols);
    nsresult SetCols(PRUint32 aCols);
1700 1701
    nsresult GetDisabled(bool *aDisabled);
    nsresult SetDisabled(bool aDisabled);
1702 1703 1704
    nsresult GetForm(nsIDOMHTMLFormElement **aForm);
    nsresult GetMaxLength(PRInt32 *aMaxLength);
    nsresult SetMaxLength(PRInt32 aMaxLength);
1705 1706
    nsresult GetName(nsAString *aName);
    nsresult SetName(const nsAString *aName);
1707 1708
    nsresult GetPlaceholder(nsAString *aPlaceholder);
    nsresult SetPlaceholder(const nsAString *aPlaceholder);
1709 1710 1711 1712
    nsresult GetReadOnly(bool *aReadOnly);
    nsresult SetReadOnly(bool aReadOnly);
    nsresult GetRequired(bool *aRequired);
    nsresult SetRequired(bool aRequired);
1713 1714
    nsresult GetRows(PRUint32 *aRows);
    nsresult SetRows(PRUint32 aRows);
1715 1716
    nsresult GetWrap(nsAString *aWrap);
    nsresult SetWrap(const nsAString *aWrap);
1717
    nsresult GetType(nsAString *aType);
1718 1719
    nsresult GetDefaultValue(nsAString *aDefaultValue);
    nsresult SetDefaultValue(const nsAString *aDefaultValue);
1720 1721
    nsresult GetValue(nsAString *aValue);
    nsresult SetValue(const nsAString *aValue);
1722
    nsresult GetTextLength(PRInt32 *aTextLength);
1723
    nsresult GetWillValidate(bool *aWillValidate);
1724 1725
    nsresult GetValidity(nsIDOMValidityState **aValidity);
    nsresult GetValidationMessage(nsAString *aValidationMessage);
1726
    nsresult CheckValidity(bool *_retval);
1727
    nsresult SetCustomValidity(const nsAString *error);
1728
    nsresult Select();
1729 1730 1731 1732 1733 1734 1735 1736
    nsresult GetSelectionStart(PRInt32 *aSelectionStart);
    nsresult SetSelectionStart(PRInt32 aSelectionStart);
    nsresult GetSelectionEnd(PRInt32 *aSelectionEnd);
    nsresult SetSelectionEnd(PRInt32 aSelectionEnd);
    nsresult SetSelectionRange(PRInt32 selectionStart, PRInt32 selectionEnd, const nsAString *direction);
    nsresult GetSelectionDirection(nsAString *aSelectionDirection);
    nsresult SetSelectionDirection(const nsAString *aSelectionDirection);
    nsresult GetControllers(nsIControllers **aControllers);
1737 1738
}

1739 1740
[
    object,
1741
    uuid(8b79bf24-d127-4b63-a798-f44bee76204d),
1742 1743 1744 1745
    local
]
interface nsIDOMHTMLScriptElement : nsIDOMHTMLElement
{
1746 1747
    nsresult GetSrc(nsAString *aSrc);
    nsresult SetSrc(const nsAString *aSrc);
1748 1749 1750 1751
    nsresult GetAsync(bool *aAsync);
    nsresult SetAsync(bool aAsync);
    nsresult GetDefer(bool *aDefer);
    nsresult SetDefer(bool aDefer);
1752 1753 1754 1755
    nsresult GetType(nsAString *aType);
    nsresult SetType(const nsAString *aType);
    nsresult GetCharset(nsAString *aCharset);
    nsresult SetCharset(const nsAString *aCharset);
1756 1757 1758 1759 1760 1761 1762 1763
    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);
}

1764 1765
[
    object,
1766
    uuid(3ed7023f-24be-4cd6-984c-c182a6b67bf9),
1767 1768 1769 1770
    local
]
interface nsIDOMHTMLImageElement : nsIDOMHTMLElement
{
1771 1772 1773 1774
    nsresult GetAlt(nsAString *aAlt);
    nsresult SetAlt(const nsAString *aAlt);
    nsresult GetSrc(nsAString *aSrc);
    nsresult SetSrc(const nsAString *aSrc);
1775 1776
    nsresult GetCrossOrigin(nsAString *aCrossOrigin);
    nsresult SetCrossOrigin(const nsAString *aCrossOrigin);
1777 1778
    nsresult GetUseMap(nsAString *aUseMap);
    nsresult SetUseMap(const nsAString *aUseMap);
1779 1780
    nsresult GetIsMap(bool *aIsMap);
    nsresult SetIsMap(bool aIsMap);
1781 1782 1783 1784 1785 1786
    nsresult GetWidth(PRUint32 *aWidth);
    nsresult SetWidth(PRUint32 aWidth);
    nsresult GetHeight(PRUint32 *aHeight);
    nsresult SetHeight(PRUint32 aHeight);
    nsresult GetNaturalWidth(PRUint32 *aNaturalWidth);
    nsresult GetNaturalHeight(PRUint32 *aNaturalHeight);
1787
    nsresult GetComplete(bool *aComplete);
1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
    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(PRInt32 *aHspace);
    nsresult SetHspace(PRInt32 aHspace);
    nsresult GetLongDesc(nsAString *aLongDesc);
    nsresult SetLongDesc(const nsAString *aLongDesc);
    nsresult GetVspace(PRInt32 *aVspace);
    nsresult SetVspace(PRInt32 aVspace);
1800 1801
    nsresult GetLowsrc(nsAString *aLowsrc);
    nsresult SetLowsrc(const nsAString *aLowsrc);
1802 1803
}

1804 1805
[
    object,
1806
    uuid(44a9c8e1-2c95-41e4-86f1-96033a452a4d),
1807 1808 1809 1810
    local
]
interface nsIDOMHTMLAnchorElement : nsIDOMHTMLElement
{
1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
    nsresult GetHref(nsAString *aHref);
    nsresult SetHref(const nsAString *aHref);
    nsresult GetTarget(nsAString *aTarget);
    nsresult SetTarget(const nsAString *aTarget);
    nsresult GetPing(nsAString *aPing);
    nsresult SetPing(const nsAString *aPing);
    nsresult 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);
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
    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);
1849
    nsresult ToString(nsAString *_retval);
1850 1851
}

1852 1853
[
    object,
1854
    uuid(7b9d43a6-7e9e-4618-970b-29eb3547d506),
1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
    local
]
interface nsIDOMHTMLTableElement : nsIDOMHTMLElement
{
    nsresult GetCaption(nsIDOMHTMLTableCaptionElement **aCaption);
    nsresult SetCaption(nsIDOMHTMLTableCaptionElement *aCaption);
    nsresult GetTHead(nsIDOMHTMLTableSectionElement **aTHead);
    nsresult SetTHead(nsIDOMHTMLTableSectionElement *aTHead);
    nsresult GetTFoot(nsIDOMHTMLTableSectionElement **aTFoot);
    nsresult SetTFoot(nsIDOMHTMLTableSectionElement *aTFoot);
    nsresult GetRows(nsIDOMHTMLCollection **aRows);
    nsresult GetTBodies(nsIDOMHTMLCollection **aTBodies);
    nsresult GetAlign(nsAString *aAlign);
    nsresult SetAlign(const nsAString *aAlign);
    nsresult GetBgColor(nsAString *aBgColor);
    nsresult SetBgColor(const nsAString *aBgColor);
    nsresult GetBorder(nsAString *aBorder);
    nsresult SetBorder(const nsAString *aBorder);
    nsresult GetCellPadding(nsAString *aCellPadding);
    nsresult SetCellPadding(const nsAString *aCellPadding);
    nsresult GetCellSpacing(nsAString *aCellSpacing);
    nsresult SetCellSpacing(const nsAString *aCellSpacing);
    nsresult GetFrame(nsAString *aFrame);
    nsresult SetFrame(const nsAString *aFrame);
    nsresult GetRules(nsAString *aRules);
    nsresult SetRules(const nsAString *aRules);
    nsresult GetSummary(nsAString *aSummary);
    nsresult SetSummary(const nsAString *aSummary);
    nsresult GetWidth(nsAString *aWidth);
    nsresult SetWidth(const nsAString *aWidth);
    nsresult CreateTHead(nsIDOMHTMLElement **_retval);
    nsresult DeleteTHead();
    nsresult CreateTFoot(nsIDOMHTMLElement **_retval);
    nsresult DeleteTFoot();
    nsresult CreateCaption(nsIDOMHTMLElement **_retval);
    nsresult DeleteCaption();
    nsresult InsertRow(PRInt32 index, nsIDOMHTMLElement **_retval);
    nsresult DeleteRow(PRInt32 index);
}

1895 1896
[
    object,
1897
    uuid(f76a1d42-25b9-41b9-a58e-7d934e1be0a2),
1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
    local
]
interface nsIDOMHTMLTableRowElement : nsIDOMHTMLElement
{
    nsresult GetRowIndex(PRInt32 *aRowIndex);
    nsresult GetSectionRowIndex(PRInt32 *aSectionRowIndex);
    nsresult GetCells(nsIDOMHTMLCollection **aCells);
    nsresult GetAlign(nsAString *aAlign);
    nsresult SetAlign(const nsAString *aAlign);
    nsresult GetBgColor(nsAString *aBgColor);
    nsresult SetBgColor(const nsAString *aBgColor);
    nsresult GetCh(nsAString *aCh);
    nsresult SetCh(const nsAString *aCh);
    nsresult GetChOff(nsAString *aChOff);
    nsresult SetChOff(const nsAString *aChOff);
    nsresult GetVAlign(nsAString *aVAlign);
    nsresult SetVAlign(const nsAString *aVAlign);
    nsresult InsertCell(PRInt32 index, nsIDOMHTMLElement **_retval);
    nsresult DeleteCell(PRInt32 index);
}

1919 1920
[
    object,
1921
    uuid(d4e870bd-452c-4860-b93c-f4ee00ba33f6),
1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946
    local
]
interface nsIDOMHTMLIFrameElement : nsIDOMHTMLElement
{
    nsresult GetAlign(nsAString *aAlign);
    nsresult SetAlign(const nsAString *aAlign);
    nsresult GetFrameBorder(nsAString *aFrameBorder);
    nsresult SetFrameBorder(const nsAString *aFrameBorder);
    nsresult GetHeight(nsAString *aHeight);
    nsresult SetHeight(const nsAString *aHeight);
    nsresult GetLongDesc(nsAString *aLongDesc);
    nsresult SetLongDesc(const nsAString *aLongDesc);
    nsresult GetMarginHeight(nsAString *aMarginHeight);
    nsresult SetMarginHeight(const nsAString *aMarginHeight);
    nsresult GetMarginWidth(nsAString *aMarginWidth);
    nsresult SetMarginWidth(const nsAString *aMarginWidth);
    nsresult GetName(nsAString *aName);
    nsresult SetName(const nsAString *aName);
    nsresult GetScrolling(nsAString *aScrolling);
    nsresult SetScrolling(const nsAString *aScrolling);
    nsresult GetSrc(nsAString *aSrc);
    nsresult SetSrc(const nsAString *aSrc);
    nsresult GetWidth(nsAString *aWidth);
    nsresult SetWidth(const nsAString *aWidth);
    nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
1947
    nsresult GetContentWindow(nsIDOMWindow **aContentWindow);
1948 1949
    nsresult GetMozAllowFullScreen(bool *aMozAllowFullScreen);
    nsresult SetMozAllowFullScreen(bool aMozAllowFullScreen);
1950 1951
}

1952 1953
[
    object,
1954
    uuid(4b529afd-ada8-4a2c-a70b-a4e2ead2329d),
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
    local
]
interface nsIDOMHTMLFrameElement : nsIDOMHTMLElement
{
    nsresult GetFrameBorder(nsAString *aFrameBorder);
    nsresult SetFrameBorder(const nsAString *aFrameBorder);
    nsresult GetLongDesc(nsAString *aLongDesc);
    nsresult SetLongDesc(const nsAString *aLongDesc);
    nsresult GetMarginHeight(nsAString *aMarginHeight);
    nsresult SetMarginHeight(const nsAString *aMarginHeight);
    nsresult GetMarginWidth(nsAString *aMarginWidth);
    nsresult SetMarginWidth(const nsAString *aMarginWidth);
    nsresult GetName(nsAString *aName);
    nsresult SetName(const nsAString *aName);
1969 1970
    nsresult GetNoResize(bool *aNoResize);
    nsresult SetNoResize(bool aNoResize);
1971 1972 1973 1974 1975
    nsresult GetScrolling(nsAString *aScrolling);
    nsresult SetScrolling(const nsAString *aScrolling);
    nsresult GetSrc(nsAString *aSrc);
    nsresult SetSrc(const nsAString *aSrc);
    nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
1976
    nsresult GetContentWindow(nsIDOMWindow **aContentWindow);
1977 1978
}

1979 1980
[
    object,
1981
    uuid(dbb14d7b-05ce-4abd-a980-9aedede612af),
1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
    local
]
interface nsIDOMHTMLObjectElement : nsIDOMHTMLElement
{
    nsresult GetForm(nsIDOMHTMLFormElement **aForm);
    nsresult GetCode(nsAString *aCode);
    nsresult SetCode(const nsAString *aCode);
    nsresult GetAlign(nsAString *aAlign);
    nsresult SetAlign(const nsAString *aAlign);
    nsresult GetArchive(nsAString *aArchive);
    nsresult SetArchive(const nsAString *aArchive);
    nsresult GetBorder(nsAString *aBorder);
    nsresult SetBorder(const nsAString *aBorder);
    nsresult GetCodeBase(nsAString *aCodeBase);
    nsresult SetCodeBase(const nsAString *aCodeBase);
    nsresult GetCodeType(nsAString *aCodeType);
    nsresult SetCodeType(const nsAString *aCodeType);
    nsresult GetData(nsAString *aData);
    nsresult SetData(const nsAString *aData);
2001 2002
    nsresult GetDeclare(bool *aDeclare);
    nsresult SetDeclare(bool aDeclare);
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
    nsresult GetHeight(nsAString *aHeight);
    nsresult SetHeight(const nsAString *aHeight);
    nsresult GetHspace(PRInt32 *aHspace);
    nsresult SetHspace(PRInt32 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(PRInt32 *aVspace);
    nsresult SetVspace(PRInt32 aVspace);
    nsresult GetWidth(nsAString *aWidth);
    nsresult SetWidth(const nsAString *aWidth);
    nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
2020
    nsresult GetWillValidate(bool *aWillValidate);
2021 2022
    nsresult GetValidity(nsIDOMValidityState **aValidity);
    nsresult GetValidationMessage(nsAString *aValidationMessage);
2023
    nsresult CheckValidity(bool *_retval);
2024
    nsresult SetCustomValidity(const nsAString *error);
2025 2026
}

2027 2028
[
    object,
2029
    uuid(1f0685fb-bf49-4c39-b08d-7d75b1e5e493),
2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043
    local
]
interface nsIDOMHTMLParamElement : nsIDOMHTMLElement
{
    nsresult GetName(nsAString *aName);
    nsresult SetName(const nsAString *aName);
    nsresult GetType(nsAString *aType);
    nsresult SetType(const nsAString *aType);
    nsresult GetValue(nsAString *aValue);
    nsresult SetValue(const nsAString *aValue);
    nsresult GetValueType(nsAString *aValueType);
    nsresult SetValueType(const nsAString *aValueType);
}

2044 2045
[
    object,
2046
    uuid(04c29aaa-2239-42a9-ade0-0ba3134c1a8e),
2047 2048 2049 2050
    local
]
interface nsIDOMHTMLStyleElement : nsIDOMHTMLElement
{
2051 2052
    nsresult GetDisabled(bool *aDisabled);
    nsresult SetDisabled(bool aDisabled);
2053 2054 2055 2056 2057 2058
    nsresult GetMedia(nsAString *aMedia);
    nsresult SetMedia(const nsAString *aMedia);
    nsresult GetType(nsAString *aType);
    nsresult SetType(const nsAString *aType);
}

2059 2060
[
    object,
2061 2062
    uuid(94928ab3-8b63-11d3-989d-001083010e9b),
    local
2063 2064 2065
]
interface nsIURIContentListener : nsISupports
{
2066 2067 2068 2069 2070 2071
    nsresult OnStartURIOpen(nsIURI *aURI, bool *_retval);
    nsresult DoContent(const char *aContentType, bool aIsContentPreferred, nsIRequest *aRequest,
        nsIStreamListener **aContentHandler, bool *_retval);
    nsresult IsPreferred(const char *aContentType, char **aDesiredContentType, bool *_retval);
    nsresult CanHandleContent(const char *aContentType, bool aIsContentPreferred,
        char **aDesiredContentType, bool *_retval);
2072 2073 2074 2075 2076 2077
    nsresult GetLoadCookie(nsISupports **aLoadCookie);
    nsresult SetLoadCookie(nsISupports *aLoadCookie);
    nsresult GetParentContentListener(nsIURIContentListener **aParentContentListener);
    nsresult SetParentContentListener(nsIURIContentListener *aParentContentListener);
}

2078 2079
[
    object,
2080 2081
    uuid(44b78386-1dd2-11b2-9ad2-e4eee2ca1916),
    local
2082 2083 2084 2085 2086 2087 2088
]
interface nsITooltipListener : nsISupports
{
    nsresult OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, const PRUnichar *aTipText);
    nsresult OnHideTooltip();
}

2089 2090
[
    object,
2091
    uuid(33e9d001-caab-4ba9-8961-54902f197202),
2092
    local
2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
]
interface nsIWebBrowser : nsISupports
{
    nsresult AddWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
    nsresult RemoveWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
    nsresult GetContainerWindow(nsIWebBrowserChrome **aContainerWindow);
    nsresult SetContainerWindow(nsIWebBrowserChrome *aContainerWindow);
    nsresult GetParentURIContentListener(nsIURIContentListener **aParentURIContentListener);
    nsresult SetParentURIContentListener(nsIURIContentListener *aParentURIContentListener);
    nsresult GetContentDOMWindow(nsIDOMWindow **aContentDOMWindow);
2103 2104
    nsresult GetIsActive(bool *aIsActive);
    nsresult SetIsActive(bool aIsActive);
2105 2106
}

2107
cpp_quote("#define SETUP_ALLOW_JAVASCRIPT  2")
2108
cpp_quote("#define SETUP_IS_CHROME_WRAPPER 7")
2109 2110 2111

[
    object,
2112 2113
    uuid(f15398a0-8018-11d3-af70-00a024ffc08c),
    local
2114 2115 2116 2117 2118 2119 2120 2121 2122 2123
]
interface nsIWebBrowserSetup : nsISupports
{
    nsresult SetProperty(PRUint32 aId, PRUint32 aValue);
}

typedef void* nativeWindow;

[
    object,
2124
    uuid(7144ac8b-6702-4a4b-a73d-d1d4e9717e46),
2125
    local
2126 2127 2128 2129 2130 2131 2132 2133 2134
]
interface nsIBaseWindow : nsISupports
{
    nsresult InitWindow(nativeWindow parentNativeWindow, nsIWidget *parentWidget, PRInt32 x,
            PRInt32 y, PRInt32 cx, PRInt32 cy);
    nsresult Create();
    nsresult Destroy();
    nsresult SetPosition(PRInt32 x, PRInt32 y);
    nsresult GetPosition(PRInt32 *x, PRInt32 *y);
2135
    nsresult SetSize(PRInt32 cx, PRInt32 cy, bool fRepaint);
2136
    nsresult GetSize(PRInt32 *cx, PRInt32 *cy);
2137
    nsresult SetPositionAndSize(PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy, bool fRepaint);
2138
    nsresult GetPositionAndSize(PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy);
2139
    nsresult Repaint(bool force);
2140
    nsresult GetParentWidget(nsIWidget **aParentWidget);
2141 2142 2143
    nsresult SetParentWidget(nsIWidget *aParentWidget);
    nsresult GetParentNativeWindow(nativeWindow *aParentNativeWindow);
    nsresult SetParentNativeWindow(nativeWindow aParentNativeWindow);
2144 2145 2146 2147
    nsresult GetVisibility(bool *aVisibility);
    nsresult SetVisibility(bool aVisibility);
    nsresult GetEnabled(bool *aEnabled);
    nsresult SetEnabled(bool aEnabled);
2148 2149 2150 2151 2152 2153
    nsresult GetMainWidget(nsIWidget **aMainWidget);
    nsresult SetFocus();
    nsresult GetTitle(PRUnichar **aTitle);
    nsresult SetTitle(const PRUnichar *aTitle);
}

2154 2155 2156
cpp_quote("#define LOAD_FLAGS_NONE           0x00000000")
cpp_quote("#define LOAD_REPLACE              0x00040000")
cpp_quote("#define LOAD_INITIAL_DOCUMENT_URI 0x00080000")
2157 2158 2159

[
    object,
2160 2161
    uuid(f5d9e7b0-d930-11d3-b057-00a024ffc08c),
    local
2162 2163 2164
]
interface nsIWebNavigation : nsISupports
{
2165 2166
    nsresult GetCanGoBack(bool *aCanGoBack);
    nsresult GetCanGoForward(bool *aCanGoForward);
2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180
    nsresult GoBack();
    nsresult GoForward();
    nsresult GotoIndex(PRInt32 index);
    nsresult LoadURI(const PRUnichar *aURI, PRUint32 aLoadFlags, nsIURI *aReferrer,
            nsIInputStream *aPostData, nsIInputStream *aHeaders);
    nsresult Reload(PRUint32 aReloadFlags);
    nsresult Stop(PRUint32 aStopFlags);
    nsresult GetDocument(nsIDOMDocument **aDocument);
    nsresult GetCurrentURI(nsIURI **aCurrentURI);
    nsresult GetReferringURI(nsIURI **aReferringURI);
    nsresult GetSessionHistory(nsISHistory **aSessionHistory);
    nsresult SetSessionHistory(nsISHistory *aSessionHistory);
}

2181 2182 2183 2184 2185 2186 2187 2188 2189 2190
[
    object,
    uuid(570f39d0-efd0-11d3-b093-00a024ffc08c),
    local
]
interface nsIWebProgress : nsISupports
{
    nsresult AddProgressListener(nsIWebProgressListener *aListener, PRUint32 aNotifyMask);
    nsresult RemoveProgressListener(nsIWebProgressListener *aListener);
    nsresult GetDOMWindow(nsIDOMWindow **aDOMWindow);
2191
    nsresult GetIsLoadingDocument(bool *aIsLoadingDocument);
2192 2193
}

2194 2195
[
    object,
2196
    uuid(4404c94b-0506-4255-9e3c-4582dba6cfbb),
2197
    local
2198 2199 2200
]
interface nsIPrintSettings : nsISupports
{
2201
    typedef struct { char dummy; } nsIntMargin;
2202

2203 2204
    nsresult SetPrintOptions(PRInt32 aType, bool aTurnOnOff);
    nsresult GetPrintOptions(PRInt32 aType, bool *_retval);
2205
    nsresult GetPrintOptionsBits(PRInt32 *_retval);
2206
    nsresult GetEffectivePageSize(double *aWidth, double *aHeight);
2207 2208 2209 2210 2211 2212 2213 2214
    nsresult Clone(nsIPrintSettings **_retval);
    nsresult Assign(nsIPrintSettings *aPS);
    nsresult GetPrintSession(nsIPrintSession **aPrintSession);
    nsresult SetPrintSession(nsIPrintSession *aPrintSession);
    nsresult GetStartPageRange(PRInt32 *aStartPageRange);
    nsresult SetStartPageRange(PRInt32 aStartPageRange);
    nsresult GetEndPageRange(PRInt32 *aEndPageRange);
    nsresult SetEndPageRange(PRInt32 aEndPageRange);
2215 2216 2217 2218 2219 2220 2221 2222
    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);
2223 2224 2225 2226 2227 2228 2229 2230
    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);
2231 2232 2233 2234 2235 2236 2237 2238
    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);
2239 2240
    nsresult GetScaling(double *aScaling);
    nsresult SetScaling(double aScaling);
2241 2242 2243 2244
    nsresult GetPrintBGColors(bool *aPrintBGColors);
    nsresult SetPrintBGColors(bool aPrintBGColors);
    nsresult GetPrintBGImages(bool *aPrintBGImages);
    nsresult SetPrintBGImages(bool aPrintBGImages);
2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264
    nsresult GetPrintRange(PRInt16 *aPrintRange);
    nsresult SetPrintRange(PRInt16 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(PRInt16 *aHowToEnableFrameUI);
    nsresult SetHowToEnableFrameUI(PRInt16 aHowToEnableFrameUI);
2265 2266
    nsresult GetIsCancelled(bool *aIsCancelled);
    nsresult SetIsCancelled(bool aIsCancelled);
2267 2268 2269 2270
    nsresult GetPrintFrameTypeUsage(PRInt16 *aPrintFrameTypeUsage);
    nsresult SetPrintFrameTypeUsage(PRInt16 aPrintFrameTypeUsage);
    nsresult GetPrintFrameType(PRInt16 *aPrintFrameType);
    nsresult SetPrintFrameType(PRInt16 aPrintFrameType);
2271 2272 2273 2274 2275 2276
    nsresult GetPrintSilent(bool *aPrintSilent);
    nsresult SetPrintSilent(bool aPrintSilent);
    nsresult GetShrinkToFit(bool *aShrinkToFit);
    nsresult SetShrinkToFit(bool aShrinkToFit);
    nsresult GetShowPrintProgress(bool *aShowPrintProgress);
    nsresult SetShowPrintProgress(bool aShowPrintProgress);
2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
    nsresult GetPaperName(PRUnichar **aPaperName);
    nsresult SetPaperName(const PRUnichar *aPaperName);
    nsresult GetPaperSizeType(PRInt16 *aPaperSizeType);
    nsresult SetPaperSizeType(PRInt16 aPaperSizeType);
    nsresult GetPaperData(PRInt16 *aPaperData);
    nsresult SetPaperData(PRInt16 aPaperData);
    nsresult GetPaperWidth(double *aPaperWidth);
    nsresult SetPaperWidth(double aPaperWidth);
    nsresult GetPaperHeight(double *aPaperHeight);
    nsresult SetPaperHeight(double aPaperHeight);
    nsresult GetPaperSizeUnit(PRInt16 *aPaperSizeUnit);
    nsresult SetPaperSizeUnit(PRInt16 aPaperSizeUnit);
    nsresult GetPlexName(PRUnichar **aPlexName);
    nsresult SetPlexName(const PRUnichar *aPlexName);
    nsresult GetColorspace(PRUnichar **aColorspace);
    nsresult SetColorspace(const PRUnichar *aColorspace);
    nsresult GetResolutionName(PRUnichar **aResolutionName);
    nsresult SetResolutionName(const PRUnichar aResolutionName);
2295 2296 2297 2298 2299 2300
    nsresult GetDownloadFonts(bool *aDownloadFonts);
    nsresult SetDownloadFonts(bool aDownloadFonts);
    nsresult GetPrintReversed(bool *aPrintReversed);
    nsresult SetPrintReversed(bool aPrintReversed);
    nsresult GetPrintInColor(bool *aPrintInColor);
    nsresult SetPrintInColor(bool aPrintInColor);
2301 2302 2303 2304 2305 2306 2307 2308
    nsresult GetOrientation(PRInt32 *aOrientation);
    nsresult SetOrientation(PRInt32 aOrientation);
    nsresult GetPrintCommand(PRUnichar **aPrintCommand);
    nsresult SetPrintCommand(const PRUnichar *aPrintCommand);
    nsresult GetNumCopies(PRInt32 *aNumCopies);
    nsresult SetNumCopies(PRInt32 aNumCopies);
    nsresult GetPrinterName(PRUnichar **aPrinterName);
    nsresult SetPrinterName(const PRUnichar *aPrinterName);
2309 2310
    nsresult GetPrintToFile(bool *aPrintToFile);
    nsresult SetPrintToFile(bool aPrintToFile);
2311 2312
    nsresult GetToFileName(PRUnichar **aToFileName);
    nsresult SetToFileName(const PRUnichar *aToFileName);
2313 2314
    nsresult GetOutputFormat(PRInt16 *aOutputFormat);
    nsresult SetOutputFormat(PRInt16 aOutputFormat);
2315 2316
    nsresult GetPrintPageDelay(PRInt32 *aPrintPageDelay);
    nsresult SetPrintPageDelay(PRInt32 aPrintPageDelay);
2317 2318 2319 2320
    nsresult GetIsInitializedFromPrinter(bool *aIsInitializedFromPrinter);
    nsresult SetIsInitializedFromPrinter(bool aIsInitializedFromPrinter);
    nsresult GetIsInitializedFromPrefs(bool *aIsInitializedFromPrefs);
    nsresult SetIsInitializedFromPrefs(bool aIsInitializedFromPrefs);
2321 2322 2323 2324
    nsresult SetMarginInTwips(nsIntMargin *aMargin);
    nsresult SetEdgeInTwips(nsIntMargin *aEdge);
    nsresult GetMarginInTwips(nsIntMargin *aMargin);
    nsresult GetEdgeInTwips(nsIntMargin *aEdge);
2325
    nsresult SetupSilentPrinting();
2326 2327
    nsresult SetUnwriteableMarginInTwips(nsIntMargin *aEdge);
    nsresult GetUnwriteableMarginInTwips(nsIntMargin *aEdge);
2328
    nsresult GetPageRanges(void * /*nsTArray<PRInt32>&*/ aPages);
2329 2330 2331 2332
}

[
    object,
2333 2334
    uuid(9a7ca4b0-fbba-11d4-a869-00105a183419),
    local
2335 2336 2337 2338 2339 2340
]
interface nsIWebBrowserPrint : nsISupports
{
    nsresult GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings);
    nsresult GetCurrentPrintSettings(nsIPrintSettings **aCurrentPrintSettings);
    nsresult GetCurrentChildDOMWindow(nsIDOMWindow **aCurrentChildDOMWindow);
2341 2342 2343 2344 2345 2346
    nsresult GetDoingPrint(bool *aDoingPrint);
    nsresult GetDoingPrintPreview(bool *aDoingPrintPreview);
    nsresult GetIsFramesetDocument(bool *aIsFramesetDocument);
    nsresult GetIsFramesetFrameSelected(bool *aIsFramesetFrameSelected);
    nsresult GetIsIFrameSelected(bool *aIsIFrameSelected);
    nsresult GetIsRangeSelection(bool *aIsRangeSelection);
2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
    nsresult GetPrintPreviewNumPages(PRInt32 *aPrintPreviewNumPages);
    nsresult Print(nsIPrintSettings *aThePrintSettings, nsIWebProgressListener *aWPListener);
    nsresult PrintPreview(nsIPrintSettings *aThePrintSettings, nsIDOMWindow *aChildDOMWin,
                          nsIWebProgressListener *aWPListener);
    nsresult PrintPreviewNavigate(PRInt16 aNavType, PRInt32 aPageNum);
    nsresult Cancel();
    nsresult EnumerateDocumentNames(PRUint32 *aCount, PRUnichar ***aResult);
    nsresult ExitPrintPreview();
}

2357 2358
[
    object,
2359 2360
    uuid(919e792a-6490-40b8-bba5-f9e9ad5640c8),
    local
2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383
]
interface nsIScrollable : nsISupports
{
    enum {
        ScrollOrientation_X = 1,
        ScrollOrientation_Y = 2
    };

    enum {
        Scrollbar_Auto   = 1,
        Scrollbar_Never  = 2,
        Scrollbar_Always = 3
    };

    nsresult GetCurScrollPos(PRInt32 scrollOrientation, PRInt32 *curPos);
    nsresult SetCurScrollPos(PRInt32 scrollOrientation, PRInt32 curPos);
    nsresult SetCurScrollPosEx(PRInt32 curHorizontalPos, PRInt32 curVerticalPos);
    nsresult GetScrollRange(PRInt32 scrollOrientation, PRInt32 *minPos, PRInt32 *maxPos);
    nsresult SetScrollRange(PRInt32 scrollOrientation, PRInt32 minPos, PRInt32 maxPos);
    nsresult SetScrollRangeEx(PRInt32 minHorizontalPos, PRInt32 maxHorizontalPos,
            PRInt32 minVerticalPos, PRInt32 maxVerticalPos);
    nsresult GetDefaultScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 *scrollbarPref);
    nsresult SetDefaultScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 scrollbarPref);
2384
    nsresult GetScrollbarVisibility(bool *verticalVisible, bool *horizontalVisible);
2385 2386
}

2387 2388
[
    object,
2389 2390
    uuid(c8c0a080-0868-11d3-915f-d9d889d48e3c),
    local
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407
]
interface nsIFile : nsISupports
{
    nsresult Append(const nsAString *node);
    nsresult AppendNative(const nsAString *node);
    nsresult Normalize();
    nsresult Create(PRUint32 type, PRUint32 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);
2408
    nsresult Remove(bool recursive);
2409 2410 2411 2412 2413 2414
    nsresult GetPermissions(PRUint32 *aPermissions);
    nsresult SetPermissions(PRUint32 pPermissions);
    nsresult GetPermissionsOfLink(PRUint32 *aPermissions);
    nsresult SetPermissionsOfLink(PRUint32 pPermissions);
    nsresult GetLastModifiedTime(PRInt64 *aLastModifiedTime);
    nsresult SetLastModifiedTime(PRInt64 aLastModifiedTime);
2415 2416
    nsresult GetLastModifiedTimeOfLink(PRInt64 *aLastModifiedTimeOfLink);
    nsresult SetLastModifiedTimeOfLink(PRInt64 aLastModifiedTimeOfLink);
2417 2418 2419 2420 2421 2422 2423
    nsresult GetFileSize(PRInt64 *aFileSize);
    nsresult SetFileSize(PRInt64 aFileSize);
    nsresult GetFileSizeOfLink(PRInt64 *aFileSizeOfLink);
    nsresult GetTarget(nsAString *aTarget);
    nsresult GetNativeTarget(nsACString *aNativeTarget);
    nsresult GetPath(nsAString *aPath);
    nsresult GetNativePath(nsACString *aNativePath);
2424 2425 2426 2427 2428 2429 2430 2431 2432
    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);
2433 2434
    nsresult CreateUnique(PRUint32 type, PRUint32 permission);
    nsresult Clone(nsIFile **_retval);
2435 2436
    nsresult Equals(nsIFile *inFile, bool *_retval);
    nsresult Contains(nsIFile *inFile, bool recir, bool *_retval);
2437 2438 2439
    nsresult GetParent(nsIFile **aParent);
    nsresult GetDirectoryEntries(nsISimpleEnumerator **aDirectoryEntries);
}
2440

2441 2442
[
    object,
2443
    uuid(e162bfa0-01bd-4e9f-9843-8fb2efcd6d1f),
2444
    local
2445 2446 2447 2448 2449
]
interface nsIPrefBranch : nsISupports
{
    nsresult GetRoot(char **aRoot);
    nsresult GetPrefType(const char *aPrefName, PRInt32 *_retval);
2450 2451
    nsresult GetBoolPref(const char *aPrefName, bool *_retval);
    nsresult SetBoolPref(const char *aPrefName, bool aValue);
2452 2453 2454 2455 2456 2457 2458 2459
    nsresult GetCharPref(const char *aPrefName, char **_retval);
    nsresult SetCharPref(const char *aPrefName, const char *aValue);
    nsresult GetIntPref(const char *aPrefName, PRInt32 *_retval);
    nsresult SetIntPref(const char *aPrefName, PRInt32 aValue);
    nsresult GetComplexValue(const char *aPrefName, const nsIID *aType, void **aValue);
    nsresult SetComplexValue(const char *aPrefName, const nsIID *aType, nsISupports *aValue);
    nsresult ClearUserPref(const char *aPrefName);
    nsresult LockPref(const char *aPrefName);
2460 2461
    nsresult PrefHasUserValue(const char *aPrefName, bool *_retval);
    nsresult PrefIsLocked(const char *aPrefName, bool *_retval);
2462 2463 2464 2465 2466 2467
    nsresult UnlockPref(const char *aPrefName);
    nsresult DeleteBranch(const char *aStartingAt);
    nsresult GetChildList(const char *aStartingAt, PRUint32 *aCount, char ***aChildArray);
    nsresult ResetBranch(const char *aStartingAt);
}

2468 2469 2470 2471 2472 2473 2474
[
    object,
    uuid(bbf8cab0-d43a-11d3-8cc2-00609792278c),
    local
]
interface nsIDirectoryServiceProvider : nsISupports
{
2475
    nsresult GetFile(const char *prop, bool *persistent, nsIFile **_retval);
2476 2477
}

2478 2479
[
    object,
2480 2481
    uuid(15fd6940-8ea7-11d3-93ad-00104ba0fd40),
    local
2482 2483 2484 2485 2486 2487 2488 2489 2490
]
interface nsIProtocolHandler : nsISupports
{
    nsresult GetScheme(nsACString *aScheme);
    nsresult GetDefaultPort(PRInt32 *aDefaultPort);
    nsresult GetProtocolFlags(PRUint32 *aProtocolFlags);
    nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset,
                    nsIURI *aBaseURI, nsIURI **_retval);
    nsresult NewChannel(nsIURI *aURI, nsIChannel **_retval);
2491
    nsresult AllowPort(PRInt32 port, const char *scheme, bool *_retval);
2492 2493 2494 2495
}

[
    object,
2496 2497
    uuid(0e61f3b2-34d7-4c79-bfdc-4860bc7341b7),
    local
2498 2499 2500
]
interface nsIExternalProtocolHandler : nsIProtocolHandler
{
2501
    nsresult ExternalAppExistsForScheme(const nsACString *scheme, bool *_retval);
2502 2503
}

2504 2505
[
    object,
2506 2507
    uuid(bddeda3f-9020-4d12-8c70-984ee9f7935e),
    local
2508 2509 2510 2511 2512
]
interface nsIIOService : nsISupports
{
    nsresult GetProtocolHandler(const char *aScheme, nsIProtocolHandler **_retval);
    nsresult GetProtocolFlags(const char *aScheme, PRUint32 *_retval);
2513 2514
    nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
                    nsIURI **_retval);
2515 2516
    nsresult NewFileURI(nsIFile *aFile, nsIURI **_retval);
    nsresult NewChannelFromURI(nsIURI *aURI, nsIChannel **_retval);
2517 2518
    nsresult NewChannel(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
                        nsIChannel **_retval);
2519 2520 2521
    nsresult GetOffline(bool *aOffline);
    nsresult SetOffline(bool aOffline);
    nsresult AllowPort(PRInt32 aPort, const char *aScheme, bool *_retval);
2522
    nsresult ExtractScheme(const nsACString *urlString, nsACString *_retval);
2523
}
2524

2525 2526
[
    object,
2527
    uuid(ca68c485-9db3-4c12-82a6-4fab7948e2d5),
2528 2529 2530 2531 2532
    local,
]
interface nsINetUtil : nsISupports
{
    nsresult ParseContentType(const nsACString *aTypeHeader, nsACString *aCharset,
2533 2534 2535
            bool *aHadCharset, nsACString *_retval);
    nsresult ProtocolHasFlags(nsIURI *aURI, PRUint32 aFlag, bool *_retval);
    nsresult URIChainHasFlags(nsIURI *aURI, PRUint32 aFlags, bool *_retval);
2536
    nsresult ToImmutableURI(nsIURI *aURI, nsIURI **_retval);
2537
    nsresult NewSimpleNestedURI(nsIURI *aURI, nsIURI **_retval);
2538 2539 2540 2541
    nsresult EscapeString(const nsACString *aString, PRUint32 aEscapeType, nsACString *_retval);
    nsresult EscapeURL(const nsACString *aStr, PRUint32 aFlags, nsACString *_retval);
    nsresult UnescapeString(const nsACString *aStr, PRUint32 aFlags, nsACString *_retval);
    nsresult ExtractCharsetFromContentType(const nsACString *aTypeHeader, nsACString *aCharset,
2542
            PRInt32 *aCharsetStart, PRInt32 *aCharsetEnd, bool *_retval);
2543 2544
}

2545 2546
[
    object,
2547 2548
    uuid(9c5d3c58-1dd1-11b2-a1c9-f3699284657a),
    local
2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561
]
interface nsIWebBrowserFocus : nsISupports
{
    nsresult Activate();
    nsresult Deactivate();
    nsresult SetFocusAtFirstElement();
    nsresult SetFocusAtLastElement();
    nsresult GetFocusedWindow(nsIDOMWindow **aFocusedWindow);
    nsresult SetFocusedWindow(nsIDOMWindow *aFocusedWindow);
    nsresult GetFocusedElement(nsIDOMElement **aFocusedElement);
    nsresult SetFocusedElement(nsIDOMElement *aFocusedElement);
}

2562 2563
[
    object,
2564 2565
    uuid(ba434c60-9d52-11d3-afb0-00a024ffc08c),
    local
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
]
interface nsIWebBrowserChrome : nsISupports
{
    nsresult SetStatus(PRUint32 statusType, const PRUnichar *status);
    nsresult GetWebBrowser(nsIWebBrowser **aWebBrowser);
    nsresult SetWebBrowser(nsIWebBrowser *aWebBrowser);
    nsresult GetChromeFlags(PRUint32 *aChromeFlags);
    nsresult SetChromeFlags(PRUint32 aChromeFlags);
    nsresult DestroyBrowserWindow();
    nsresult SizeBrowserTo(PRInt32 aCX, PRInt32 aCY);
    nsresult ShowAsModal();
2577
    nsresult IsWindowModal(bool *_retval);
2578 2579 2580
    nsresult ExitModalEventLoop(nsresult aStatus);
}

2581 2582
[
    object,
2583 2584
    uuid(df31c120-ded6-11d1-bd85-00805f8ae3f4),
    local
2585 2586 2587 2588 2589 2590 2591 2592
]
interface nsIDOMEventListener : nsISupports
{
    nsresult HandleEvent(nsIDOMEvent *event);
}

[
    object,
2593
    uuid(8e375931-298d-4d0a-9cb4-5668f0cdc5a8),
2594
    local
2595 2596 2597
]
interface nsIDOMEventTarget : nsISupports
{
2598 2599 2600 2601 2602
    nsresult AddEventListener(const nsAString *type, nsIDOMEventListener *listener, bool useCapture, bool wantsUntrusted, PRUint8 _argc);
    nsresult AddSystemEventListener(const nsAString *type, nsIDOMEventListener *listener, bool aUseCapture, bool aWantsUntrusted, PRUint8 _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);
2603 2604

    /* Followed by methods we should try to avoid using */
2605 2606
}

2607 2608
[
    object,
2609
    uuid(e85cff74-951f-45c1-be0c-89442ea2f500),
2610
    local
2611 2612 2613 2614 2615 2616 2617
]
interface nsIDOMEvent : nsISupports
{
    nsresult GetType(nsAString *aType);
    nsresult GetTarget(nsIDOMEventTarget **aTarget);
    nsresult GetCurrentTarget(nsIDOMEventTarget **aCurrentTarget);
    nsresult GetEventPhase(PRUint16 *aEventPhase);
2618 2619
    nsresult GetBubbles(bool *aBubbles);
    nsresult GetCancelable(bool *aCancelable);
2620 2621 2622
    nsresult GetTimeStamp(DOMTimeStamp *aTimeStamp);
    nsresult StopPropagation();
    nsresult PreventDefault();
2623 2624
    nsresult InitEvent(const nsAString *eventTypeArg, bool canBubbleArg, bool cancelableArg);
    nsresult GetDefaultPrevented(bool *aDefaultPrevented);
2625
    nsresult StopImmediatePropagation();
2626 2627
}

2628 2629 2630 2631 2632 2633 2634
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")
2635 2636 2637

[
    object,
2638 2639
    uuid(3478b6b0-3875-11d4-94ef-0020183bf181),
    local
2640 2641 2642 2643 2644 2645 2646 2647
]
interface nsIContextMenuListener : nsISupports
{
    nsresult OnShowContextMenu(PRUint32 aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode);
}

[
    object,
2648
    uuid(af3f130e-0c22-4613-a150-780a46c22e3a),
2649
    local
2650 2651 2652
]
interface nsIDOMUIEvent : nsIDOMEvent
{
2653
    nsresult GetView(nsIDOMWindow **aView);
2654
    nsresult GetDetail(PRInt32 *aDetail);
2655
    nsresult InitUIEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
2656
            nsIDOMWindow *viewArg, PRInt32 detailArg);
2657 2658 2659 2660 2661 2662 2663
    nsresult GetLayerX(PRInt32 *aLayerX);
    nsresult GetLayerY(PRInt32 *aLayerY);
    nsresult GetPageX(PRInt32 *aPageX);
    nsresult GetPageY(PRInt32 *aPageY);
    nsresult GetWhich(PRUint32 *aWhich);
    nsresult GetRangeParent(nsIDOMNode * *aRangeParent);
    nsresult GetRangeOffset(PRInt32 *aRangeOffset);
2664 2665 2666
    nsresult GetCancelBubble(bool *aCancelBubble);
    nsresult SetCancelBubble(bool aCancelBubble);
    nsresult GetIsChar(bool *aIsChar);
2667 2668 2669 2670
}

[
    object,
2671
    uuid(7f57aa45-6792-4d8b-ba5b-201533cf0b2f),
2672
    local
2673 2674 2675 2676 2677 2678 2679
]
interface nsIDOMMouseEvent : nsIDOMUIEvent
{
    nsresult GetScreenX(PRInt32 *aScreenX);
    nsresult GetScreenY(PRInt32 *aScreenY);
    nsresult GetClientX(PRInt32 *aClientX);
    nsresult GetClientY(PRInt32 *aClientY);
2680 2681 2682 2683
    nsresult GetCtrlKey(bool *aCtrlKey);
    nsresult GetShiftKey(bool *aShiftKey);
    nsresult GetAltKey(bool *aAltKey);
    nsresult GetMetaKey(bool *aMetaKey);
2684
    nsresult GetButton(PRUint16 *aButton);
2685
    nsresult GetRelatedTarget(nsIDOMEventTarget **aRelatedTarget);
2686
    nsresult InitMouseEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
2687
            nsIDOMWindow *viewArg, PRInt32 detailArg, PRInt32 screenXArg, PRInt32 screenYArg,
2688 2689
            PRInt32 clientXArg, PRInt32 clientYArg, bool ctrlKeyArg, bool altKeyArg,
            bool shiftKeyArg, bool metaKeyArg, PRUint16 buttonArg,
2690
            nsIDOMEventTarget *relatedTargetArg);
2691 2692
    nsresult GetMozPressure(float *aMozPressure);
    nsresult GetMozInputSource(PRUint16 *aMozInputSource);
2693
    nsresult InitNSMouseEvent(const nsAString *typeArg, bool canBubbleArg, bool cancelableArg,
2694
            nsIDOMWindow *viewArg, PRInt32 detailArg, PRInt32 screenXArg, PRInt32 screenYArg,
2695 2696
            PRInt32 clientXArg, PRInt32 clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg,
            bool metaKeyArg, PRUint16 buttonArg, nsIDOMEventTarget *relatedTargetArg, float pressure,
2697
            PRUint16 inputSourceArg);
2698
}
2699

2700 2701
[
    object,
2702
    uuid(def974c3-b491-481b-bc67-29174af4b26a),
2703
    local
2704 2705 2706 2707 2708
]
interface nsIDOMKeyEvent : nsIDOMUIEvent
{
    nsresult GetCharCode(PRUint32 *aCharCode);
    nsresult GetKeyCode(PRUint32 *aKeyCode);
2709 2710 2711 2712 2713 2714 2715
    nsresult GetAltKey(bool *aAltKey);
    nsresult GetCtrlKey(bool *aCtrlKey);
    nsresult GetShiftKey(bool *aShiftKey);
    nsresult GetMetaKey(bool *aMetaKey);
    nsresult InitKeyEvent(const nsAString *typeArg, bool canBubbleArg,
            bool cancelableArg, nsIDOMWindow *viewArg, bool ctrlKeyArg,
            bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, PRUint32 keyCodeArg,
2716 2717 2718
            PRUint32 charCodeArg);
}

2719
[
2720 2721 2722
    object,
    uuid(3e5432cd-9568-4bd1-8cbe-d50aba110743),
    local
2723 2724 2725 2726 2727 2728
]
interface nsIEmbeddingSiteWindow : nsISupports
{
    nsresult SetDimensions(PRUint32 flags, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy);
    nsresult GetDimensions(PRUint32 flags, PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy);
    nsresult SetFocus();
2729 2730
    nsresult GetVisibility(bool *aVisibility);
    nsresult SetVisibility(bool aVisibility);
2731 2732 2733 2734
    nsresult GetTitle(PRUnichar **aTitle);
    nsresult SetTitle(const PRUnichar *aTitle);
    nsresult GetSiteWindow(void **aSiteWindow);
}
2735 2736

[
2737 2738 2739
    object,
    uuid(2417cbfe-65ad-48a6-b4b6-eb84db174392),
    local
2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751
]
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);
2752 2753
    nsresult IsCIDRegistered(const nsCID *aClass, bool *_retval);
    nsresult IsContractIDRegistered(const char *aContractID, bool *_retval);
2754 2755 2756 2757 2758 2759 2760 2761
    nsresult EnumerateCIDs(nsISimpleEnumerator **_retval);
    nsresult EnumerateContractIDs(nsISimpleEnumerator **_retval);
    nsresult CIDToContractID(const nsCID *aClass, char **_retval);
    nsresult ContractIDToCID(const char *aContractID, nsCID **_retval);
}

[
    object,
2762 2763
    uuid(1630c61a-325e-49ca-8759-a31b16c47aa5),
    local
2764 2765 2766 2767 2768 2769
]
interface nsIPromptService : nsISupports
{
    nsresult Alert(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
            const PRUnichar *aText);
    nsresult AlertCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2770
            const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState);
2771
    nsresult Confirm(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2772
            const PRUnichar *aText, bool *_retval);
2773
    nsresult ConfirmCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2774 2775
            const PRUnichar *aText, const PRUnichar *aCheckMsg, bool *aCheckState,
            bool *_retval);
2776 2777 2778
    nsresult ConfirmEx(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
            const PRUnichar *aText, PRUint32 aButtonFlags, const PRUnichar *aButton0Title,
            const PRUnichar *aButton1Title, const PRUnichar *aButton2Title,
2779
            const PRUnichar *aCheckMsg, bool *aCheckState, PRInt32 *_retval);
2780 2781
    nsresult Prompt(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
            const PRUnichar *aText, PRUnichar **aValue, const PRUnichar *aCheckMsg,
2782
            bool *aCheckState, bool *_retval);
2783 2784
    nsresult PromptUsernameAndPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
            const PRUnichar *aText, PRUnichar **aUsername, PRUnichar **aPassword,
2785
            const PRUnichar *aCheckMsg, bool *aCheckState, bool *_retval);
2786 2787
    nsresult PromptPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
            const PRUnichar *aText, PRUnichar **aPassword, const PRUnichar *aCheckMsg,
2788
            bool *aCheckState, bool *_retval);
2789 2790
    nsresult Select(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
            const PRUnichar *aText, PRUint32 aCount, const PRUnichar **aSelectList,
2791
            PRInt32 *aOutSelection, bool *_retval);
2792
}
2793

2794 2795
[
    object,
2796 2797
    uuid(b128a1e6-44f3-4331-8fbe-5af360ff21ee),
    local
2798 2799 2800
]
interface nsITooltipTextProvider : nsISupports
{
2801
    nsresult GetNodeText(nsIDOMNode *aNode, PRUnichar **aText, bool *_retval);
2802 2803
}

2804 2805
[
    object,
2806 2807
    uuid(02b0625a-e7f3-11d2-9f5a-006008a6efe9),
    local
2808 2809 2810 2811 2812
]
interface nsIProfile : nsISupports
{
    nsresult GetProfileCount(PRInt32 *aProfileCount);
    nsresult GetProfileList(PRUint32 *length, PRUnichar ***profileNames);
2813
    nsresult ProfileExists(const PRUnichar *profileName, bool *_retval);
2814
    nsresult GetCurrentProfile(PRUnichar **aCurrentProfile);
2815
    nsresult SetCurrentProfile(const PRUnichar *aCurrentProfile);
2816 2817 2818
    nsresult ShutDownCurrentProfile(PRUint32 shutDownType);
    nsresult CreateNewProfile(const PRUnichar *profileName,
            const PRUnichar *nativeProfileDir, const PRUnichar *langcode,
2819
            bool useExistingDir);
2820
    nsresult RenameProfile(const PRUnichar *oldName, const PRUnichar *newName);
2821
    nsresult DeleteProfile(const PRUnichar *name, bool canDeleteFiles);
2822 2823
    nsresult CloneProfile(const PRUnichar *profileName);
}
2824

2825 2826
[
    object,
2827
    uuid(24f3f4da-18a4-448d-876d-7360fefac029),
2828
    local
2829 2830 2831 2832 2833
]
interface nsIEditingSession : nsISupports
{
    nsresult GetEditorStatus(PRUint32 *aEditorStatus);
    nsresult MakeWindowEditable(nsIDOMWindow *window, const char *aEditorType,
2834 2835
            bool doAfterUriLoad, bool aMakeWholeDocumentEditable, bool aInteractive);
    nsresult WindowIsEditable(nsIDOMWindow *window, bool *_retval);
2836 2837 2838 2839
    nsresult GetEditorForWindow(nsIDOMWindow *window, nsIEditor **_retval);
    nsresult SetupEditorOnWindow(nsIDOMWindow *window);
    nsresult TearDownEditorOnWindow(nsIDOMWindow *window);
    nsresult SetEditorOnControllers(nsIDOMWindow *aWindow, nsIEditor *aEditor);
2840 2841 2842 2843
    nsresult DisableJSAndPlugins(nsIDOMWindow *aWindow);
    nsresult RestoreJSAndPlugins(nsIDOMWindow *aWindow);
    nsresult DetachFromWindow(nsIDOMWindow *aWindow);
    nsresult ReattachToWindow(nsIDOMWindow *aWindow);
2844
    nsresult GetJsAndPluginsDisabled(bool *aJsAndPluginsDisabled);
2845 2846
}

2847 2848
[
    object,
2849 2850
    uuid(83f892cf-7ed3-490e-967a-62640f3158e1),
    local
2851 2852 2853 2854
]
interface nsICommandParams : nsISupports
{
    nsresult GetValueType(const char *name, PRInt16 *_retval);
2855
    nsresult GetBooleanValue(const char *name, bool *_retval);
2856 2857 2858 2859 2860
    nsresult GetLongValue(const char *name, PRInt32 *_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);
2861
    nsresult SetBooleanValue(const char *name, bool value);
2862 2863 2864 2865 2866 2867
    nsresult SetLongValue(const char *name, PRInt32 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);
2868
    nsresult HasMoreElements(bool *_retval);
2869 2870 2871 2872
    nsresult First();
    nsresult GetNext(char **_retval);
}

2873 2874
[
    object,
2875 2876
    uuid(080d2001-f91e-11d4-a73c-f9242928207c),
    local
2877 2878 2879 2880 2881
]
interface nsICommandManager : nsISupports
{
    nsresult AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve);
    nsresult RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved);
2882 2883
    nsresult IsCommandSupported(const char *aCommandName, nsIDOMWindow *aTargetWindow, bool *_retval);
    nsresult IsCommandEnabled(const char *aCommandName, nsIDOMWindow *aTargetWindow, bool *_retval);
2884 2885 2886 2887 2888 2889
    nsresult GetCommandState(const char *aCommandName, nsIDOMWindow *aTargetWindow,
            nsICommandParams *aCommandParams);
    nsresult DoCommand(const char *aCommandName, nsICommandParams *aCommandParams,
            nsIDOMWindow *aTargetWindow);
}

2890 2891
[
    object,
2892 2893
    uuid(47b82b60-a36f-4167-8072-6f421151ed50),
    local
2894 2895 2896 2897 2898 2899 2900 2901 2902
]
interface nsIControllerContext : nsISupports
{
    nsresult Init(nsIControllerCommandTable *aCommandTable);
    nsresult SetCommandContext(nsISupports *aCommandContext);
}

[
    object,
2903 2904
    uuid(d5b61b82-1da4-11d3-bf87-00105a1b0627),
    local
2905 2906 2907
]
interface nsIController : nsISupports
{
2908 2909
    nsresult IsCommandEnabled(const char *command, bool *_retval);
    nsresult SupportsCommand(const char *command, bool *_retval);
2910 2911 2912 2913
    nsresult DoCommand(const char *command);
    nsresult OnEvent(const char *eventName);
}

2914 2915
[
    object,
2916
    uuid(dc68f070-226d-11e1-bfc2-0800200c9a66),
2917 2918 2919 2920 2921 2922 2923 2924 2925
    local
]
interface nsIContent : nsISupports
{
    /* This is not a real interface declaration. It's too internal for us. */
}

[
    object,
2926
    uuid(283ec27d-5b23-49b2-94d9-09b5db453073),
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936
    local
]
interface nsIDocument : nsISupports
{
    /* This is not a real interface declaration. It's too internal for us. */
}

[
    object,
    uuid(b1ee32f2-b8c4-49b9-93df-b6fab5d54688),
2937
    local
2938 2939 2940
]
interface nsIContentSerializer : nsISupports
{
2941 2942
    nsresult Init(PRUint32 flags, PRUint32 aWrapColumn, const char *aCharSet, bool aIsCopying,
            bool aIsWholeDocument);
2943 2944
    nsresult AppendText(nsIContent *aText, PRInt32 aStartOffset, PRInt32 aEndOffset, nsAString *aStr);
    nsresult AppendCDATASection(nsIContent *aCDATASection, PRInt32 aStartOffset,
2945
            PRInt32 aEndOffset, nsAString *aStr);
2946
    nsresult AppendProcessingInstruction(nsIContent *aPI, PRInt32 aStartOffset,
2947
            PRInt32 aEndOffset, nsAString *aStr);
2948
    nsresult AppendComment(nsIContent *aComment, PRInt32 aStartOffset, PRInt32 aEndOffset,
2949
            nsAString *aStr);
2950 2951
    nsresult AppendDoctype(nsIContent *aDoctype, nsAString *aStr);
    nsresult AppendElementStart(nsIContent *aElement, nsIContent *aOriginalElement,
2952
                                nsAString *aStr);
2953
    nsresult AppendElementEnd(nsIContent *aElement, nsAString *aStr);
2954
    nsresult Flush(nsAString *aStr);
2955
    nsresult AppendDocumentStart(nsIDocument *aDocument, nsAString *aStr);
2956 2957
}

2958 2959
[
    object,
2960
    uuid(20ee0b70-c528-11e0-9572-0800200c9a66),
2961
    local
2962 2963 2964 2965 2966 2967
]
interface nsIEditor  : nsISupports
{
    typedef void *nsIContentPtr;

    nsresult GetSelection([out] nsISelection *_retval);
2968
    nsresult Init([in] nsIDOMDocument *doc, [in] nsIContentPtr aRoot, [in] nsISelectionController *aSelCon, [in] PRUint32 aFlags);
2969 2970
    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);
2971 2972 2973 2974 2975 2976
    nsresult PostCreate();
    nsresult PreDestroy();
    nsresult GetFlags([out] PRUint32 *_retval);
    nsresult SetFlags([in] PRUint32 val);
    nsresult GetContentsMIMEType([out] char **_retval);
    nsresult SetContentsMIMEType([in] const char *val);
2977 2978
    nsresult GetIsDocumentEditable([out] bool *_retval);
    nsresult GetIsSelectionEditable(bool *aIsSelectionEditable);
2979 2980 2981 2982
    nsresult GetDocument([out] nsIDOMDocument **_retval);
    nsresult GetRootElement([out] nsIDOMElement **_retval);
    nsresult GetSelectionController([out] nsISelectionController **_retval);
    nsresult DeleteSelection([in] PRInt16 action);
2983 2984
    nsresult GetDocumentIsEmpty([out] bool *_retval);
    nsresult GetDocumentModified([out] bool *_retval);
2985 2986 2987 2988
    nsresult GetDocumentCharacterSet([out] nsACString *_retval);
    nsresult SetDocumentCharacterSet([in] const nsACString *val);
    nsresult ResetModificationCount();
    nsresult GetModificationCount([out] PRInt32 *_retval);
2989
    nsresult IncrementModificationCount([in] PRInt32 aModCount);
2990
    nsresult GetTransactionManager([out] nsITransactionManager **_retval);
2991
    nsresult SetTransactionManager(nsITransactionManager *aTransactionManager);
2992
    nsresult DoTransaction([in] nsITransaction *txn);
2993
    nsresult EnableUndo([in] bool enable);
2994
    nsresult Undo([in] PRUint32 count);
2995
    nsresult CanUndo([out] bool *isEnabled, [out] bool *canUndo);
2996
    nsresult Redo([in] PRUint32 count);
2997
    nsresult CanRedo([out] bool *isEnabled, [out] bool *canRedo);
2998 2999 3000 3001
    nsresult BeginTransaction();
    nsresult EndTransaction();
    nsresult BeginPlaceHolderTransaction([in] nsIAtom *name);
    nsresult EndPlaceHolderTransaction();
3002 3003
    nsresult ShouldTxnSetSelection([out] bool *_retval);
    nsresult SetShouldTxnSetSelection([in] bool should);
3004
    nsresult GetInlineSpellChecker([out] nsIInlineSpellChecker **_retval);
3005
    nsresult SyncRealTimeSpell();
3006
    nsresult SetSpellcheckUserOverride(bool enable);
3007
    nsresult Cut();
3008
    nsresult CanCut([out] bool *_retval);
3009
    nsresult Copy();
3010
    nsresult CanCopy([out] bool *_retval);
3011
    nsresult Paste([in] PRInt32 aSelectionType);
3012
    nsresult PasteTransferable(nsITransferable *aTransferable);
3013 3014
    nsresult CanPaste([in] PRInt32 aSelectionType, [out] bool *_retval);
    nsresult CanPasteTransferable(nsITransferable *aTransferable, bool *_retval);
3015 3016 3017
    nsresult SelectAll();
    nsresult BeginningOfDocument();
    nsresult EndOfDocument();
3018
    nsresult CanDrag([in] nsIDOMEvent *aEvent, [out] bool *_retval);
3019 3020 3021
    nsresult DoDrag([in] nsIDOMEvent *aEvent);
    nsresult InsertFromDrop([in] nsIDOMEvent *aEvent);
    nsresult SetAttribute([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [in] const nsAString *attvalue);
3022
    nsresult GetAttributeValue([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [out] nsAString *resultValue, bool *_retval);
3023 3024 3025
    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);
3026
    nsresult CreateNode([in] const nsAString *tag, [in] nsIDOMNode *parent, [in] PRInt32 position, [out] nsIDOMNode **_retval);
3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043
    nsresult InsertNode([in] nsIDOMNode *node, [in] nsIDOMNode *parent, [in] PRInt32 aPosition);
    nsresult SplitNode([in] nsIDOMNode *existingRightNode, [in] PRInt32 offset, [out] nsIDOMNode **newLeftNode);
    nsresult JoinNodes([in] nsIDOMNode *leftNode, [in] nsIDOMNode *rightNode, [in] nsIDOMNode *parent);
    nsresult DeleteNode([in] nsIDOMNode *child);
    nsresult MarkNodeDirty([in] nsIDOMNode *node);
    nsresult SwitchTextDirection();
    nsresult OutputToString([in] nsAString formatType, [in] PRUint32 flags, [out] nsAString *_retval);
    nsresult OutputToStream([in] nsIOutputStream *aStream, [in] nsAString *formatType, [in] nsACString *charsetOverride, [in] PRUint32 flags);
    nsresult AddEditorObserver([in] nsIEditorObserver *observer);
    nsresult RemoveEditorObserver([in] 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] PRInt32 *outNumTests, [out] PRInt32 *outNumTestsFailed);
3044 3045
    bool IsModifiableNode(nsIDOMNode *aNode);
    nsresult GetLastKeypressEventTrusted(bool *aLastKeypressEventTrusted);
3046 3047
}

3048 3049
[
    object,
3050
    uuid(d58f35a7-c269-4292-b9aa-a79e200a7c99),
3051
    local
3052 3053 3054 3055 3056 3057 3058 3059
]
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 SetCSSInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
    nsresult SetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
3060 3061
    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);
3062 3063 3064 3065
    nsresult RemoveAllInlineProperties();
    nsresult RemoveInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute);
    nsresult IncreaseFontSize();
    nsresult DecreaseFontSize();
3066
    nsresult CanDrag([in] nsIDOMEvent *aEvent, [out] bool *_retval);
3067 3068
    nsresult DoDrag([in] nsIDOMEvent *aEvent);
    nsresult InsertFromDrop([in] nsIDOMEvent *aEvent);
3069
    nsresult NodeIsBlock([in] nsIDOMNode *node, bool *_retval);
3070 3071 3072
    nsresult InsertHTML([in] nsAString *aInputString);
    nsresult PasteNoFormatting([in] PRInt32 aSelectionType);
    nsresult RebuildDocumentFromSource([in] nsAString *aSourceString);
3073 3074
    nsresult InsertHTMLWithContext([in] nsAString *aInputString, [in] nsAString *aContextStr, [in] nsAString *aInfoStr, [in] nsAString *aFlavor, [in] nsIDOMDocument *aSourceDoc, [in] nsIDOMNode *aDestinationNode, [in] PRInt32 aDestinationOffset, [in] bool aDeleteSelection);
    nsresult InsertElementAtSelection([in] nsIDOMElement *aElement, [in] bool aDeleteSelection);
3075 3076 3077 3078 3079
    nsresult SetDocumentTitle([in] nsAString *aTitle);
    nsresult UpdateBaseURL();
    nsresult SelectElement([in] nsIDOMElement *aElement);
    nsresult SetCaretAfterElement([in] nsIDOMElement *aElement);
    nsresult SetParagraphFormat([in] nsAString *aParagraphFormat);
3080 3081 3082 3083 3084 3085 3086 3087 3088 3089
    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] PRInt16 *aAlign);
    nsresult GetIndentState([out] bool *aCanIndent, [out] bool *aCanOutdent);
    nsresult MakeOrChangeList([in] nsAString *aListType, [in] bool entireList, [in] nsAString *aBulletType);
3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100
    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);
3101
    nsresult IgnoreSpuriousDragEvent([in] bool aIgnoreSpuriousDragEvent);
3102
    nsresult GetLinkedObjects([out] nsISupportsArray **_retval);
3103 3104
    nsresult GetIsCSSEnabled([out] bool *_retval);
    nsresult SetIsCSSEnabled([in] bool prb);
3105 3106
    nsresult AddInsertionListener([in] nsIContentFilter *inFilter);
    nsresult RemoveInsertionListener([in] nsIContentFilter *inFilter);
3107
    nsresult CreateAnonymousElement([in] nsAString *aTag, [in] nsIDOMNode *aParentNode, [in] nsAString *aAnonClass, [in] bool aIsCreatedHidden, [out] nsIDOMElement **_retval);
3108 3109
    nsresult GetSelectionContainer([out] nsIDOMElement **_retval);
    nsresult CheckSelectionStateForAnonymousButtons([in] nsISelection *aSelection);
3110 3111 3112 3113
    nsresult IsAnonymousElement([in] nsIDOMElement *aElement, [out] bool *_retval);
    nsresult GetReturnInParagraphCreatesNewParagraph([out] bool *_retval);
    nsresult SetReturnInParagraphCreatesNewParagraph([in] bool prb);
    nsresult BreakIsVisible(nsIDOMNode *aNode, bool *_retval);
3114
    nsIContent *GetActiveEditingHost();
3115 3116
}

3117 3118
[
    object,
3119
    uuid(0666adf8-8738-4ca7-a917-0348f47d2f40),
3120 3121 3122 3123
    local
]
interface nsIDocShell : nsISupports
{
3124
    nsresult LoadURI(nsIURI *uri, nsIDocShellLoadInfo *loadInfo, PRUint32 aLoadFlags, bool firstParty);
3125 3126 3127 3128
    nsresult LoadStream(nsIInputStream *aStream, nsIURI *aURI, const nsACString *aContentType,
            const nsACString *aContentCharset, nsIDocShellLoadInfo *aLoadInfo);
    nsresult InternalLoad(nsIURI *aURI, nsIURI *aReferrer, nsISupports *aOwner, PRUint32 aFlags, const PRUnichar *aWindowTarget,
            const char *aTypeHint, nsIInputStream *aPostDataStream, nsIInputStream *aHeadersStream, PRUint32 aLoadFlags,
3129 3130
            nsISHEntry *aSHEntry, bool firstParty, nsIDocShell **aDocShell, nsIRequest **aRequest);
    nsresult AddState(nsIVariant *aData, const nsAString *aTitle, const nsAString *aURL, bool aReplace, JSContext *cx);
3131 3132 3133
    nsresult CreateLoadInfo(nsIDocShellLoadInfo **loadInfo);
    nsresult PrepareForNewContentModel();
    nsresult SetCurrentURI(nsIURI *aURI);
3134
    nsresult FirePageHideNotification(bool isUnload);
3135 3136 3137 3138 3139 3140 3141 3142
    nsresult GetPresContext(void /*nsPresContext*/ **aPresContext);
    nsresult GetPresShell(nsIPresShell **aPresShell);
    nsresult GetEldestPresShell(nsIPresShell **aEldestPresShell);
    nsresult GetContentViewer(nsIContentViewer **aContentViewer);
    nsresult GetChromeEventHandler(nsIDOMEventTarget **aChromeEventHandler);
    nsresult SetChromeEventHandler(nsIDOMEventTarget *aChromeEventHandler);
    nsresult GetDocumentCharsetInfo(nsIDocumentCharsetInfo **aDocumentCharsetInfo);
    nsresult SetDocumentCharsetInfo(nsIDocumentCharsetInfo *aDocumentCharsetInfo);
3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156
    nsresult GetAllowPlugins(bool *aAllowPlugins);
    nsresult SetAllowPlugins(bool aAllowPlugins);
    nsresult GetAllowJavascript(bool *aAllowJavascript);
    nsresult SetAllowJavascript(bool aAllowJavascript);
    nsresult GetAllowMetaRedirects(bool *aAllowMetaRedirects);
    nsresult SetAllowMetaRedirects(bool aAllowMetaRedirects);
    nsresult GetAllowSubframes(bool *aAllowSubframes);
    nsresult SetAllowSubframes(bool aAllowSubframes);
    nsresult GetAllowImages(bool *aAllowImages);
    nsresult SetAllowImages(bool aAllowImages);
    nsresult GetAllowDNSPrefetch(bool *aAllowDNSPrefetch);
    nsresult SetAllowDNSPrefetch(bool aAllowDNSPrefetch);
    nsresult GetAllowWindowControl(bool *aAllowWindowControl);
    nsresult SetAllowWindowControl(bool aAllowWindowControl);
3157 3158 3159
    nsresult GetDocShellEnumerator(PRInt32 aItemType, PRInt32 aDirection, nsISimpleEnumerator **_retval);
    nsresult GetAppType(PRUint32 *aAppType);
    nsresult SetAppType(PRUint32 aAppType);
3160 3161
    nsresult GetAllowAuth(bool *aAllowAuth);
    nsresult SetAllowAuth(bool aAllowAuth);
3162 3163 3164 3165 3166 3167
    nsresult GetZoom(float *aZoom);
    nsresult SetZoom(float aZoom);
    nsresult GetMarginWidth(PRInt32 *aMarginWidth);
    nsresult SetMarginWidth(PRInt32 aMarginWidth);
    nsresult GetMarginHeight(PRInt32 *aMarginHeight);
    nsresult SetMarginHeight(PRInt32 aMarginHeight);
3168
    nsresult TabToTreeOwner(bool forward, bool *tookFocus);
3169 3170 3171
    nsresult GetBusyFlags(PRUint32 *aBusyFlags);
    nsresult GetLoadType(PRUint32 *aLoadType);
    nsresult SetLoadType(PRUint32 aLoadType);
3172 3173
    nsresult IsBeingDestroyed(bool *_retval);
    nsresult GetIsExecutingOnLoadHandler(bool *aIsExecutingOnLoadHandler);
3174 3175
    nsresult GetLayoutHistoryState(nsILayoutHistoryState **aLayoutHistoryState);
    nsresult SetLayoutHistoryState(nsILayoutHistoryState *aLayoutHistoryState);
3176
    nsresult GetShouldSaveLayoutState(bool *aShouldSaveLayoutState);
3177 3178 3179 3180
    nsresult GetSecurityUI(nsISecureBrowserUI **aSecurityUI);
    nsresult SetSecurityUI(nsISecureBrowserUI *aSecurityUI);
    nsresult SuspendRefreshURIs();
    nsresult ResumeRefreshURIs();
3181
    nsresult BeginRestore(nsIContentViewer *viewer, bool top);
3182
    nsresult FinishRestore();
3183 3184 3185
    nsresult GetRestoringDocument(bool *aRestoringDocument);
    nsresult GetUseErrorPages(bool *aUseErrorPages);
    nsresult SetUseErrorPages(bool aUseErrorPages);
3186 3187 3188
    nsresult GetPreviousTransIndex(PRInt32 *aPreviousTransIndex);
    nsresult GetLoadedTransIndex(PRInt32 *aLoadedTransIndex);
    nsresult HistoryPurged(PRInt32 numEntries);
3189 3190
    nsresult GetSessionStorageForURI(nsIURI *uri, const nsAString *documentURI, nsIDOMStorage **_retval);
    nsresult GetSessionStorageForPrincipal(nsIPrincipal *principal, const nsAString *documentURI,
3191
            bool create, nsIDOMStorage **_retval);
3192
    nsresult AddSessionStorage(nsIPrincipal *principal, nsIDOMStorage *storage);
3193
    nsresult GetCurrentDocumentChannel(nsIChannel **aCurrentDocumentChannel);
3194
    nsresult SetChildOffset(PRUint32 offset);
3195 3196
    nsresult GetIsInUnload(bool *aIsInUnload);
    nsresult GetChannelIsUnsafe(bool *aChannelIsUnsafe);
3197
    void DetachEditorFromWindow();
3198 3199
    nsresult GetIsOffScreenBrowser(bool *aIsOffScreenBrowser);
    nsresult SetIsOffScreenBrowser(bool aIsOffScreenBrowser);
3200
    nsresult GetPrintPreview(nsIWebBrowserPrint **aPrintPreview);
3201 3202 3203
    nsresult GetCanExecuteScripts(bool *aCanExecuteScripts);
    nsresult GetIsActive(bool *aIsActive);
    nsresult SetIsActive(bool aIsActive);
3204
    nsresult GetHistoryID(PRUint64 *aHistoryID);
3205 3206
    nsresult GetIsAppTab(bool *aIsAppTab);
    nsresult SetIsAppTab(bool aIsAppTab);
3207
    nsresult CreateAboutBlankContentViewer(nsIPrincipal *aPrincipal);
3208 3209
}

3210 3211
[
    object,
3212
    uuid(85eea794-ed8e-4e1b-a128-d09300ae51aa),
3213 3214 3215 3216 3217 3218 3219 3220
    local
]
interface nsIMutationObserver : nsISupports
{
    void CharacterDataWillChange(nsIDocument *aDocument, nsIContent *aContent,
                                 void /*CharacterDataChangeInfo*/ *aInfo);
    void CharacterDataChanged(nsIDocument *aDocument, nsIContent *aContent,
                              void /*CharacterDataChangeInfo*/ *aInfo);
3221
    void AttributeWillChange(nsIDocument *aDocument, nsIContent *aContent, PRInt32 aNameSpaceID,
3222
                             nsIAtom *aAttribute, PRInt32 aModType);
3223
    void AttributeChanged(nsIDocument *aDocument, nsIContent *aContent, PRInt32 aNameSpaceID,
3224
                          nsIAtom *aAttribute, PRInt32 aModType);
3225
    void ContentAppended(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aFirstNewContent,
3226
                         PRInt32 aNewIndexInContainer);
3227 3228 3229
    void ContentInserted(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
                         PRInt32 aIndexInContainer);
    void ContentRemoved(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
3230
                        PRInt32 aIndexInContainer, nsIContent *aPreviousSibling);
3231 3232 3233 3234
    void NodeWillBeDestroyed(const nsINode *aNode);
    void ParentChainChanged(nsIContent *aContent);
}

3235 3236
[
    object,
3237
    uuid(c9169398-897a-481d-a95f-d6606ef83756),
3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254
    local
]
interface nsIParser : nsISupports
{
    typedef int nsDTDMode;
    typedef int eParserCommands;

    void SetContentSink(nsIContentSink *aSink);
    nsIContentSink *GetContentSink();
    void GetCommand(nsACString *aCommand);
    void SetCommand2(const char *aCommand);
    void SetCommand(eParserCommands aParserCommand);
    void SetDocumentCharset(const nsACString *aCharset, PRInt32 aSource);
    void GetDocumentCharset(nsACString *oCharset, PRInt32 *oSource);
    void SetParserFilter(nsIParserFilter *aFilter);
    nsresult GetChannel(nsIChannel **aChannel);
    nsresult GetDTD(nsIDTD **aDTD);
3255
    nsIStreamListener *GetStreamListener();
3256 3257 3258
    nsresult ContinueInterruptedParsing();
    void BlockParser();
    void UnblockParser();
3259 3260
    bool IsParserEnabled();
    bool IsComplete();
3261
    nsresult Parse(nsIURI *aURL, nsIRequestObserver *aListener, void *aKey, nsDTDMode aMode);
3262
    nsresult Parse2(const nsAString *aSourceBuffer, void *aKey, const nsACString *aMimeType, bool aLastCall, nsDTDMode aMode);
3263 3264
    void *GetRootContextKey();
    nsresult Terminate();
3265
    nsresult ParseFragment(const nsAString *aSourceBuffer, void /*nsTArray<nsString>*/ *aTagStack);
3266 3267
    nsresult BuildModel();
    nsresult CancelParsingEvents();
3268
    void Reset();
3269 3270
    bool CanInterrupt();
    bool IsInsertionPointDefined();
3271 3272
    void BeginEvaluatingParserInsertedScript();
    void EndEvaluatingParserInsertedScript();
3273
    void MarkAsNotScriptCreated(const char *aCommand);
3274
    bool IsScriptCreated();
3275 3276
}

3277 3278
[
    object,
3279
    uuid(900bc4bc-8b6c-4cba-82fa-568a80fffd3e),
3280 3281 3282 3283
    local
]
interface nsIDocumentObserver : nsIMutationObserver
{
3284
    typedef PRUint32 nsUpdateType;
3285

3286 3287 3288 3289
    typedef struct {
        PRUint64 mStates;
    } nsEventStates;

3290 3291 3292 3293
    void BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
    void EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
    void BeginLoad(nsIDocument *aDocument);
    void EndLoad(nsIDocument *aDocument);
3294 3295
    void ContentStatesChanged(nsIDocument *aDocument, nsIContent *aContent, nsEventStates *aStateMask);
    void DocumentStatesChanged(nsIDocument *aDocument, nsEventStates *aStateMask);
3296 3297
    void StyleSheetAdded(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, bool aDocumentSheet);
    void StyleSheetRemoved(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, bool aDocumentSheet);
3298
    void StyleSheetApplicableStateChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet,
3299
                                          bool aApplicable);
3300 3301 3302 3303 3304
    void StyleRuleChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aOldStyleRule,
                          nsIStyleRule *aNewStyleRule);
    void StyleRuleAdded(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule);
    void StyleRuleRemoved(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule);
    void BindToDocument(nsIDocument *aDocument, nsIContent *aContent);
3305
    void AttemptToExecuteScript(nsIContent *aContent, nsIParser *aParser, bool *aBlock);
3306 3307 3308 3309 3310 3311 3312 3313 3314
}

[
    object,
    uuid(3682dd99-8560-44f4-9b8f-ccce9d7b96fb),
    local
]
interface nsIContentUtils : nsISupports
{
3315
    bool IsSafeToRunScript();
3316 3317 3318 3319 3320
    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);
3321
}
3322

3323 3324
[
    object,
3325
    uuid(8f672000-bab9-4c60-aaaf-2673c4e2a4c6),
3326 3327 3328 3329 3330 3331
    local
]
interface nsIPluginInstance : nsISupports
{
    nsresult GetDOMElement(nsIDOMElement **aDOMElement);
}