dlls/mshtml/nsiface.idl

   1 /*
   2  * Copyright 2005-2007 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * 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  * This file is not a typical idl file. Interfaces in this file are XPCOM
  22  * interfaces (NOT MSCOM!), but we generate the header file with WIDL
  23  * compatible with XPCOM, usable in C code.
  24  */
  25
  26 cpp_quote("#define GECKO_VERSION \"1.2.0\"")
  27 cpp_quote("#define GECKO_VERSION_STRING \"Wine Gecko \" GECKO_VERSION")
  28
  29 import "wtypes.idl";
  30
  31 cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
  32 cpp_quote("#undef GetForm")
  33 cpp_quote("#undef SetPort")
  34 cpp_quote("#endif")
  35
  36 typedef HRESULT nsresult;
  37 typedef ULONG nsrefcnt;
  38
  39 typedef IID nsID;
  40 typedef IID nsIID;
  41 typedef nsIID nsCID;
  42 typedef REFIID nsIIDRef;
  43 typedef nsIIDRef nsCIDRef;
  44
  45 typedef WCHAR PRUnichar;
  46 typedef ULONG PRUint32;
  47 typedef LONG PRInt32;
  48 typedef WORD PRUint16;
  49 typedef INT16 PRInt16;
  50 typedef BYTE PRUint8;
  51 typedef BOOL PRBool;
  52 typedef LONGLONG PRInt64;
  53 typedef ULONGLONG PRUint64;
  54 typedef PRUint64 DOMTimeStamp;
  55 typedef PRUint32 nsLoadFlags;
  56
  57 typedef struct {
  58     void *v;
  59     void *d1;
  60     PRUint32 d2;
  61     void *d3;
  62 } nsCStringContainer;
  63
  64 typedef struct {
  65     void *v;
  66     void *d1;
  67     PRUint32 d2;
  68     void *d3;
  69 } nsStringContainer;
  70
  71 typedef nsCStringContainer nsACString;
  72 typedef nsStringContainer nsAString;
  73
  74 interface nsIWebBrowserChrome;
  75 interface nsILoadGroup;
  76 interface nsIDOMNode;
  77 interface nsIDOMDocument;
  78 interface nsIDOMEvent;
  79 interface nsIEditor;
  80 interface nsISelectionController;
  81 interface nsITransactionManager;
  82 interface nsITransaction;
  83 interface nsIInlineSpellChecker;
  84 interface nsIOutputStream;
  85 interface nsIEditorObserver;
  86 interface nsIEditActionListener;
  87 interface nsIDocumentStateListener;
  88 interface nsIDOMCSSStyleSheet;
  89 interface nsIDOMDocumentView;
  90 interface nsIDOMWindow;
  91 interface nsIDOMElement;
  92
  93 interface IMoniker;
  94
  95 [
  96     object,
  97     uuid(00000000-0000-0000-c000-000000000046),
  98     local
  99 ]
 100 interface nsISupports
 101 {
 102     nsresult QueryInterface(nsIIDRef riid, void **result);
 103     nsrefcnt AddRef();
 104     nsrefcnt Release();
 105 }
 106
 107 /* Currently we don't need a full declaration of these interfaces */
 108 typedef nsISupports nsISHistory;
 109 typedef nsISupports nsIWidget;
 110 typedef nsISupports nsIDOMBarProp;
 111 typedef nsISupports nsIPrompt;
 112 typedef nsISupports nsIAuthPrompt;
 113 typedef nsISupports nsIDOMDocumentType;
 114 typedef nsISupports nsIDOMDOMImplementation;
 115 typedef nsISupports nsIDOMCDATASection;
 116 typedef nsISupports nsIDOMProcessingInstruction;
 117 typedef nsISupports nsIDOMEntityReference;
 118 typedef nsISupports nsIWebProgressListener;
 119 typedef nsISupports nsIDOMCSSValue;
 120 typedef nsISupports nsIPrintSession;
 121 typedef nsISupports nsIControllerCommandTable;
 122 typedef nsISupports nsIPrincipal;
 123 typedef nsISupports nsIAtom;
 124 typedef nsISupports nsISupportsArray;
 125 typedef nsISupports nsIContentFilter;
 126 typedef nsISupports nsIDOMMediaList;
 127 typedef nsISupports nsIDOMHTMLTableCaptionElement;
 128 typedef nsISupports nsIDOMHTMLTableSectionElement;
 129 typedef nsISupports nsIDOMClientRectList;
 130 typedef nsISupports nsIDOMLocation;
 131 typedef nsISupports nsINode;
 132 typedef nsISupports nsIStyleSheet;
 133 typedef nsISupports nsIStyleRule;
 134 typedef nsISupports nsIVariant;
 135 typedef nsISupports nsIDOMUserDataHandler;
 136 typedef nsISupports nsIDocShellLoadInfo;
 137 typedef nsISupports nsISHEntry;
 138 typedef nsISupports nsIPresShell;
 139 typedef nsISupports nsIContentViewer;
 140 typedef nsISupports nsIDocumentCharsetInfo;
 141 typedef nsISupports nsILayoutHistoryState;
 142 typedef nsISupports nsISecureBrowserUI;
 143 typedef nsISupports nsIDOMStorage;
 144 typedef nsISupports nsIDOMDOMTokenList;
 145 typedef nsISupports nsITransferable;
 146 typedef nsISupports nsIDOMHTMLHeadElement;
 147 typedef nsISupports nsIDOMFileList;
 148 typedef nsISupports nsIControllers;
 149 typedef nsISupports nsIDOMValidityState;
 150 typedef nsISupports nsIPluginInstanceOwner;
 151 typedef nsISupports nsIPluginStreamListener;
 152 typedef nsISupports nsIContentSink;
 153 typedef nsISupports nsIParserFilter;
 154 typedef nsISupports nsIDTD;
 155 typedef nsISupports nsIObserver;
 156
 157 [
 158     object,
 159     uuid(8bb35ed9-e332-462d-9155-4a002ab5c958),
 160     local
 161 ]
 162 interface nsIServiceManager : nsISupports
 163 {
 164     nsresult GetService(nsCIDRef aClass, nsIIDRef aIID, void **result);
 165     nsresult GetServiceByContractID(const char *aContractID, nsIIDRef aIID, void **result);
 166     nsresult IsServiceInstantiated(nsCIDRef aClass, nsIIDRef aIID, BOOL *_retval);
 167     nsresult IsServiceInstantiatedByContractID(const char *aContractID, nsIIDRef aIID, BOOL *_retval);
 168 }
 169
 170 [
 171     object,
 172     uuid(00000001-0000-0000-c000-000000000046),
 173     local
 174 ]
 175 interface nsIFactory : nsISupports
 176 {
 177     nsresult CreateInstance(nsISupports *aOuter, const nsIID *iid, void **result);
 178     nsresult LockFactory(PRBool lock);
 179 }
 180
 181 [
 182     object,
 183     uuid(a88e5a60-205a-4bb1-94e1-2628daf51eae),
 184     local
 185 ]
 186 interface nsIComponentManager : nsISupports
 187 {
 188     nsresult GetClassObject(nsCIDRef aClass, nsIIDRef aIID, void **result);
 189     nsresult GetClassObjectByContractID(const char *aContractID, nsIIDRef aIID, void **result);
 190     nsresult CreateInstance(nsCIDRef aClass, nsISupports *aDelegate, nsIIDRef aIID,
 191             void **result);
 192     nsresult CreateInstanceByContractID(const char *aContractID, nsISupports *aDelegate,
 193             nsIIDRef aIID, void **result);
 194 }
 195
 196 [
 197     object,
 198     uuid(59e7e77a-38e4-11d4-8cf5-0060b0fc14a3),
 199     local
 200 ]
 201 interface nsIMemory : nsISupports
 202 {
 203     void *Alloc(/*size_t*/ int size);
 204     void *Realloc(void *_ptr, /*size_t*/ int newSize);
 205     void Free(void *_ptr);
 206     nsresult HeapMinimize(PRBool immediate);
 207     nsresult IsLowMemory(PRBool *_retval);
 208 }
 209
 210 [
 211     object,
 212     uuid(9188bc85-f92e-11d2-81ef-0060083a0bcf),
 213     local
 214 ]
 215 interface nsIWeakReference : nsISupports
 216 {
 217     nsresult QueryReferent(const nsIID *riid, void **result);
 218 }
 219
 220 [
 221     object,
 222     uuid(9188bc86-f92e-11d2-81ef-0060083a0bcf),
 223     local
 224 ]
 225 interface nsISupportsWeakReference : nsISupports
 226 {
 227     nsresult GetWeakReference(nsIWeakReference **_retval);
 228 }
 229
 230 [
 231     object,
 232     uuid(033a1470-8b2a-11d3-af88-00a024ffc08c),
 233     local
 234 ]
 235 interface nsIInterfaceRequestor : nsISupports
 236 {
 237     nsresult GetInterface(const nsIID *riid, void **result);
 238 }
 239
 240 [
 241     object,
 242     uuid(4a2abaf0-6886-11d3-9382-00104ba0fd40),
 243     local
 244 ]
 245 interface nsIRunnable : nsISupports
 246 {
 247     nsresult Run();
 248 }
 249
 250 [
 251     object,
 252     uuid(d1899240-f9d2-11d2-bdd6-000064657374),
 253     local
 254 ]
 255 interface nsISimpleEnumerator : nsISupports
 256 {
 257     nsresult HasMoreElements(PRBool *_retval);
 258     nsresult GetNext(nsISupports **_retval);
 259 }
 260
 261 [
 262     object,
 263     uuid(fa9c7f6c-61b3-11d4-9877-00c04fa0cf4a),
 264     local
 265 ]
 266 interface nsIInputStream : nsISupports
 267 {
 268     nsresult Close();
 269     nsresult Available(PRUint32 *_retval);
 270     nsresult Read(char *aBuf, PRUint32 aCount, PRUint32 *_retval);
 271     nsresult ReadSegments(nsresult (*aWriter)(nsIInputStream *aInStream,
 272             void *aClosure, const char *aFromSegment, PRUint32 aToOffset,
 273             PRUint32 aCount, PRUint32 *aWriteCount),
 274             void *aClosure, PRUint32 aCount, PRUint32 *_retval);
 275     nsresult IsNonBlocking(PRBool *_retval);
 276 }
 277
 278 [
 279     object,
 280     uuid(07a22cc0-0ce5-11d3-9331-00104ba0fd40),
 281     local
 282 ]
 283 interface nsIURI : nsISupports
 284 {
 285     nsresult GetSpec(nsACString *aSpec);
 286     nsresult SetSpec(const nsACString *aSpec);
 287     nsresult GetPrePath(nsACString *aPrePath);
 288     nsresult GetScheme(nsACString *aScheme);
 289     nsresult SetScheme(const nsACString *aScheme);
 290     nsresult GetUserPass(nsACString *aUserPass);
 291     nsresult SetUserPass(const nsACString *aUserPass);
 292     nsresult GetUsername(nsACString *aUsername);
 293     nsresult SetUsername(const nsACString *aUsername);
 294     nsresult GetPassword(nsACString *aPassword);
 295     nsresult SetPassword(const nsACString *aPassword);
 296     nsresult GetHostPort(nsACString *aHostPort);
 297     nsresult SetHostPort(const nsACString *aHostPort);
 298     nsresult GetHost(nsACString *aHost);
 299     nsresult SetHost(const nsACString *aHost);
 300     nsresult GetPort(PRInt32 *aPort);
 301     nsresult SetPort(PRInt32 aPort);
 302     nsresult GetPath(nsACString *aPath);
 303     nsresult SetPath(const nsACString *aPath);
 304     nsresult Equals(nsIURI *other, PRBool *_retval);
 305     nsresult SchemeIs(const char *scheme, PRBool *_retval);
 306     nsresult Clone(nsIURI **_retval);
 307     nsresult Resolve(const nsACString *relativePath, nsACString *_retval);
 308     nsresult GetAsciiSpec(nsACString *aAsciiSpec);
 309     nsresult GetAsciiHost(nsACString *aAsciiHost);
 310     nsresult GetOriginCharset(nsACString *aOriginCharset);
 311 }
 312
 313 [
 314     object,
 315     uuid(d6116970-8034-11d3-9399-00104ba0fd40),
 316     local
 317 ]
 318 interface nsIURL : nsIURI
 319 {
 320     nsresult GetFilePath(nsACString *aFilePath);
 321     nsresult SetFilePath(const nsACString *aFilePath);
 322     nsresult GetParam(nsACString *aParam);
 323     nsresult SetParam(const nsACString *aParam);
 324     nsresult GetQuery(nsACString *aQuery);
 325     nsresult SetQuery(const nsACString *aQuery);
 326     nsresult GetRef(nsACString *aRef);
 327     nsresult SetRef(const nsACString *aRef);
 328     nsresult GetDirectory(nsACString *aDirectory);
 329     nsresult SetDirectory(const nsACString *aDirectory);
 330     nsresult GetFileName(nsACString *aFileName);
 331     nsresult SetFileName(const nsACString *aFileName);
 332     nsresult GetFileBaseName(nsACString *aFileBaseName);
 333     nsresult SetFileBaseName(const nsACString *aFileBaseName);
 334     nsresult GetFileExtension(nsACString *aFileExtension);
 335     nsresult SetFileExtension(const nsACString *aFileExtension);
 336     nsresult GetCommonBaseSpec(nsIURI *aURIToCompare, nsACString *_retval);
 337     nsresult GetRelativeSpec(nsIURI *aURIToCompare, nsACString *_retval);
 338 }
 339
 340 [
 341     object,
 342     uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe),
 343     local
 344 ]
 345 interface nsIRequest : nsISupports
 346 {
 347     nsresult GetName(nsACString *aName);
 348     nsresult IsPending(PRBool *_retval);
 349     nsresult GetStatus(nsresult *aStatus);
 350     nsresult Cancel(nsresult aStatus);
 351     nsresult Suspend();
 352     nsresult Resume();
 353     nsresult GetLoadGroup(nsILoadGroup **aLoadGroup);
 354     nsresult SetLoadGroup(nsILoadGroup *aLoadGroup);
 355     nsresult GetLoadFlags(nsLoadFlags *aLoadFlags);
 356     nsresult SetLoadFlags(nsLoadFlags aLoadFlags);
 357 }
 358
 359 [
 360     object,
 361     uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40),
 362     local
 363 ]
 364 interface nsIRequestObserver : nsISupports
 365 {
 366     nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext);
 367     nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode);
 368 }
 369
 370 [
 371     object,
 372     uuid(1a637020-1482-11d3-9333-00104ba0fd40),
 373     local
 374 ]
 375 interface nsIStreamListener : nsIRequestObserver
 376 {
 377     nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
 378                              nsIInputStream *aInputStream, PRUint32 aOffset, PRUint32 aCount);
 379 }
 380
 381 [
 382     object,
 383     uuid(3de0a31c-feaf-400f-9f1e-4ef71f8b20cc),
 384     local
 385 ]
 386 interface nsILoadGroup : nsIRequest
 387 {
 388     nsresult GetGroupObserver(nsIRequestObserver **aGroupObserver);
 389     nsresult SetGroupObserver(nsIRequestObserver *aGroupObserver);
 390     nsresult GetDefaultLoadRequest(nsIRequest **aDefaultLoadRequest);
 391     nsresult SetDefaultLoadRequest(nsIRequest *aDefaultLoadRequest);
 392     nsresult AddRequest(nsIRequest *aRequest, nsISupports *aContext);
 393     nsresult RemoveRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatus);
 394     nsresult GetRequests(nsISimpleEnumerator **aRequests);
 395     nsresult GetActiveCount(PRUint32 *aActiveCount);
 396     nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
 397     nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
 398 }
 399
 400 [
 401     object,
 402     uuid(c63a055a-a676-4e71-bf3c-6cfa11082018),
 403     local
 404 ]
 405 interface nsIChannel : nsIRequest
 406 {
 407     nsresult GetOriginalURI(nsIURI **aOriginalURI);
 408     nsresult SetOriginalURI(nsIURI *aOriginalURI);
 409     nsresult GetURI(nsIURI **aURI);
 410     nsresult GetOwner(nsISupports **aOwner);
 411     nsresult SetOwner(nsISupports *aOwner);
 412     nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
 413     nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
 414     nsresult GetSecurityInfo(nsISupports **aSecurityInfo);
 415     nsresult GetContentType(nsACString *aContentType);
 416     nsresult SetContentType(const nsACString *aContentType);
 417     nsresult GetContentCharset(nsACString *aContentCharset);
 418     nsresult SetContentCharset(const nsACString *aContentCharset);
 419     nsresult GetContentLength(PRInt32 *aContentLength);
 420     nsresult SetContentLength(PRInt32 aContentLength);
 421     nsresult Open(nsIInputStream **_retval);
 422     nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext);
 423 }
 424
 425 [
 426     object,
 427     uuid(0cf40717-d7c1-4a94-8c1e-d6c9734101bb),
 428     local
 429 ]
 430 interface nsIHttpHeaderVisitor : nsISupports
 431 {
 432     nsresult VisitHeader(const nsACString *aHeader, const nsACString *aValue);
 433 }
 434
 435 [
 436     object,
 437     uuid(9277fe09-f0cc-4cd9-bbce-581dd94b0260),
 438     local
 439 ]
 440 interface nsIHttpChannel : nsIChannel
 441 {
 442     nsresult GetRequestMethod(nsACString *aRequestMethod);
 443     nsresult SetRequestMethod(const nsACString *aRequestMethod);
 444     nsresult GetReferrer(nsIURI **aReferrer);
 445     nsresult SetReferrer(nsIURI *aReferrer);
 446     nsresult GetRequestHeader(const nsACString *aHeader, nsACString *_retval);
 447     nsresult SetRequestHeader(const nsACString *aHeader, const nsACString *aValue, PRBool aMerge);
 448     nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
 449     nsresult GetAllowPipelining(PRBool *aAllowPipelining);
 450     nsresult SetAllowPipelining(PRBool aAllowPipelining);
 451     nsresult GetRedirectionLimit(PRUint32 *aRedirectionLimit);
 452     nsresult SetRedirectionLimit(PRUint32 aRedirectionLimit);
 453     nsresult GetResponseStatus(PRUint32 *aResponseStatus);
 454     nsresult GetResponseStatusText(nsACString *aResponseStatusText);
 455     nsresult GetRequestSucceeded(PRBool *aRequestSucceeded);
 456     nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
 457     nsresult SetResponseHeader(const nsACString *header, const nsACString *value, PRBool merge);
 458     nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor);
 459     nsresult IsNoStoreResponse(PRBool *_retval);
 460     nsresult IsNoCacheResponse(PRBool *_retval);
 461 }
 462
 463 [
 464     object,
 465     uuid(9fb2a161-d075-4bf2-b07a-26bac650cc81),
 466     local
 467 ]
 468 interface nsIHttpChannelInternal : nsISupports
 469 {
 470     nsresult GetDocumentURI(nsIURI **aDocumentURI);
 471     nsresult SetDocumentURI(nsIURI *aDocumentURI);
 472     nsresult GetRequestVersion(PRUint32 *major, PRUint32 *minor);
 473     nsresult GetResponseVersion(PRUint32 *major, PRUint32 *minor);
 474     nsresult SetCookie(const char *aCookieHeader);
 475     nsresult SetupFallbackChannel(const char *aFallbackKey);
 476     nsresult GetForceAllowThirdPartyCookie(PRBool *aForceAllowThirdPartyCookie);
 477     nsresult SetForceAllowThirdPartyCookie(PRBool aForceAllowThirdPartyCookie);
 478     nsresult GetCanceled(PRBool *aCanceled);
 479     nsresult GetChannelIsForDownload(PRBool *aChannelIsForDownload);
 480     nsresult SetChannelIsForDownload(PRBool aChannelIsForDownload);
 481 }
 482
 483 [
 484     object,
 485     uuid(ddf633d8-e9a4-439d-ad88-de636fd9bb75),
 486     local
 487 ]
 488 interface nsIUploadChannel : nsISupports
 489 {
 490     nsresult SetUploadStream(nsIInputStream *aStream, const nsACString *aContentType,
 491                              PRInt32 aContentLength);
 492     nsresult GetUploadStream(nsIInputStream **aUploadStream);
 493 }
 494
 495 [
 496     object,
 497     uuid(8d171460-a716-41f1-92be-8c659db39b45),
 498     local
 499 ]
 500 interface nsIAsyncVerifyRedirectCallback : nsISupports
 501 {
 502     nsresult OnRedirectVerifyCallback(nsresult result);
 503 }
 504
 505 [
 506     object,
 507     uuid(a430d870-df77-4502-9570-d46a8de33154),
 508     local
 509 ]
 510 interface nsIChannelEventSink : nsISupports
 511 {
 512     cpp_quote("#define REDIRECT_TEMPORARY 1")
 513     cpp_quote("#define REDIRECT_PERMANENT 2")
 514     cpp_quote("#define REDIRECT_INTERNAL  4")
 515
 516     nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, PRUint32 flags,
 517                                     nsIAsyncVerifyRedirectCallback *callback);
 518 }
 519
 520 [
 521     object,
 522     uuid(a6cf90c1-15b3-11d2-932e-00805f8add32),
 523     local
 524 ]
 525 interface nsIDOMCSSRule : nsISupports
 526 {
 527     nsresult GetType(PRUint16 *aType);
 528     nsresult GetCssText(nsAString *aCssText);
 529     nsresult SetCssText(const nsAString *aCssText);
 530     nsresult GetParentStyleSheet(nsIDOMCSSStyleSheet **aParentStyleSheet);
 531     nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
 532 }
 533
 534 [
 535     object,
 536     uuid(a6cf90be-15b3-11d2-932e-00805f8add32),
 537     local
 538 ]
 539 interface nsIDOMCSSStyleDeclaration : nsISupports
 540 {
 541     nsresult GetCssText(nsAString *aCssText);
 542     nsresult SetCssText(const nsAString *aCssText);
 543     nsresult GetPropertyValue(const nsAString *propertyName, nsAString *_retval);
 544     nsresult GetPropertyCSSValue(const nsAString *propertyName, nsIDOMCSSValue **_retval);
 545     nsresult RemoveProperty(const nsAString *propertyName, nsAString *_retval);
 546     nsresult GetPropertyPriority(const nsAString *propertyName, nsAString *_retval);
 547     nsresult SetProperty(const nsAString *propertyName, const nsAString *value,
 548                          const nsAString *priority);
 549     nsresult GetLength(PRUint32 *aLength);
 550     nsresult Item(PRUint32 index, nsAString *_retval);
 551     nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
 552 }
 553
 554 [
 555     object,
 556     uuid(a6cf90c0-15b3-11d2-932e-00805f8add32),
 557     local
 558 ]
 559 interface nsIDOMCSSRuleList : nsISupports
 560 {
 561     nsresult GetLength(PRUint32 *aLength);
 562     nsresult Item(PRUint32 index, nsIDOMCSSRule **_retval);
 563 }
 564
 565 [
 566     object,
 567     uuid(a6cf9080-15b3-11d2-932e-00805f8add32),
 568     local
 569 ]
 570 interface nsIDOMStyleSheet : nsISupports
 571 {
 572     nsresult GetType(nsAString *aType);
 573     nsresult GetDisabled(PRBool *aDisabled);
 574     nsresult SetDisabled(PRBool aDisabled);
 575     nsresult GetOwnerNode(nsIDOMNode **aOwnerNode);
 576     nsresult GetParentStyleSheet(nsIDOMStyleSheet **aParentStyleSheet);
 577     nsresult GetHref(nsAString *aHref);
 578     nsresult GetTitle(nsAString *aTitle);
 579     nsresult GetMedia(nsIDOMMediaList **aMedia);
 580 }
 581
 582 [
 583     object,
 584     uuid(a6cf90c2-15b3-11d2-932e-00805f8add32),
 585     local
 586 ]
 587 interface nsIDOMCSSStyleSheet : nsIDOMStyleSheet
 588 {
 589     nsresult GetOwnerRule(nsIDOMCSSRule **aOwnerRule);
 590     nsresult GetCssRules(nsIDOMCSSRuleList **aCssRules);
 591     nsresult InsertRule(const nsAString *rule, PRUint32 index, PRUint32 *_retval);
 592     nsresult DeleteRule(PRUint32 index);
 593 }
 594
 595 [
 596     object,
 597     uuid(a6cf9081-15b3-11d2-932e-00805f8add32),
 598     local
 599 ]
 600 interface nsIDOMStyleSheetList : nsISupports
 601 {
 602     nsresult GetLength(PRUint32 *aLength);
 603     nsresult Item(PRUint32 index, nsIDOMStyleSheet **_retval);
 604 }
 605
 606 [
 607     object,
 608     uuid(a6cf907d-15b3-11d2-932e-00805f8add32),
 609     local
 610 ]
 611 interface nsIDOMNodeList : nsISupports
 612 {
 613     nsresult Item(PRUint32 index, nsIDOMNode **_retval);
 614     nsresult GetLength(PRUint32 *aLength);
 615 }
 616
 617 [
 618     object,
 619     uuid(29fb2a18-1dd2-11b2-8dd9-a6fd5d5ad12f),
 620     local
 621 ]
 622 interface nsIDOM3Node : nsISupports
 623 {
 624     enum NSDOCPOSITION {
 625         DISCONNECTED = 1,
 626         PRECEDING = 2,
 627         FOLLOWING = 4,
 628         CONTAINS = 8,
 629         CONTAINED_BY = 16,
 630         IMPLEMENTATION_SPECIFIC = 32
 631     };
 632
 633     nsresult GetBaseURI(nsAString *aBaseURI);
 634     nsresult CompareDocumentPosition(nsIDOMNode *other, PRUint16 *_retval);
 635     nsresult GetTextContent(nsAString *aTextContent);
 636     nsresult SetTextContent(const nsAString *aTextContent);
 637     nsresult IsSameNode(nsIDOMNode *other, PRBool *_retval);
 638     nsresult LookupPrefix(const nsAString *namespaceURI, PRBool *_retval);
 639     nsresult IsDefaultNamespace(const nsAString *namespaceURI, PRBool *_retval);
 640     nsresult LookupNamespaceURI(const nsAString *prefix, nsAString _retval);
 641     nsresult IsEqualNode(nsIDOMNode *arg, PRBool *_retval);
 642     nsresult GetFeature(const nsAString *feature, const nsAString *version, nsISupports **_retval);
 643     nsresult SetUserData(const nsAString *key, nsIVariant *data, nsIDOMUserDataHandler *handler, nsIVariant **_retval);
 644     nsresult GetUserData(const nsAString *key, nsIVariant **_retval);
 645 }
 646
 647 [
 648     object,
 649     uuid(a6cf907b-15b3-11d2-932e-00805f8add32),
 650     local
 651 ]
 652 interface nsIDOMNamedNodeMap : nsISupports
 653 {
 654     nsresult GetNamedItem(const nsAString *name, nsIDOMNode **_retval);
 655     nsresult SetNamedItem(nsIDOMNode *arg, nsIDOMNode **_retval);
 656     nsresult RemoveNamedItem(const nsAString *name, nsIDOMNode **_retval);
 657     nsresult Item(PRUint32 index, nsIDOMNode **_retval);
 658     nsresult GetLength(PRUint32 *aLength);
 659     nsresult GetNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMNode **_retval);
 660     nsresult SetNamedItemNS(nsIDOMNode *arg, nsIDOMNode **_retval);
 661     nsresult RemoveNamedItemNS(const nsAString *namespaceURI, const nsAString *localName, nsIDOMNode **_retval);
 662 }
 663
 664 [
 665     object,
 666     uuid(a6cf907c-15b3-11d2-932e-00805f8add32),
 667     local
 668 ]
 669 interface nsIDOMNode : nsISupports
 670 {
 671     enum NSNODETYPE {
 672         ELEMENT_NODE = 1,
 673         ATTRIBUTE_NODE = 2,
 674         TEXT_NODE = 3,
 675         CDATA_SELECTION_NODE = 4,
 676         ENTITY_REFERENCE_NODE = 5,
 677         ENTITY_NODE = 6,
 678         PROCESSING_INSTRUCTION_NODE = 7,
 679         COMMENT_NODE = 8,
 680         DOCUMENT_NODE = 9,
 681         DOCUMENT_TYPE_NODE = 10,
 682         DOCUMENT_FRAGMENT_NODE = 11,
 683         NOTATION_NODE = 12
 684     };
 685
 686     nsresult GetNodeName(nsAString *aNodeName);
 687     nsresult GetNodeValue(nsAString *aNodeValue);
 688     nsresult SetNodeValue(const nsAString *aNodeValue);
 689     nsresult GetNodeType(PRUint16 *aNodeType);
 690     nsresult GetParentNode(nsIDOMNode **aParentNode);
 691     nsresult GetChildNodes(nsIDOMNodeList **aChildNodes);
 692     nsresult GetFirstChild(nsIDOMNode **aFirstChild);
 693     nsresult GetLastChild(nsIDOMNode **aLastChild);
 694     nsresult GetPreviousSibling(nsIDOMNode **aPreviousSibling);
 695     nsresult GetNextSibling(nsIDOMNode **aNextSibling);
 696     nsresult GetAttributes(nsIDOMNamedNodeMap **aAttributes);
 697     nsresult GetOwnerDocument(nsIDOMDocument **aOwnerDocument);
 698     nsresult InsertBefore(nsIDOMNode *newChild, nsIDOMNode *refChild, nsIDOMNode **_retval);
 699     nsresult ReplaceChild(nsIDOMNode *newChild, nsIDOMNode *oldChild, nsIDOMNode **_retval);
 700     nsresult RemoveChild(nsIDOMNode *oldChild, nsIDOMNode **_retval);
 701     nsresult AppendChild(nsIDOMNode *newChild, nsIDOMNode **_retval);
 702     nsresult HasChildNodes(PRBool *_retval);
 703     nsresult CloneNode(PRBool deep, nsIDOMNode **_retval);
 704     nsresult Normalize();
 705     nsresult IsSupported(const nsAString *feature, const nsAString *version, PRBool *_retval);
 706     nsresult GetNamespaceURI(nsAString *aNamespaceURI);
 707     nsresult GetPrefix(nsAString *aPrefix);
 708     nsresult SetPrefix(const nsAString *aPrefix);
 709     nsresult GetLocalName(nsAString *aLocalName);
 710     nsresult HasAttributes(PRBool *_retval);
 711 }
 712
 713 [
 714     object,
 715     uuid(a6cf9070-15b3-11d2-932e-00805f8add32),
 716     local
 717 ]
 718 interface nsIDOMAttr : nsIDOMNode
 719 {
 720     nsresult GetName(nsAString *aName);
 721     nsresult GetSpecified(PRBool *aSpecified);
 722     nsresult GetValue(nsAString *aValue);
 723     nsresult SetValue(const nsAString *aValue);
 724     nsresult GetOwnerElement(nsIDOMElement **aOwnerElement);
 725 }
 726
 727 [
 728     object,
 729     uuid(a6cf9078-15b3-11d2-932e-00805f8add32),
 730     local
 731 ]
 732 interface nsIDOMElement : nsIDOMNode
 733 {
 734     nsresult GetTagName(nsAString *aTagName);
 735     nsresult GetAttribute(const nsAString *name, nsAString *_retval);
 736     nsresult SetAttribute(const nsAString *name, const nsAString *value);
 737     nsresult RemoveAttribute(const nsAString *name);
 738     nsresult GetAttributeNode(const nsAString *name, nsIDOMAttr **_retval);
 739     nsresult SetAttributeNode(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
 740     nsresult RemoveAttributeNode(nsIDOMAttr *oldAttr, nsIDOMAttr **_retval);
 741     nsresult GetElementsByTagName(const nsAString *name, nsIDOMNodeList **_retval);
 742     nsresult GetAttributeNS(const nsAString *namespaceURI, const nsAString *localName,
 743                             nsAString *_retval);
 744     nsresult SetAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 745                             const nsAString *value);
 746     nsresult RemoveAttributeNS(const nsAString *namespaceURI, const nsAString *localName);
 747     nsresult GetAttributeNodeNS(const nsAString *namespaceURI, const nsAString *localName,
 748                                 nsIDOMAttr **_retval);
 749     nsresult SetAttributeNodeNS(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
 750     nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName,
 751                                     nsIDOMNodeList **_retval);
 752     nsresult HasAttribute(const nsAString *name, PRBool *_retval);
 753     nsresult HasAttributeNS(const nsAString *namespaceURI, const nsAString *localName,
 754                             PRBool *_retval);
 755 }
 756
 757 [
 758     object,
 759     uuid(99715845-95fc-4a56-aa53-214b65c26e22),
 760     local
 761 ]
 762 interface nsIDOMElementCSSInlineStyle : nsISupports
 763 {
 764     nsresult GetStyle(nsIDOMCSSStyleDeclaration **aStyle);
 765 }
 766
 767 [
 768     object,
 769     uuid(b2f824c4-d9d3-499b-8d3b-45c8245497c6),
 770     local
 771 ]
 772 interface nsIDOMClientRect : nsISupports
 773 {
 774     nsresult GetLeft(float *aLeft);
 775     nsresult GetTop(float *aTop);
 776     nsresult GetRight(float *aRight);
 777     nsresult GetBottom(float *aBottom);
 778     nsresult GetWidth(float *aWidth);
 779     nsresult GetHeight(float *aHeight);
 780 }
 781
 782 [
 783     object,
 784     uuid(d894b5d4-44f3-422a-a220-7763c12d4a94),
 785     local
 786 ]
 787 interface nsIDOMNSElement : nsISupports
 788 {
 789     nsresult GetElementsByClassName(const nsAString *classes, nsIDOMNodeList **_retval);
 790     nsresult GetClientRects(nsIDOMClientRectList **_retval);
 791     nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
 792     nsresult GetScrollTop(PRInt32 *aScrollTop);
 793     nsresult SetScrollTop(PRInt32 aScrollTop);
 794     nsresult GetScrollLeft(PRInt32 *aScrollLeft);
 795     nsresult SetScrollLeft(PRInt32 aScrollLeft);
 796     nsresult GetScrollHeight(PRInt32 *aScrollHeight);
 797     nsresult GetScrollWidth(PRInt32 *aScrollWidth);
 798     nsresult GetClientTop(PRInt32 *aClientTop);
 799     nsresult GetClientLeft(PRInt32 *aClientLeft);
 800     nsresult GetClientHeight(PRInt32 *aClientHeight);
 801     nsresult GetClientWidth(PRInt32 *aClientWidth);
 802     nsresult GetFirstElementChild(nsIDOMElement **aFirstElementChild);
 803     nsresult GetLastElementChild(nsIDOMElement **aLastElementChild);
 804     nsresult GetPreviousElementSibling(nsIDOMElement **aPreviousElementSibling);
 805     nsresult GetNextElementSibling(nsIDOMElement **aNextElementSibling);
 806     nsresult GetChildElementCount(PRUint32 *aChildElementCount);
 807     nsresult GetChildren(nsIDOMNodeList **aChildren);
 808     nsresult GetClassList(nsIDOMDOMTokenList **aClassList);
 809     nsresult SetCapture(PRBool retargetToElement);
 810     nsresult ReleaseCapture();
 811     nsresult MozMatchesSelector(const nsAString *selector, PRBool *_retval);
 812 }
 813
 814 cpp_quote("#undef GetClassName")
 815
 816 [
 817     object,
 818     uuid(a6cf9085-15b3-11d2-932e-00805f8add32),
 819     local
 820 ]
 821 interface nsIDOMHTMLElement : nsIDOMElement
 822 {
 823     nsresult GetId(nsAString *aId);
 824     nsresult SetId(const nsAString *aId);
 825     nsresult GetTitle(nsAString *aTitle);
 826     nsresult SetTitle(const nsAString *aTitle);
 827     nsresult GetLang(nsAString *aLang);
 828     nsresult SetLang(const nsAString *aLang);
 829     nsresult GetDir(nsAString *aDir);
 830     nsresult SetDir(const nsAString *aDir);
 831     nsresult GetClassName(nsAString *aClassName);
 832     nsresult SetClassName(const nsAString *aClassName);
 833 }
 834
 835 [
 836     object,
 837     uuid(f0ffe1d2-9615-492b-aae1-05428ebc2a70),
 838     local
 839 ]
 840 interface nsIDOMNSHTMLElement : nsISupports
 841 {
 842     nsresult GetOffsetTop(PRInt32 *aOffsetTop);
 843     nsresult GetOffsetLeft(PRInt32 *aOffsetLeft);
 844     nsresult GetOffsetWidth(PRInt32 *aOffsetWidth);
 845     nsresult GetOffsetHeight(PRInt32 *aOffsetHeight);
 846     nsresult GetOffsetParent(nsIDOMElement **aOffsetParent);
 847     nsresult GetInnerHTML(nsAString *aInnerHTML);
 848     nsresult SetInnerHTML(const nsAString *aInnerHTML);
 849     nsresult GetHidden(PRBool *aHidden);
 850     nsresult SetHidden(PRBool aHidden);
 851     nsresult GetTabIndex(PRInt32 *aTabIndex);
 852     nsresult SetTabIndex(PRInt32 aTabIndex);
 853     nsresult GetContentEditable(nsAString *aContentEditable);
 854     nsresult SetContentEditable(const nsAString *aContentEditable);
 855     nsresult GetIsContentEditable(PRBool *aIsContentEditable);
 856     nsresult GetDraggable(PRBool *aDraggable);
 857     nsresult SetDraggable(PRBool aDraggable);
 858     nsresult Blur();
 859     nsresult Focus();
 860     nsresult ScrollIntoView(PRBool top, PRUint8 _argc);
 861     nsresult GetSpellcheck(PRBool *aSpellcheck);
 862     nsresult SetSpellcheck(PRBool aSpellcheck);
 863 }
 864
 865 [
 866     object,
 867     uuid(a6cf9083-15b3-11d2-932e-00805f8add32),
 868     local
 869 ]
 870 interface nsIDOMHTMLCollection : nsISupports
 871 {
 872     nsresult GetLength(PRUint32 *aLength);
 873     nsresult Item(PRUint32 index, nsIDOMNode **_retval);
 874     nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
 875 }
 876
 877 [
 878     object,
 879     uuid(a6cf9072-15b3-11d2-932e-00805f8add32),
 880     local
 881 ]
 882 interface nsIDOMCharacterData : nsIDOMNode
 883 {
 884     nsresult GetData(nsAString *aData);
 885     nsresult SetData(const nsAString *aData);
 886     nsresult GetLength(PRUint32 *aLength);
 887     nsresult SubstringData(PRUint32 offset, PRUint32 count, nsAString *_retval);
 888     nsresult AppendData(const nsAString *arg);
 889     nsresult InsertData(PRUint32 offset, const nsAString *arg);
 890     nsresult DeleteData(PRUint32 offset, PRUint32 count);
 891     nsresult ReplaceData(PRUint32 offset, PRUint32 count, const nsAString *arg);
 892 }
 893
 894 [
 895     object,
 896     uuid(a6cf9082-15b3-11d2-932e-00805f8add32),
 897     local
 898 ]
 899 interface nsIDOMText : nsIDOMCharacterData
 900 {
 901     nsresult SplitText(PRUint32 offset, nsIDOMText **_retval);
 902 }
 903
 904 [
 905     object,
 906     uuid(a6cf9073-15b3-11d2-932e-00805f8add32),
 907     local
 908 ]
 909 interface nsIDOMComment : nsIDOMCharacterData
 910 {
 911 }
 912
 913 [
 914     object,
 915     uuid(a6cf9076-15b3-11d2-932e-00805f8add32),
 916     local
 917 ]
 918 interface nsIDOMDocumentFragment : nsIDOMNode
 919 {
 920 }
 921
 922 [
 923     object,
 924     uuid(f51ebade-8b1a-11d3-aae7-0010830123b4),
 925     local
 926 ]
 927 interface nsIDOMAbstractView : nsISupports
 928 {
 929     nsresult GetDocument(nsIDOMDocumentView **aDocument);
 930 }
 931
 932 [
 933     object,
 934     uuid(0b9341f3-95d4-4fa4-adcd-e119e0db2889),
 935     local
 936 ]
 937 interface nsIDOMViewCSS : nsIDOMAbstractView
 938 {
 939     nsresult GetComputedStyle(nsIDOMElement *elt, const nsAString *pseudoElt, nsIDOMCSSStyleDeclaration **_retval);
 940 }
 941
 942 [
 943     object,
 944     uuid(a6cf9075-15b3-11d2-932e-00805f8add32),
 945     local
 946 ]
 947 interface nsIDOMDocument : nsIDOMNode
 948 {
 949     nsresult GetDoctype(nsIDOMDocumentType **aDoctype);
 950     nsresult GetImplementation(nsIDOMDOMImplementation **aImplementation);
 951     nsresult GetDocumentElement(nsIDOMElement **aDocumentElement);
 952     nsresult CreateElement(const nsAString *tagName, nsIDOMElement **_retval);
 953     nsresult CreateDocumentFragment(nsIDOMDocumentFragment **_retval);
 954     nsresult CreateTextNode(const nsAString *data, nsIDOMText **_retval);
 955     nsresult CreateComment(const nsAString *data, nsIDOMComment **_retval);
 956     nsresult CreateCDATASection(const nsAString *data, nsIDOMCDATASection **_retval);
 957     nsresult CreateProcessingInstruction(const nsAString *target, const nsAString *data,
 958                                          nsIDOMProcessingInstruction **_retval);
 959     nsresult CreateAttribute(const nsAString *name, nsIDOMAttr **_retval);
 960     nsresult CreateEntityReference(const nsAString *name, nsIDOMEntityReference **_retval);
 961     nsresult GetElementsByTagName(const nsAString *tagname, nsIDOMNodeList **_retval);
 962     nsresult ImportNode(nsIDOMNode *importedNode, PRBool deep, nsIDOMNode **_retval);
 963     nsresult CreateElementNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 964                              nsIDOMElement **_retval);
 965     nsresult CreateAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 966                                nsIDOMAttr **_retval);
 967     nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName,
 968                                     nsIDOMNodeList **_retval);
 969     nsresult GetElementById(const nsAString *elementId, nsIDOMElement **_retval);
 970 }
 971
 972 [
 973     object,
 974     uuid(92f2c6f8-3668-4a47-8251-2a900afe11fa),
 975     local
 976 ]
 977 interface nsIDOMNSDocument : nsISupports
 978 {
 979     nsresult GetCharacterSet(nsAString *aCharacterSet);
 980     nsresult GetDir(nsAString *aDir);
 981     nsresult SetDir(const nsAString *aDir);
 982     nsresult GetLocation(nsIDOMLocation **aLocation);
 983     nsresult GetTitle(nsAString *aTitle);
 984     nsresult SetTitle(const nsAString *aTitle);
 985     nsresult GetContentType(nsAString *aContentType);
 986     nsresult GetReadyState(nsAString *aReadyState);
 987     nsresult GetLastModified(nsAString *aLastModified);
 988     nsresult GetReferrer(nsAString *aReferrer);
 989     nsresult HasFocus(PRBool *_retval);
 990     nsresult GetActiveElement(nsIDOMElement **aActiveElement);
 991     nsresult GetCurrentScript(nsIDOMElement **aActiveElement);
 992     nsresult GetElementsByClassName(const nsAString *classes, nsIDOMNodeList **_retval);
 993     nsresult ElementFromPoint(float x, float y, nsIDOMElement **_retval);
 994     nsresult ReleaseCapture();
 995     nsresult MozSetImageElement(const nsAString *aImageElementId, nsIDOMElement *aImageElement);
 996 }
 997
 998 [
 999     object,
1000     uuid(a6cf9084-15b3-11d2-932e-00805f8add32),
1001     local
1002 ]
1003 interface nsIDOMHTMLDocument : nsIDOMDocument
1004 {
1005     nsresult GetTitle(nsAString *aTitle);
1006     nsresult SetTitle(const nsAString *aTitle);
1007     nsresult GetReferrer(nsAString *aReferrer);
1008     nsresult GetDomain(nsAString *aDomain);
1009     nsresult GetURL(nsAString *aURL);
1010     nsresult GetBody(nsIDOMHTMLElement **aBody);
1011     nsresult SetBody(nsIDOMHTMLElement *aBody);
1012     nsresult GetImages(nsIDOMHTMLCollection **aImages);
1013     nsresult GetApplets(nsIDOMHTMLCollection **aApplets);
1014     nsresult GetLinks(nsIDOMHTMLCollection **aLinks);
1015     nsresult GetForms(nsIDOMHTMLCollection **aForms);
1016     nsresult GetAnchors(nsIDOMHTMLCollection **aAnchors);
1017     nsresult GetCookie(nsAString *aCookie);
1018     nsresult SetCookie(const nsAString *aCookie);
1019     nsresult Open();
1020     nsresult Close();
1021     nsresult Write(const nsAString *text);
1022     nsresult Writeln(const nsAString *text);
1023     nsresult GetElementsByName(const nsAString *elementName, nsIDOMNodeList **_retval);
1024 }
1025
1026 [
1027     object,
1028     uuid(95cd5ad4-ae8a-4f0e-b168-35e03d5e0b9a),
1029     local
1030 ]
1031 interface nsIDOMNSHTMLDocument : nsISupports
1032 {
1033     nsresult GetWidth(PRInt32 *aWidth);
1034     nsresult GetHeight(PRInt32 *aHeight);
1035     nsresult GetAlinkColor(nsAString *aAlinkColor);
1036     nsresult SetAlinkColor(const nsAString *aAlinkColor);
1037     nsresult GetLinkColor(nsAString *aLinkColor);
1038     nsresult SetLinkColor(const nsAString *aLinkColor);
1039     nsresult GetVlinkColor(nsAString *aVlinkColor);
1040     nsresult SetVlinkColor(const nsAString *aVlinkColor);
1041     nsresult GetBgColor(nsAString *aBgColor);
1042     nsresult SetBgColor(const nsAString *aBgColor);
1043     nsresult GetFgColor(nsAString *aFgColor);
1044     nsresult SetFgColor(const nsAString *aFgColor);
1045     nsresult GetDomain(nsAString *aDomain);
1046     nsresult SetDomain(const nsAString *aDomain);
1047     nsresult GetEmbeds(nsIDOMHTMLCollection **aEmbeds);
1048     nsresult GetSelection(nsAString *_retval);
1049     nsresult Open(nsACString *aContentType, PRBool aReplace, nsIDOMDocument **_retval);
1050     nsresult Clear();
1051     nsresult CaptureEvents(PRInt32 eventFlags);
1052     nsresult ReleaseEvents(PRInt32 eventFlags);
1053     nsresult RouteEvent(nsIDOMEvent *evt);
1054     nsresult GetCompatMode(nsAString *aCompatMode);
1055     nsresult GetPlugins(nsIDOMHTMLCollection **aPlugins);
1056     nsresult GetDesignMode(nsAString *aDesignMode);
1057     nsresult SetDesignMode(const nsAString *aDesignMode);
1058     nsresult ExecCommand(const nsAString *commandID, PRBool doShowUI, const nsAString *value, PRBool *_retval);
1059     nsresult ExecCommandShowHelp(const nsAString *commandID, PRBool *_retval);
1060     nsresult QueryCommandEnabled(const nsAString *commandID, PRBool *_retval);
1061     nsresult QueryCommandIndeterm(const nsAString *commandID, PRBool *_retval);
1062     nsresult QueryCommandState(const nsAString *commandID, PRBool *_retval);
1063     nsresult QueryCommandSupported(const nsAString *commandID, PRBool *_retval);
1064     nsresult QueryCommandText(const nsAString *commandID, nsAString *_retval);
1065     nsresult QueryCommandValue(const nsAString *commandID, nsAString *_retval);
1066     nsresult GetHead(nsIDOMHTMLHeadElement *_retval);
1067 }
1068
1069 [
1070     object,
1071     uuid(3d9f4973-dd2e-48f5-b5f7-2634e09eadd9),
1072     local
1073 ]
1074 interface nsIDOMDocumentStyle : nsISupports
1075 {
1076     nsresult GetStyleSheets(nsIDOMStyleSheetList **aStyleSheets);
1077 }
1078
1079 [
1080     object,
1081     uuid(1acdb2ba-1dd2-11b2-95bc-9542495d2569),
1082     local
1083 ]
1084 interface nsIDOMDocumentView : nsISupports
1085 {
1086     nsresult GetDefaultView(nsIDOMAbstractView **aDefaultView);
1087 }
1088
1089 [
1090     object,
1091     uuid(46b91d66-28e2-11d4-ab1e-0010830123b4),
1092     local
1093 ]
1094 interface nsIDOMDocumentEvent : nsISupports
1095 {
1096 cpp_quote("#undef CreateEvent")
1097     nsresult CreateEvent(const nsAString *eventType, nsIDOMEvent **_retval);
1098 }
1099
1100 [
1101     object,
1102     uuid(a6cf90ce-15b3-11d2-932e-00805f8add32),
1103     local
1104 ]
1105 interface nsIDOMRange : nsISupports
1106 {
1107     enum {
1108         NS_START_TO_START,
1109         NS_START_TO_END,
1110         NS_END_TO_END,
1111         NS_END_TO_START
1112     };
1113
1114     nsresult GetStartContainer(nsIDOMNode **aStartContainer);
1115     nsresult GetStartOffset(PRInt32 *aStartOffset);
1116     nsresult GetEndContainer(nsIDOMNode **aEndContainer);
1117     nsresult GetEndOffset(PRInt32 *aEndOffset);
1118     nsresult GetCollapsed(PRBool *aCollapsed);
1119     nsresult GetCommonAncestorContainer(nsIDOMNode **aCommonAncestorContainer);
1120     nsresult SetStart(nsIDOMNode *refNode, PRInt32 offset);
1121     nsresult SetEnd(nsIDOMNode *refNode, PRInt32 offset);
1122     nsresult SetStartBefore(nsIDOMNode *refNode);
1123     nsresult SetStartAfter(nsIDOMNode *refNode);
1124     nsresult SetEndBefore(nsIDOMNode *refNode);
1125     nsresult SetEndAfter(nsIDOMNode *refNode);
1126     nsresult Collapse(PRBool toStart);
1127     nsresult SelectNode(nsIDOMNode *refNode);
1128     nsresult SelectNodeContents(nsIDOMNode *refNode);
1129     nsresult CompareBoundaryPoints(PRUint16 how, nsIDOMRange *sourceRange, PRInt16 *_retval);
1130     nsresult DeleteContents();
1131     nsresult ExtractContents(nsIDOMDocumentFragment **_retval);
1132     nsresult CloneContents(nsIDOMDocumentFragment **_retval);
1133     nsresult InsertNode(nsIDOMNode *newNode);
1134     nsresult SurroundContents(nsIDOMNode *newParent);
1135     nsresult CloneRange(nsIDOMRange **_retval);
1136     nsresult ToString(nsAString *_retval);
1137     nsresult Detach();
1138 }
1139
1140 [
1141     object,
1142     uuid(fed93d11-f24d-41d8-ae55-4197927999bb),
1143     local
1144 ]
1145 interface nsIDOMNSRange : nsISupports
1146 {
1147     nsresult CreateContextualFragment([in] const nsAString *fragment, [out] nsIDOMDocumentFragment **_retval);
1148     nsresult IsPointInRange([in] nsIDOMNode *parent, [in] PRInt32 offset, [out] PRBool *_retval);
1149     nsresult ComparePoint([in] nsIDOMNode *parent, [in] PRInt32 offset, [out] PRInt16 *_retval);
1150     nsresult GetClientRects(nsIDOMClientRectList **_retval);
1151     nsresult GetBoundingClientRect(nsIDOMClientRect **_retval);
1152 }
1153
1154
1155 [
1156     object,
1157     uuid(7b9badc6-c9bc-447a-8670-dbd195aed24b),
1158     local
1159 ]
1160 interface nsIDOMDocumentRange : nsISupports
1161 {
1162     nsresult CreateRange(nsIDOMRange **_retval);
1163 }
1164
1165 [
1166     object,
1167     uuid(b2c7ed59-8634-4352-9e37-5484c8b6e4e1),
1168     local
1169 ]
1170 interface nsISelection : nsISupports
1171 {
1172     nsresult GetAnchorNode(nsIDOMNode **aAnchorNode);
1173     nsresult GetAnchorOffset(PRInt32 *aAnchorOffset);
1174     nsresult GetFocusNode(nsIDOMNode **aFocusNode);
1175     nsresult GetFocusOffset(PRInt32 *aFocusOffset);
1176     nsresult GetIsCollapsed(PRBool *aIsCollapsed);
1177     nsresult GetRangeCount(PRInt32 *aRangeCount);
1178     nsresult GetRangeAt(PRInt32 index, nsIDOMRange **_retval);
1179     nsresult Collapse(nsIDOMNode *parentNode, PRInt32 offset);
1180     nsresult Extend(nsIDOMNode *parentNode, PRInt32 offset);
1181     nsresult CollapseToStart();
1182     nsresult CollapseToEnd();
1183     nsresult ContainsNode(nsIDOMNode *node, PRBool entirelyContained, PRBool *_retval);
1184     nsresult SelectAllChildren(nsIDOMNode *parentNode);
1185     nsresult AddRange(nsIDOMRange *range);
1186     nsresult RemoveRange(nsIDOMRange *range);
1187     nsresult RemoveAllRanges();
1188     nsresult DeleteFromDocument();
1189     nsresult SelectionLanguageChange(PRBool langRTL);
1190     nsresult ToString(PRUnichar **_retval);
1191 }
1192
1193 [
1194     object,
1195     uuid(a6cf906f-15b3-11d2-932e-00805f8add32),
1196     local
1197 ]
1198 interface nsIDOMWindowCollection : nsISupports
1199 {
1200     nsresult GetLength(PRUint32 *aLength);
1201     nsresult Item(PRUint32 index, nsIDOMWindow **_retval);
1202     nsresult NamedItem(const nsAString *name, nsIDOMWindow **_retval);
1203 }
1204
1205 [
1206     object,
1207     uuid(a6cf906b-15b3-11d2-932e-00805f8add32),
1208     local
1209 ]
1210 interface nsIDOMWindow : nsISupports
1211 {
1212     nsresult GetDocument(nsIDOMDocument **aDocument);
1213     nsresult GetParent(nsIDOMWindow **aParent);
1214     nsresult GetTop(nsIDOMWindow **aTop);
1215     nsresult GetScrollbars(nsIDOMBarProp **aScrollbars);
1216     nsresult GetFrames(nsIDOMWindowCollection **aFrames);
1217     nsresult GetName(nsAString *aName);
1218     nsresult SetName(const nsAString *aName);
1219     nsresult GetTextZoom(float *aTextZoom);
1220     nsresult SetTextZoom(float aTextZoom);
1221     nsresult GetScrollX(PRInt32 *aScrollX);
1222     nsresult GetScrollY(PRInt32 *aScrollY);
1223     nsresult ScrollTo(PRInt32 xScroll, PRInt32 yScroll);
1224     nsresult ScrollBy(PRInt32 xScrollDif, PRInt32 yScrollDif);
1225     nsresult GetSelection(nsISelection **_retval);
1226     nsresult ScrollByLines(PRInt32 numLines);
1227     nsresult ScrollByPages(PRInt32 numPages);
1228     nsresult SizeToContent();
1229 }
1230
1231 [
1232     object,
1233     uuid(a6cf908e-15b3-11d2-932e-00805f8add32),
1234     local
1235 ]
1236 interface nsIDOMHTMLBodyElement : nsIDOMHTMLElement
1237 {
1238     nsresult GetALink(nsAString *aALink);
1239     nsresult SetALink(const nsAString *aALink);
1240     nsresult GetBackground(nsAString *aBackground);
1241     nsresult SetBackground(const nsAString *aBackground);
1242     nsresult GetBgColor(nsAString *aBgColor);
1243     nsresult SetBgColor(const nsAString *aBgColor);
1244     nsresult GetLink(nsAString *aLink);
1245     nsresult SetLink(const nsAString *aLink);
1246     nsresult GetText(nsAString *aText);
1247     nsresult SetText(const nsAString *aText);
1248     nsresult GetVLink(nsAString *aVLink);
1249     nsresult SetVLink(const nsAString *aVLink);
1250 }
1251
1252 [
1253     object,
1254     uuid(0884ce23-e069-499e-a13c-a91c8ae0fc98),
1255     local
1256 ]
1257 interface nsIDOMHTMLFormElement : nsIDOMHTMLElement
1258 {
1259     nsresult GetName(nsAString *aName);
1260     nsresult SetName(const nsAString *aName);
1261     nsresult GetAcceptCharset(nsAString *aAcceptCharset);
1262     nsresult SetAcceptCharset(const nsAString *aAcceptCharset);
1263     nsresult GetAction(nsAString *aAction);
1264     nsresult SetAction(const nsAString *aAction);
1265     nsresult GetAutocomplete(nsAString *aAutocomplete);
1266     nsresult SetAutocomplete(const nsAString *aAutocomplete);
1267     nsresult GetEnctype(nsAString *aEnctype);
1268     nsresult SetEnctype(const nsAString *aEnctype);
1269     nsresult GetMethod(nsAString *aMethod);
1270     nsresult SetMethod(const nsAString *aMethod);
1271     nsresult GetNoValidate(PRBool *aNoValidate);
1272     nsresult SetNoValidate(PRBool aNoValidate);
1273     nsresult GetTarget(nsAString *aTarget);
1274     nsresult SetTarget(const nsAString *aTarget);
1275     nsresult GetElements(nsIDOMHTMLCollection **aElements);
1276     nsresult GetLength(PRInt32 *aLength);
1277     nsresult Submit();
1278     nsresult Reset();
1279 }
1280
1281 [
1282     object,
1283     uuid(0805059d-f18f-4095-ae6b-0bf6df80b7b8),
1284     local
1285 ]
1286 interface nsIDOMHTMLInputElement : nsIDOMHTMLElement
1287 {
1288     nsresult GetAccept(nsAString *aAccept);
1289     nsresult SetAccept(const nsAString *aAccept);
1290     nsresult GetAlt(nsAString *aAlt);
1291     nsresult SetAlt(const nsAString *aAlt);
1292     nsresult GetAutocomplete(nsAString *aAutocomplete);
1293     nsresult SetAutocomplete(const nsAString *aAutocomplete);
1294     nsresult GetAutofocus(PRBool *aAutofocus);
1295     nsresult SetAutofocus(PRBool aAutofocus);
1296     nsresult GetDefaultChecked(PRBool *aDefaultChecked);
1297     nsresult SetDefaultChecked(PRBool aDefaultChecked);
1298     nsresult GetChecked(PRBool *aChecked);
1299     nsresult SetChecked(PRBool aChecked);
1300     nsresult GetDisabled(PRBool *aDisabled);
1301     nsresult SetDisabled(PRBool aDisabled);
1302     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1303     nsresult GetFormAction(nsAString *aFormAction);
1304     nsresult SetFormAction(const nsAString *aFormAction);
1305     nsresult GetFormEnctype(nsAString *aFormEnctype);
1306     nsresult SetFormEnctype(const nsAString *aFormEnctype);
1307     nsresult GetFormMethod(nsAString *aFormMethod);
1308     nsresult SetFormMethod(const nsAString *aFormMethod);
1309     nsresult GetFormNoValidate(PRBool *aFormNoValidate);
1310     nsresult SetFormNoValidate(PRBool aFormNoValidate);
1311     nsresult GetFormTarget(nsAString *aFormTarget);
1312     nsresult SetFormTarget(const nsAString *aFormTarget);
1313     nsresult GetFiles(nsIDOMFileList **aFiles);
1314     nsresult GetIndeterminate(PRBool *aIndeterminate);
1315     nsresult SetIndeterminate(PRBool aIndeterminate);
1316     nsresult GetList(nsIDOMHTMLElement **aList);
1317     nsresult GetMaxLength(PRInt32 *aMaxLength);
1318     nsresult SetMaxLength(PRInt32 aMaxLength);
1319     nsresult GetMultiple(PRBool *aMultiple);
1320     nsresult SetMultiple(PRBool aMultiple);
1321     nsresult GetName(nsAString *aName);
1322     nsresult SetName(const nsAString *aName);
1323     nsresult GetPattern(nsAString *aPattern);
1324     nsresult SetPattern(const nsAString *aPattern);
1325     nsresult GetPlaceholder(nsAString *aPlaceholder);
1326     nsresult SetPlaceholder(const nsAString *aPlaceholder);
1327     nsresult GetReadOnly(PRBool *aReadOnly);
1328     nsresult SetReadOnly(PRBool aReadOnly);
1329     nsresult GetRequired(PRBool *aRequired);
1330     nsresult SetRequired(PRBool aRequired);
1331     nsresult GetAccessKey(nsAString *aAccessKey);
1332     nsresult SetAccessKey(const nsAString *aAccessKey);
1333     nsresult GetAlign(nsAString *aAlign);
1334     nsresult SetAlign(const nsAString *aAlign);
1335     nsresult GetSize(PRUint32 *aSize);
1336     nsresult SetSize(PRUint32 aSize);
1337     nsresult GetSrc(nsAString *aSrc);
1338     nsresult SetSrc(const nsAString *aSrc);
1339     nsresult GetType(nsAString *aType);
1340     nsresult SetType(const nsAString *aType);
1341     nsresult GetDefaultValue(nsAString *aDefaultValue);
1342     nsresult SetDefaultValue(const nsAString *aDefaultValue);
1343     nsresult GetValue(nsAString *aValue);
1344     nsresult SetValue(const nsAString *aValue);
1345     nsresult GetWillValidate(PRBool *aWillValidate);
1346     nsresult GetValidity(nsIDOMValidityState **aValidity);
1347     nsresult GetValidationMessage(nsAString *aValidationMessage);
1348     nsresult CheckValidity(PRBool *_retval);
1349     nsresult SetCustomValidity(const nsAString *error);
1350     nsresult Select();
1351     nsresult GetSelectionStart(PRInt32 *aSelectionStart);
1352     nsresult SetSelectionStart(PRInt32 aSelectionStart);
1353     nsresult GetSelectionEnd(PRInt32 *aSelectionEnd);
1354     nsresult SetSelectionEnd(PRInt32 aSelectionEnd);
1355     nsresult SetSelectionRange(PRInt32 selectionStart, PRInt32 selectionEnd);
1356     nsresult GetTabIndex(PRInt32 *aTabIndex);
1357     nsresult SetTabIndex(PRInt32 aTabIndex);
1358     nsresult GetUseMap(nsAString *aUseMap);
1359     nsresult SetUseMap(const nsAString *aUseMap);
1360     nsresult GetControllers(nsIControllers **aControllers);
1361     nsresult GetTextLength(PRInt32 *aTextLength);
1362     nsresult MozGetFileNameArray(PRUint32 *aLength, PRUnichar ***aFileNames);
1363     nsresult MozSetFileNameArray(const PRUnichar **aFileNames, PRUint32 aLength);
1364     nsresult MozIsTextField(PRBool aExcludePassword, PRBool *_retval);
1365     nsresult Blur();
1366     nsresult Focus();
1367     nsresult Click();
1368 }
1369
1370 [
1371     object,
1372     uuid(611d00f5-1eb8-4571-b995-2a2019d2d11c),
1373     local
1374 ]
1375 interface nsIDOMHTMLOptionElement : nsIDOMHTMLElement
1376 {
1377     nsresult GetDisabled(PRBool *aDisabled);
1378     nsresult SetDisabled(PRBool aDisabled);
1379     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1380     nsresult GetLabel(nsAString *aLabel);
1381     nsresult SetLabel(const nsAString *aLabel);
1382     nsresult GetDefaultSelected(PRBool *aDefaultSelected);
1383     nsresult SetDefaultSelected(PRBool aDefaultSelected);
1384     nsresult GetSelected(PRBool *aSelected);
1385     nsresult SetSelected(PRBool aSelected);
1386     nsresult GetValue(nsAString *aValue);
1387     nsresult SetValue(const nsAString *aValue);
1388     nsresult GetText(nsAString *aText);
1389     nsresult SetText(const nsAString *aText);
1390     nsresult GetIndex(PRInt32 *aIndex);
1391 }
1392
1393 [
1394     object,
1395     uuid(bce0213c-f70f-488f-b93f-688acca55d63),
1396     local
1397 ]
1398 interface nsIDOMHTMLOptionsCollection : nsISupports
1399 {
1400     nsresult GetLength(PRUint32 *aLength);
1401     nsresult SetLength(PRUint32 aLength);
1402     nsresult Item(PRUint32 index, nsIDOMNode **_retval);
1403     nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
1404 }
1405
1406 [
1407     object,
1408     uuid(e3c6d960-972c-4a5e-a8f4-6ca65d578abf),
1409     local
1410 ]
1411 interface nsIDOMHTMLSelectElement : nsIDOMHTMLElement
1412 {
1413     nsresult GetAutofocus(PRBool *aAutofocus);
1414     nsresult SetAutofocus(PRBool aAutofocus);
1415     nsresult GetDisabled(PRBool *aDisabled);
1416     nsresult SetDisabled(PRBool aDisabled);
1417     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1418     nsresult GetMultiple(PRBool *aMultiple);
1419     nsresult SetMultiple(PRBool aMultiple);
1420     nsresult GetName(nsAString *aName);
1421     nsresult SetName(const nsAString *aName);
1422     nsresult GetSize(PRInt32 *aSize);
1423     nsresult SetSize(PRInt32 aSize);
1424     nsresult GetType(nsAString *aType);
1425     nsresult GetOptions(nsIDOMHTMLOptionsCollection **aOptions);
1426     nsresult GetLength(PRUint32 *aLength);
1427     nsresult SetLength(PRUint32 aLength);
1428     nsresult Item(PRUint32 index, nsIDOMNode **_retval);
1429     nsresult NamedItem(const nsAString *name, nsIDOMNode **_retval);
1430     nsresult Add(nsIDOMHTMLElement *element, nsIDOMHTMLElement *before);
1431     nsresult Remove(PRInt32 index);
1432     nsresult GetSelectedIndex(PRInt32 *aSelectedIndex);
1433     nsresult SetSelectedIndex(PRInt32 aSelectedIndex);
1434     nsresult GetValue(nsAString *aValue);
1435     nsresult SetValue(const nsAString *aValue);
1436     nsresult GetTabIndex(PRInt32 *aTabIndex);
1437     nsresult SetTabIndex(PRInt32 aTabIndex);
1438     nsresult Blur();
1439     nsresult Focus();
1440     nsresult GetWillValidate(PRBool *aWillValidate);
1441     nsresult GetValidity(nsIDOMValidityState **aValidity);
1442     nsresult GetValidationMessage(nsAString *aValidationMessage);
1443     nsresult CheckValidity(PRBool *_retval);
1444     nsresult SetCustomValidity(const nsAString *error);
1445 }
1446
1447 [
1448     object,
1449     uuid(a6cf9094-15b3-11d2-932e-00805f8add32),
1450     local
1451 ]
1452 interface nsIDOMHTMLTextAreaElement : nsIDOMHTMLElement
1453 {
1454     nsresult GetDefaultValue(nsAString *aDefaultValue);
1455     nsresult SetDefaultValue(const nsAString *aDefaultValue);
1456     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1457     nsresult GetAccessKey(nsAString *aAccessKey);
1458     nsresult SetAccessKey(const nsAString *aAccessKey);
1459     nsresult GetCols(PRInt32 *aCols);
1460     nsresult SetCols(PRInt32 aCols);
1461     nsresult GetDisabled(PRBool *aDisabled);
1462     nsresult SetDisabled(PRBool aDisabled);
1463     nsresult GetName(nsAString *aName);
1464     nsresult SetName(const nsAString *aName);
1465     nsresult GetReadOnly(PRBool *aReadOnly);
1466     nsresult SetReadOnly(PRBool aReadOnly);
1467     nsresult GetRows(PRInt32 *aRows);
1468     nsresult SetRows(PRInt32 aRows);
1469     nsresult GetTabIndex(PRInt32 *aTabIndex);
1470     nsresult SetTabIndex(PRInt32 aTabIndex);
1471     nsresult GetType(nsAString *aType);
1472     nsresult GetValue(nsAString *aValue);
1473     nsresult SetValue(const nsAString *aValue);
1474     nsresult Blur();
1475     nsresult Focus();
1476     nsresult Select();
1477 }
1478
1479 [
1480     object,
1481     uuid(4af8568c-375c-42fd-a82f-b25a7c03fc3e),
1482     local
1483 ]
1484 interface nsIDOMHTMLScriptElement : nsIDOMHTMLElement
1485 {
1486     nsresult GetSrc(nsAString *aSrc);
1487     nsresult SetSrc(const nsAString *aSrc);
1488     nsresult GetAsync(PRBool *aAsync);
1489     nsresult SetAsync(PRBool aAsync);
1490     nsresult GetDefer(PRBool *aDefer);
1491     nsresult SetDefer(PRBool aDefer);
1492     nsresult GetType(nsAString *aType);
1493     nsresult SetType(const nsAString *aType);
1494     nsresult GetCharset(nsAString *aCharset);
1495     nsresult SetCharset(const nsAString *aCharset);
1496     nsresult GetText(nsAString *aText);
1497     nsresult SetText(const nsAString *aText);
1498     nsresult GetHtmlFor(nsAString *aHtmlFor);
1499     nsresult SetHtmlFor(const nsAString *aHtmlFor);
1500     nsresult GetEvent(nsAString *aEvent);
1501     nsresult SetEvent(const nsAString *aEvent);
1502 }
1503
1504 [
1505     object,
1506     uuid(3fc9c313-49b9-4315-b39f-7166cf362e10),
1507     local
1508 ]
1509 interface nsIDOMHTMLImageElement : nsIDOMHTMLElement
1510 {
1511     nsresult GetAlt(nsAString *aAlt);
1512     nsresult SetAlt(const nsAString *aAlt);
1513     nsresult GetSrc(nsAString *aSrc);
1514     nsresult SetSrc(const nsAString *aSrc);
1515     nsresult GetUseMap(nsAString *aUseMap);
1516     nsresult SetUseMap(const nsAString *aUseMap);
1517     nsresult GetIsMap(PRBool *aIsMap);
1518     nsresult SetIsMap(PRBool aIsMap);
1519     nsresult GetWidth(PRInt32 *aWidth);
1520     nsresult SetWidth(PRInt32 aWidth);
1521     nsresult GetHeight(PRInt32 *aHeight);
1522     nsresult SetHeight(PRInt32 aHeight);
1523     nsresult GetNaturalWidth(PRInt32 *aNaturalWidth);
1524     nsresult GetNaturalHeight(PRInt32 *aNaturalHeight);
1525     nsresult GetComplete(PRBool *aComplete);
1526     nsresult GetName(nsAString *aName);
1527     nsresult SetName(const nsAString *aName);
1528     nsresult GetAlign(nsAString *aAlign);
1529     nsresult SetAlign(const nsAString *aAlign);
1530     nsresult GetBorder(nsAString *aBorder);
1531     nsresult SetBorder(const nsAString *aBorder);
1532     nsresult GetHspace(PRInt32 *aHspace);
1533     nsresult SetHspace(PRInt32 aHspace);
1534     nsresult GetLongDesc(nsAString *aLongDesc);
1535     nsresult SetLongDesc(const nsAString *aLongDesc);
1536     nsresult GetVspace(PRInt32 *aVspace);
1537     nsresult SetVspace(PRInt32 aVspace);
1538     nsresult GetLowsrc(nsAString *aLowsrc);
1539     nsresult SetLowsrc(const nsAString *aLowsrc);
1540     nsresult GetX(PRInt32 *aX);
1541     nsresult GetY(PRInt32 *aY);
1542 }
1543
1544 [
1545     object,
1546     uuid(4e237175-3628-4dc8-892f-5270edc3c71a),
1547     local
1548 ]
1549 interface nsIDOMHTMLAnchorElement : nsIDOMHTMLElement
1550 {
1551     nsresult GetHref(nsAString *aHref);
1552     nsresult SetHref(const nsAString *aHref);
1553     nsresult GetTarget(nsAString *aTarget);
1554     nsresult SetTarget(const nsAString *aTarget);
1555     nsresult GetPing(nsAString *aPing);
1556     nsresult SetPing(const nsAString *aPing);
1557     nsresult GetRel(nsAString *aRel);
1558     nsresult SetRel(const nsAString *aRel);
1559     nsresult GetHreflang(nsAString *aHreflang);
1560     nsresult SetHreflang(const nsAString *aHreflang);
1561     nsresult GetType(nsAString *aType);
1562     nsresult SetType(const nsAString *aType);
1563     nsresult GetText(nsAString *aText);
1564     nsresult SetText(const nsAString *aText);
1565     nsresult GetProtocol(nsAString *aProtocol);
1566     nsresult SetProtocol(const nsAString *aProtocol);
1567     nsresult GetHost(nsAString *aHost);
1568     nsresult SetHost(const nsAString *aHost);
1569     nsresult GetHostname(nsAString *aHostname);
1570     nsresult SetHostname(const nsAString *aHostname);
1571     nsresult GetPort(nsAString *aPort);
1572     nsresult SetPort(const nsAString *aPort);
1573     nsresult GetPathname(nsAString *aPathname);
1574     nsresult SetPathname(const nsAString *aPathname);
1575     nsresult GetSearch(nsAString *aSearch);
1576     nsresult SetSearch(const nsAString *aSearch);
1577     nsresult GetHash(nsAString *aHash);
1578     nsresult SetHash(const nsAString *aHash);
1579     nsresult GetAccessKey(nsAString *aAccessKey);
1580     nsresult SetAccessKey(const nsAString *aAccessKey);
1581     nsresult GetCharset(nsAString *aCharset);
1582     nsresult SetCharset(const nsAString *aCharset);
1583     nsresult GetCoords(nsAString *aCoords);
1584     nsresult SetCoords(const nsAString *aCoords);
1585     nsresult GetName(nsAString *aName);
1586     nsresult SetName(const nsAString *aName);
1587     nsresult GetRev(nsAString *aRev);
1588     nsresult SetRev(const nsAString *aRev);
1589     nsresult GetShape(nsAString *aShape);
1590     nsresult SetShape(const nsAString *aShape);
1591     nsresult GetTabIndex(PRInt32 *aTabIndex);
1592     nsresult SetTabIndex(PRInt32 aTabIndex);
1593     nsresult ToString(nsAString *_retval);
1594     nsresult Blur();
1595     nsresult Focus();
1596 }
1597
1598 [
1599     object,
1600     uuid(a6cf90b2-15b3-11d2-932e-00805f8add32),
1601     local
1602 ]
1603 interface nsIDOMHTMLTableElement : nsIDOMHTMLElement
1604 {
1605     nsresult GetCaption(nsIDOMHTMLTableCaptionElement **aCaption);
1606     nsresult SetCaption(nsIDOMHTMLTableCaptionElement *aCaption);
1607     nsresult GetTHead(nsIDOMHTMLTableSectionElement **aTHead);
1608     nsresult SetTHead(nsIDOMHTMLTableSectionElement *aTHead);
1609     nsresult GetTFoot(nsIDOMHTMLTableSectionElement **aTFoot);
1610     nsresult SetTFoot(nsIDOMHTMLTableSectionElement *aTFoot);
1611     nsresult GetRows(nsIDOMHTMLCollection **aRows);
1612     nsresult GetTBodies(nsIDOMHTMLCollection **aTBodies);
1613     nsresult GetAlign(nsAString *aAlign);
1614     nsresult SetAlign(const nsAString *aAlign);
1615     nsresult GetBgColor(nsAString *aBgColor);
1616     nsresult SetBgColor(const nsAString *aBgColor);
1617     nsresult GetBorder(nsAString *aBorder);
1618     nsresult SetBorder(const nsAString *aBorder);
1619     nsresult GetCellPadding(nsAString *aCellPadding);
1620     nsresult SetCellPadding(const nsAString *aCellPadding);
1621     nsresult GetCellSpacing(nsAString *aCellSpacing);
1622     nsresult SetCellSpacing(const nsAString *aCellSpacing);
1623     nsresult GetFrame(nsAString *aFrame);
1624     nsresult SetFrame(const nsAString *aFrame);
1625     nsresult GetRules(nsAString *aRules);
1626     nsresult SetRules(const nsAString *aRules);
1627     nsresult GetSummary(nsAString *aSummary);
1628     nsresult SetSummary(const nsAString *aSummary);
1629     nsresult GetWidth(nsAString *aWidth);
1630     nsresult SetWidth(const nsAString *aWidth);
1631     nsresult CreateTHead(nsIDOMHTMLElement **_retval);
1632     nsresult DeleteTHead();
1633     nsresult CreateTFoot(nsIDOMHTMLElement **_retval);
1634     nsresult DeleteTFoot();
1635     nsresult CreateCaption(nsIDOMHTMLElement **_retval);
1636     nsresult DeleteCaption();
1637     nsresult InsertRow(PRInt32 index, nsIDOMHTMLElement **_retval);
1638     nsresult DeleteRow(PRInt32 index);
1639 }
1640
1641 [
1642     object,
1643     uuid(a6cf90b6-15b3-11d2-932e-00805f8add32),
1644     local
1645 ]
1646 interface nsIDOMHTMLTableRowElement : nsIDOMHTMLElement
1647 {
1648     nsresult GetRowIndex(PRInt32 *aRowIndex);
1649     nsresult GetSectionRowIndex(PRInt32 *aSectionRowIndex);
1650     nsresult GetCells(nsIDOMHTMLCollection **aCells);
1651     nsresult GetAlign(nsAString *aAlign);
1652     nsresult SetAlign(const nsAString *aAlign);
1653     nsresult GetBgColor(nsAString *aBgColor);
1654     nsresult SetBgColor(const nsAString *aBgColor);
1655     nsresult GetCh(nsAString *aCh);
1656     nsresult SetCh(const nsAString *aCh);
1657     nsresult GetChOff(nsAString *aChOff);
1658     nsresult SetChOff(const nsAString *aChOff);
1659     nsresult GetVAlign(nsAString *aVAlign);
1660     nsresult SetVAlign(const nsAString *aVAlign);
1661     nsresult InsertCell(PRInt32 index, nsIDOMHTMLElement **_retval);
1662     nsresult DeleteCell(PRInt32 index);
1663 }
1664
1665 [
1666     object,
1667     uuid(a6cf90ba-15b3-11d2-932e-00805f8add32),
1668     local
1669 ]
1670 interface nsIDOMHTMLIFrameElement : nsIDOMHTMLElement
1671 {
1672     nsresult GetAlign(nsAString *aAlign);
1673     nsresult SetAlign(const nsAString *aAlign);
1674     nsresult GetFrameBorder(nsAString *aFrameBorder);
1675     nsresult SetFrameBorder(const nsAString *aFrameBorder);
1676     nsresult GetHeight(nsAString *aHeight);
1677     nsresult SetHeight(const nsAString *aHeight);
1678     nsresult GetLongDesc(nsAString *aLongDesc);
1679     nsresult SetLongDesc(const nsAString *aLongDesc);
1680     nsresult GetMarginHeight(nsAString *aMarginHeight);
1681     nsresult SetMarginHeight(const nsAString *aMarginHeight);
1682     nsresult GetMarginWidth(nsAString *aMarginWidth);
1683     nsresult SetMarginWidth(const nsAString *aMarginWidth);
1684     nsresult GetName(nsAString *aName);
1685     nsresult SetName(const nsAString *aName);
1686     nsresult GetScrolling(nsAString *aScrolling);
1687     nsresult SetScrolling(const nsAString *aScrolling);
1688     nsresult GetSrc(nsAString *aSrc);
1689     nsresult SetSrc(const nsAString *aSrc);
1690     nsresult GetWidth(nsAString *aWidth);
1691     nsresult SetWidth(const nsAString *aWidth);
1692     nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
1693 }
1694
1695 [
1696     object,
1697     uuid(a6cf90b9-15b3-11d2-932e-00805f8add32),
1698     local
1699 ]
1700 interface nsIDOMHTMLFrameElement : nsIDOMHTMLElement
1701 {
1702     nsresult GetFrameBorder(nsAString *aFrameBorder);
1703     nsresult SetFrameBorder(const nsAString *aFrameBorder);
1704     nsresult GetLongDesc(nsAString *aLongDesc);
1705     nsresult SetLongDesc(const nsAString *aLongDesc);
1706     nsresult GetMarginHeight(nsAString *aMarginHeight);
1707     nsresult SetMarginHeight(const nsAString *aMarginHeight);
1708     nsresult GetMarginWidth(nsAString *aMarginWidth);
1709     nsresult SetMarginWidth(const nsAString *aMarginWidth);
1710     nsresult GetName(nsAString *aName);
1711     nsresult SetName(const nsAString *aName);
1712     nsresult GetNoResize(PRBool *aNoResize);
1713     nsresult SetNoResize(PRBool aNoResize);
1714     nsresult GetScrolling(nsAString *aScrolling);
1715     nsresult SetScrolling(const nsAString *aScrolling);
1716     nsresult GetSrc(nsAString *aSrc);
1717     nsresult SetSrc(const nsAString *aSrc);
1718     nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
1719 }
1720
1721 [
1722     object,
1723     uuid(9b93aab4-7fe8-4f79-9ad2-0623178a0c46),
1724     local
1725 ]
1726 interface nsIDOMHTMLObjectElement : nsIDOMHTMLElement
1727 {
1728     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1729     nsresult GetCode(nsAString *aCode);
1730     nsresult SetCode(const nsAString *aCode);
1731     nsresult GetAlign(nsAString *aAlign);
1732     nsresult SetAlign(const nsAString *aAlign);
1733     nsresult GetArchive(nsAString *aArchive);
1734     nsresult SetArchive(const nsAString *aArchive);
1735     nsresult GetBorder(nsAString *aBorder);
1736     nsresult SetBorder(const nsAString *aBorder);
1737     nsresult GetCodeBase(nsAString *aCodeBase);
1738     nsresult SetCodeBase(const nsAString *aCodeBase);
1739     nsresult GetCodeType(nsAString *aCodeType);
1740     nsresult SetCodeType(const nsAString *aCodeType);
1741     nsresult GetData(nsAString *aData);
1742     nsresult SetData(const nsAString *aData);
1743     nsresult GetDeclare(PRBool *aDeclare);
1744     nsresult SetDeclare(PRBool aDeclare);
1745     nsresult GetHeight(nsAString *aHeight);
1746     nsresult SetHeight(const nsAString *aHeight);
1747     nsresult GetHspace(PRInt32 *aHspace);
1748     nsresult SetHspace(PRInt32 aHspace);
1749     nsresult GetName(nsAString *aName);
1750     nsresult SetName(const nsAString *aName);
1751     nsresult GetStandby(nsAString *aStandby);
1752     nsresult SetStandby(const nsAString *aStandby);
1753     nsresult GetTabIndex(PRInt32 *aTabIndex);
1754     nsresult SetTabIndex(PRInt32 aTabIndex);
1755     nsresult GetType(nsAString *aType);
1756     nsresult SetType(const nsAString *aType);
1757     nsresult GetUseMap(nsAString *aUseMap);
1758     nsresult SetUseMap(const nsAString *aUseMap);
1759     nsresult GetVspace(PRInt32 *aVspace);
1760     nsresult SetVspace(PRInt32 aVspace);
1761     nsresult GetWidth(nsAString *aWidth);
1762     nsresult SetWidth(const nsAString *aWidth);
1763     nsresult GetContentDocument(nsIDOMDocument **aContentDocument);
1764     nsresult GetWillValidate(PRBool *aWillValidate);
1765     nsresult GetValidity(nsIDOMValidityState **aValidity);
1766     nsresult GetValidationMessage(nsAString *aValidationMessage);
1767     nsresult CheckValidity(PRBool *_retval);
1768     nsresult SetCustomValidity(const nsAString *error);
1769 }
1770
1771 [
1772     object,
1773     uuid(a6cf90ad-15b3-11d2-932e-00805f8add32),
1774     local
1775 ]
1776 interface nsIDOMHTMLParamElement : nsIDOMHTMLElement
1777 {
1778     nsresult GetName(nsAString *aName);
1779     nsresult SetName(const nsAString *aName);
1780     nsresult GetType(nsAString *aType);
1781     nsresult SetType(const nsAString *aType);
1782     nsresult GetValue(nsAString *aValue);
1783     nsresult SetValue(const nsAString *aValue);
1784     nsresult GetValueType(nsAString *aValueType);
1785     nsresult SetValueType(const nsAString *aValueType);
1786 }
1787
1788 [
1789     object,
1790     uuid(a6cf908d-15b3-11d2-932e-00805f8add32),
1791     local
1792 ]
1793 interface nsIDOMHTMLStyleElement : nsIDOMHTMLElement
1794 {
1795     nsresult GetDisabled(PRBool *aDisabled);
1796     nsresult SetDisabled(PRBool aDisabled);
1797     nsresult GetMedia(nsAString *aMedia);
1798     nsresult SetMedia(const nsAString *aMedia);
1799     nsresult GetType(nsAString *aType);
1800     nsresult SetType(const nsAString *aType);
1801 }
1802
1803 [
1804     object,
1805     uuid(94928ab3-8b63-11d3-989d-001083010e9b),
1806     local
1807 ]
1808 interface nsIURIContentListener : nsISupports
1809 {
1810     nsresult OnStartURIOpen(nsIURI *aURI, PRBool *_retval);
1811     nsresult DoContent(const char *aContentType, PRBool aIsContentPreferred, nsIRequest *aRequest,
1812         nsIStreamListener **aContentHandler, PRBool *_retval);
1813     nsresult IsPreferred(const char *aContentType, char **aDesiredContentType, PRBool *_retval);
1814     nsresult CanHandleContent(const char *aContentType, PRBool aIsContentPreferred,
1815         char **aDesiredContentType, PRBool *_retval);
1816     nsresult GetLoadCookie(nsISupports **aLoadCookie);
1817     nsresult SetLoadCookie(nsISupports *aLoadCookie);
1818     nsresult GetParentContentListener(nsIURIContentListener **aParentContentListener);
1819     nsresult SetParentContentListener(nsIURIContentListener *aParentContentListener);
1820 }
1821
1822 [
1823     object,
1824     uuid(44b78386-1dd2-11b2-9ad2-e4eee2ca1916),
1825     local
1826 ]
1827 interface nsITooltipListener : nsISupports
1828 {
1829     nsresult OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, const PRUnichar *aTipText);
1830     nsresult OnHideTooltip();
1831 }
1832
1833 [
1834     object,
1835     uuid(33e9d001-caab-4ba9-8961-54902f197202),
1836     local
1837 ]
1838 interface nsIWebBrowser : nsISupports
1839 {
1840     nsresult AddWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
1841     nsresult RemoveWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
1842     nsresult GetContainerWindow(nsIWebBrowserChrome **aContainerWindow);
1843     nsresult SetContainerWindow(nsIWebBrowserChrome *aContainerWindow);
1844     nsresult GetParentURIContentListener(nsIURIContentListener **aParentURIContentListener);
1845     nsresult SetParentURIContentListener(nsIURIContentListener *aParentURIContentListener);
1846     nsresult GetContentDOMWindow(nsIDOMWindow **aContentDOMWindow);
1847     nsresult GetIsActive(PRBool *aIsActive);
1848     nsresult SetIsActive(PRBool aIsActive);
1849 }
1850
1851 cpp_quote("#define SETUP_ALLOW_JAVASCRIPT  2")
1852 cpp_quote("#define SETUP_IS_CHROME_WRAPPER 7")
1853
1854 [
1855     object,
1856     uuid(f15398a0-8018-11d3-af70-00a024ffc08c),
1857     local
1858 ]
1859 interface nsIWebBrowserSetup : nsISupports
1860 {
1861     nsresult SetProperty(PRUint32 aId, PRUint32 aValue);
1862 }
1863
1864 typedef void* nativeWindow;
1865
1866 [
1867     object,
1868     uuid(046bc8a0-8015-11d3-af70-00a024ffc08c),
1869     local
1870 ]
1871 interface nsIBaseWindow : nsISupports
1872 {
1873     nsresult InitWindow(nativeWindow parentNativeWindow, nsIWidget *parentWidget, PRInt32 x,
1874             PRInt32 y, PRInt32 cx, PRInt32 cy);
1875     nsresult Create();
1876     nsresult Destroy();
1877     nsresult SetPosition(PRInt32 x, PRInt32 y);
1878     nsresult GetPosition(PRInt32 *x, PRInt32 *y);
1879     nsresult SetSize(PRInt32 cx, PRInt32 cy, PRBool fRepaint);
1880     nsresult GetSize(PRInt32 *cx, PRInt32 *cy);
1881     nsresult SetPositionAndSize(PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy, PRBool fRepaint);
1882     nsresult GetPositionAndSize(PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy);
1883     nsresult Repaint(PRBool force);
1884     nsresult GetParentWidget(nsIWidget **aParentWidget);
1885     nsresult SetParentWidget(nsIWidget *aParentWidget);
1886     nsresult GetParentNativeWindow(nativeWindow *aParentNativeWindow);
1887     nsresult SetParentNativeWindow(nativeWindow aParentNativeWindow);
1888     nsresult GetVisibility(PRBool *aVisibility);
1889     nsresult SetVisibility(PRBool aVisibility);
1890     nsresult GetEnabled(PRBool *aEnabled);
1891     nsresult SetEnabled(PRBool aEnabled);
1892     nsresult GetBlurSuppression(PRBool *aBlurSuppression);
1893     nsresult SetBlurSuppression(PRBool aBlurSuppression);
1894     nsresult GetMainWidget(nsIWidget **aMainWidget);
1895     nsresult SetFocus();
1896     nsresult GetTitle(PRUnichar **aTitle);
1897     nsresult SetTitle(const PRUnichar *aTitle);
1898 }
1899
1900 cpp_quote("#define LOAD_FLAGS_NONE           0x00000000")
1901 cpp_quote("#define LOAD_REPLACE              0x00040000")
1902 cpp_quote("#define LOAD_INITIAL_DOCUMENT_URI 0x00080000")
1903
1904 [
1905     object,
1906     uuid(f5d9e7b0-d930-11d3-b057-00a024ffc08c),
1907     local
1908 ]
1909 interface nsIWebNavigation : nsISupports
1910 {
1911     nsresult GetCanGoBack(PRBool *aCanGoBack);
1912     nsresult GetCanGoForward(PRBool *aCanGoForward);
1913     nsresult GoBack();
1914     nsresult GoForward();
1915     nsresult GotoIndex(PRInt32 index);
1916     nsresult LoadURI(const PRUnichar *aURI, PRUint32 aLoadFlags, nsIURI *aReferrer,
1917             nsIInputStream *aPostData, nsIInputStream *aHeaders);
1918     nsresult Reload(PRUint32 aReloadFlags);
1919     nsresult Stop(PRUint32 aStopFlags);
1920     nsresult GetDocument(nsIDOMDocument **aDocument);
1921     nsresult GetCurrentURI(nsIURI **aCurrentURI);
1922     nsresult GetReferringURI(nsIURI **aReferringURI);
1923     nsresult GetSessionHistory(nsISHistory **aSessionHistory);
1924     nsresult SetSessionHistory(nsISHistory *aSessionHistory);
1925 }
1926
1927 [
1928     object,
1929     uuid(570f39d0-efd0-11d3-b093-00a024ffc08c),
1930     local
1931 ]
1932 interface nsIWebProgress : nsISupports
1933 {
1934     nsresult AddProgressListener(nsIWebProgressListener *aListener, PRUint32 aNotifyMask);
1935     nsresult RemoveProgressListener(nsIWebProgressListener *aListener);
1936     nsresult GetDOMWindow(nsIDOMWindow **aDOMWindow);
1937     nsresult GetIsLoadingDocument(PRBool *aIsLoadingDocument);
1938 }
1939
1940 [
1941     object,
1942     uuid(343700dd-078b-42b6-a809-b9c1d7e951d0),
1943     local
1944 ]
1945 interface nsIPrintSettings : nsISupports
1946 {
1947     typedef struct { char dummy; } nsIntMargin;
1948
1949     nsresult SetPrintOptions(PRInt32 aType, PRBool aTurnOnOff);
1950     nsresult GetPrintOptions(PRInt32 aType, PRBool *_retval);
1951     nsresult GetPrintOptionsBits(PRInt32 *_retval);
1952     nsresult GetEffectivePageSize(double *aWidth, double *aHeight);
1953     nsresult Clone(nsIPrintSettings **_retval);
1954     nsresult Assign(nsIPrintSettings *aPS);
1955     nsresult GetPrintSession(nsIPrintSession **aPrintSession);
1956     nsresult SetPrintSession(nsIPrintSession *aPrintSession);
1957     nsresult GetStartPageRange(PRInt32 *aStartPageRange);
1958     nsresult SetStartPageRange(PRInt32 aStartPageRange);
1959     nsresult GetEndPageRange(PRInt32 *aEndPageRange);
1960     nsresult SetEndPageRange(PRInt32 aEndPageRange);
1961     nsresult GetEdgeTop(double *aEdgeTop);
1962     nsresult SetEdgeTop(double aEdgeTop);
1963     nsresult GetEdgeLeft(double *aEdgeLeft);
1964     nsresult SetEdgeLeft(double aEdgeLeft);
1965     nsresult GetEdgeBottom(double *aEdgeBottom);
1966     nsresult SetEdgeBottom(double aEdgeBottom);
1967     nsresult GetEdgeRight(double *aEdgeRight);
1968     nsresult SetEdgeRight(double aEdgeRight);
1969     nsresult GetMarginTop(double *aMarginTop);
1970     nsresult SetMarginTop(double aMarginTop);
1971     nsresult GetMarginLeft(double *aMarginLeft);
1972     nsresult SetMarginLeft(double aMarginLeft);
1973     nsresult GetMarginBottom(double *aMarginBottom);
1974     nsresult SetMarginBottom(double aMarginBottom);
1975     nsresult GetMarginRight(double *aMarginRight);
1976     nsresult SetMarginRight(double aMarginRight);
1977     nsresult GetUnwriteableMarginTop(double *aUnwriteableMarginTop);
1978     nsresult SetUnwriteableMarginTop(double aUnwriteableMarginTop);
1979     nsresult GetUnwriteableMarginLeft(double *aUnwriteableMarginLeft);
1980     nsresult SetUnwriteableMarginLeft(double aUnwriteableMarginLeft);
1981     nsresult GetUnwriteableMarginBottom(double *aUnwriteableMarginBottom);
1982     nsresult SetUnwriteableMarginBottom(double aUnwriteableMarginBottom);
1983     nsresult GetUnwriteableMarginRight(double *aUnwriteableMarginRight);
1984     nsresult SetUnwriteableMarginRight(double aUnwriteableMarginRight);
1985     nsresult GetScaling(double *aScaling);
1986     nsresult SetScaling(double aScaling);
1987     nsresult GetPrintBGColors(PRBool *aPrintBGColors);
1988     nsresult SetPrintBGColors(PRBool aPrintBGColors);
1989     nsresult GetPrintBGImages(PRBool *aPrintBGImages);
1990     nsresult SetPrintBGImages(PRBool aPrintBGImages);
1991     nsresult GetPrintRange(PRInt16 *aPrintRange);
1992     nsresult SetPrintRange(PRInt16 aPrintRange);
1993     nsresult GetTitle(PRUnichar **aTitle);
1994     nsresult SetTitle(const PRUnichar *aTitle);
1995     nsresult GetDocURL(PRUnichar **aDocURL);
1996     nsresult SetDocURL(const PRUnichar *aDocURL);
1997     nsresult GetHeaderStrLeft(PRUnichar **aHeaderStrLeft);
1998     nsresult SetHeaderStrLeft(const PRUnichar *aHeaderStrLeft);
1999     nsresult GetHeaderStrCenter(PRUnichar **aHeaderStrCenter);
2000     nsresult SetHeaderStrCenter(const PRUnichar *aHeaderStrCenter);
2001     nsresult GetHeaderStrRight(PRUnichar **aHeaderStrRight);
2002     nsresult SetHeaderStrRight(const PRUnichar *aHeaderStrRight);
2003     nsresult GetFooterStrLeft(PRUnichar **aFooterStrLeft);
2004     nsresult SetFooterStrLeft(const PRUnichar *aFooterStrLeft);
2005     nsresult GetFooterStrCenter(PRUnichar **aFooterStrCenter);
2006     nsresult SetFooterStrCenter(const PRUnichar *aFooterStrCenter);
2007     nsresult GetFooterStrRight(PRUnichar **aFooterStrRight);
2008     nsresult SetFooterStrRight(const PRUnichar *aFooterStrRight);
2009     nsresult GetHowToEnableFrameUI(PRInt16 *aHowToEnableFrameUI);
2010     nsresult SetHowToEnableFrameUI(PRInt16 aHowToEnableFrameUI);
2011     nsresult GetIsCancelled(PRBool *aIsCancelled);
2012     nsresult SetIsCancelled(PRBool aIsCancelled);
2013     nsresult GetPrintFrameTypeUsage(PRInt16 *aPrintFrameTypeUsage);
2014     nsresult SetPrintFrameTypeUsage(PRInt16 aPrintFrameTypeUsage);
2015     nsresult GetPrintFrameType(PRInt16 *aPrintFrameType);
2016     nsresult SetPrintFrameType(PRInt16 aPrintFrameType);
2017     nsresult GetPrintSilent(PRBool *aPrintSilent);
2018     nsresult SetPrintSilent(PRBool aPrintSilent);
2019     nsresult GetShrinkToFit(PRBool *aShrinkToFit);
2020     nsresult SetShrinkToFit(PRBool aShrinkToFit);
2021     nsresult GetShowPrintProgress(PRBool *aShowPrintProgress);
2022     nsresult SetShowPrintProgress(PRBool aShowPrintProgress);
2023     nsresult GetPaperName(PRUnichar **aPaperName);
2024     nsresult SetPaperName(const PRUnichar *aPaperName);
2025     nsresult GetPaperSizeType(PRInt16 *aPaperSizeType);
2026     nsresult SetPaperSizeType(PRInt16 aPaperSizeType);
2027     nsresult GetPaperData(PRInt16 *aPaperData);
2028     nsresult SetPaperData(PRInt16 aPaperData);
2029     nsresult GetPaperWidth(double *aPaperWidth);
2030     nsresult SetPaperWidth(double aPaperWidth);
2031     nsresult GetPaperHeight(double *aPaperHeight);
2032     nsresult SetPaperHeight(double aPaperHeight);
2033     nsresult GetPaperSizeUnit(PRInt16 *aPaperSizeUnit);
2034     nsresult SetPaperSizeUnit(PRInt16 aPaperSizeUnit);
2035     nsresult GetPlexName(PRUnichar **aPlexName);
2036     nsresult SetPlexName(const PRUnichar *aPlexName);
2037     nsresult GetColorspace(PRUnichar **aColorspace);
2038     nsresult SetColorspace(const PRUnichar *aColorspace);
2039     nsresult GetResolutionName(PRUnichar **aResolutionName);
2040     nsresult SetResolutionName(const PRUnichar aResolutionName);
2041     nsresult GetDownloadFonts(PRBool *aDownloadFonts);
2042     nsresult SetDownloadFonts(PRBool aDownloadFonts);
2043     nsresult GetPrintReversed(PRBool *aPrintReversed);
2044     nsresult SetPrintReversed(PRBool aPrintReversed);
2045     nsresult GetPrintInColor(PRBool *aPrintInColor);
2046     nsresult SetPrintInColor(PRBool aPrintInColor);
2047     nsresult GetOrientation(PRInt32 *aOrientation);
2048     nsresult SetOrientation(PRInt32 aOrientation);
2049     nsresult GetPrintCommand(PRUnichar **aPrintCommand);
2050     nsresult SetPrintCommand(const PRUnichar *aPrintCommand);
2051     nsresult GetNumCopies(PRInt32 *aNumCopies);
2052     nsresult SetNumCopies(PRInt32 aNumCopies);
2053     nsresult GetPrinterName(PRUnichar **aPrinterName);
2054     nsresult SetPrinterName(const PRUnichar *aPrinterName);
2055     nsresult GetPrintToFile(PRBool *aPrintToFile);
2056     nsresult SetPrintToFile(PRBool aPrintToFile);
2057     nsresult GetToFileName(PRUnichar **aToFileName);
2058     nsresult SetToFileName(const PRUnichar *aToFileName);
2059     nsresult GetOutputFormat(PRInt16 *aOutputFormat);
2060     nsresult SetOutputFormat(PRInt16 aOutputFormat);
2061     nsresult GetPrintPageDelay(PRInt32 *aPrintPageDelay);
2062     nsresult SetPrintPageDelay(PRInt32 aPrintPageDelay);
2063     nsresult GetIsInitializedFromPrinter(PRBool *aIsInitializedFromPrinter);
2064     nsresult SetIsInitializedFromPrinter(PRBool aIsInitializedFromPrinter);
2065     nsresult GetIsInitializedFromPrefs(PRBool *aIsInitializedFromPrefs);
2066     nsresult SetIsInitializedFromPrefs(PRBool aIsInitializedFromPrefs);
2067     nsresult SetMarginInTwips(nsIntMargin *aMargin);
2068     nsresult SetEdgeInTwips(nsIntMargin *aEdge);
2069     nsresult GetMarginInTwips(nsIntMargin *aMargin);
2070     nsresult GetEdgeInTwips(nsIntMargin *aEdge);
2071     nsresult SetupSilentPrinting();
2072     nsresult SetUnwriteableMarginInTwips(nsIntMargin *aEdge);
2073     nsresult GetUnwriteableMarginInTwips(nsIntMargin *aEdge);
2074 }
2075
2076 [
2077     object,
2078     uuid(9a7ca4b0-fbba-11d4-a869-00105a183419),
2079     local
2080 ]
2081 interface nsIWebBrowserPrint : nsISupports
2082 {
2083     nsresult GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings);
2084     nsresult GetCurrentPrintSettings(nsIPrintSettings **aCurrentPrintSettings);
2085     nsresult GetCurrentChildDOMWindow(nsIDOMWindow **aCurrentChildDOMWindow);
2086     nsresult GetDoingPrint(PRBool *aDoingPrint);
2087     nsresult GetDoingPrintPreview(PRBool *aDoingPrintPreview);
2088     nsresult GetIsFramesetDocument(PRBool *aIsFramesetDocument);
2089     nsresult GetIsFramesetFrameSelected(PRBool *aIsFramesetFrameSelected);
2090     nsresult GetIsIFrameSelected(PRBool *aIsIFrameSelected);
2091     nsresult GetIsRangeSelection(PRBool *aIsRangeSelection);
2092     nsresult GetPrintPreviewNumPages(PRInt32 *aPrintPreviewNumPages);
2093     nsresult Print(nsIPrintSettings *aThePrintSettings, nsIWebProgressListener *aWPListener);
2094     nsresult PrintPreview(nsIPrintSettings *aThePrintSettings, nsIDOMWindow *aChildDOMWin,
2095                           nsIWebProgressListener *aWPListener);
2096     nsresult PrintPreviewNavigate(PRInt16 aNavType, PRInt32 aPageNum);
2097     nsresult Cancel();
2098     nsresult EnumerateDocumentNames(PRUint32 *aCount, PRUnichar ***aResult);
2099     nsresult ExitPrintPreview();
2100 }
2101
2102 [
2103     object,
2104     uuid(919e792a-6490-40b8-bba5-f9e9ad5640c8),
2105     local
2106 ]
2107 interface nsIScrollable : nsISupports
2108 {
2109     enum {
2110         ScrollOrientation_X = 1,
2111         ScrollOrientation_Y = 2
2112     };
2113
2114     enum {
2115         Scrollbar_Auto   = 1,
2116         Scrollbar_Never  = 2,
2117         Scrollbar_Always = 3
2118     };
2119
2120     nsresult GetCurScrollPos(PRInt32 scrollOrientation, PRInt32 *curPos);
2121     nsresult SetCurScrollPos(PRInt32 scrollOrientation, PRInt32 curPos);
2122     nsresult SetCurScrollPosEx(PRInt32 curHorizontalPos, PRInt32 curVerticalPos);
2123     nsresult GetScrollRange(PRInt32 scrollOrientation, PRInt32 *minPos, PRInt32 *maxPos);
2124     nsresult SetScrollRange(PRInt32 scrollOrientation, PRInt32 minPos, PRInt32 maxPos);
2125     nsresult SetScrollRangeEx(PRInt32 minHorizontalPos, PRInt32 maxHorizontalPos,
2126             PRInt32 minVerticalPos, PRInt32 maxVerticalPos);
2127     nsresult GetDefaultScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 *scrollbarPref);
2128     nsresult SetDefaultScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 scrollbarPref);
2129     nsresult GetScrollbarVisibility(PRBool *verticalVisible, PRBool *horizontalVisible);
2130 }
2131
2132 [
2133     object,
2134     uuid(c8c0a080-0868-11d3-915f-d9d889d48e3c),
2135     local
2136 ]
2137 interface nsIFile : nsISupports
2138 {
2139     nsresult Append(const nsAString *node);
2140     nsresult AppendNative(const nsAString *node);
2141     nsresult Normalize();
2142     nsresult Create(PRUint32 type, PRUint32 permission);
2143     nsresult GetLeafName(nsAString *aLeafName);
2144     nsresult SetLeafName(const nsAString *aLeafName);
2145     nsresult GetNativeLeafName(nsAString *aLeafName);
2146     nsresult SetNativeLeafName(const nsAString *aLeafName);
2147     nsresult CopyTo(nsIFile *newParentDir, const nsAString *newName);
2148     nsresult CopyToNative(nsIFile *newParentDir, const nsAString *newName);
2149     nsresult CopyToFollowingLinks(nsIFile *newParentDir, const nsAString *newName);
2150     nsresult CopyToFollowingLinksNative(nsIFile *newParentDir, const nsAString *newName);
2151     nsresult MoveTo(nsIFile *newParentDir, const nsAString *newName);
2152     nsresult MoveToNative(nsIFile *newParentDir, const nsAString *newName);
2153     nsresult Remove(PRBool recursive);
2154     nsresult GetPermissions(PRUint32 *aPermissions);
2155     nsresult SetPermissions(PRUint32 pPermissions);
2156     nsresult GetPermissionsOfLink(PRUint32 *aPermissions);
2157     nsresult SetPermissionsOfLink(PRUint32 pPermissions);
2158     nsresult GetLastModifiedTime(PRInt64 *aLastModifiedTime);
2159     nsresult SetLastModifiedTime(PRInt64 aLastModifiedTime);
2160     nsresult GetLastModifiedTimeOfLink(PRInt64 *aLastModifiedTimeOfLink);
2161     nsresult SetLastModifiedTimeOfLink(PRInt64 aLastModifiedTimeOfLink);
2162     nsresult GetFileSize(PRInt64 *aFileSize);
2163     nsresult SetFileSize(PRInt64 aFileSize);
2164     nsresult GetFileSizeOfLink(PRInt64 *aFileSizeOfLink);
2165     nsresult GetTarget(nsAString *aTarget);
2166     nsresult GetNativeTarget(nsACString *aNativeTarget);
2167     nsresult GetPath(nsAString *aPath);
2168     nsresult GetNativePath(nsACString *aNativePath);
2169     nsresult Exists(PRBool *_retval);
2170     nsresult IsWritable(PRBool *_retval);
2171     nsresult IsReadable(PRBool *_retval);
2172     nsresult IsExecutable(PRBool *_retval);
2173     nsresult IsHidden(PRBool *_retval);
2174     nsresult IsDirectory(PRBool *_retval);
2175     nsresult IsFile(PRBool *_retval);
2176     nsresult IsSymlink(PRBool *_retval);
2177     nsresult IsSpecial(PRBool *_retval);
2178     nsresult CreateUnique(PRUint32 type, PRUint32 permission);
2179     nsresult Clone(nsIFile **_retval);
2180     nsresult Equals(nsIFile *inFile, PRBool *_retval);
2181     nsresult Contains(nsIFile *inFile, PRBool recir, PRBool *_retval);
2182     nsresult GetParent(nsIFile **aParent);
2183     nsresult GetDirectoryEntries(nsISimpleEnumerator **aDirectoryEntries);
2184 }
2185
2186 [
2187     object,
2188     uuid(56c35506-f14b-11d3-99d3-ddbfac2ccf65),
2189     local
2190 ]
2191 interface nsIPrefBranch : nsISupports
2192 {
2193     nsresult GetRoot(char **aRoot);
2194     nsresult GetPrefType(const char *aPrefName, PRInt32 *_retval);
2195     nsresult GetBoolPref(const char *aPrefName, PRBool *_retval);
2196     nsresult SetBoolPref(const char *aPrefName, PRInt32 aValue);
2197     nsresult GetCharPref(const char *aPrefName, char **_retval);
2198     nsresult SetCharPref(const char *aPrefName, const char *aValue);
2199     nsresult GetIntPref(const char *aPrefName, PRInt32 *_retval);
2200     nsresult SetIntPref(const char *aPrefName, PRInt32 aValue);
2201     nsresult GetComplexValue(const char *aPrefName, const nsIID *aType, void **aValue);
2202     nsresult SetComplexValue(const char *aPrefName, const nsIID *aType, nsISupports *aValue);
2203     nsresult ClearUserPref(const char *aPrefName);
2204     nsresult LockPref(const char *aPrefName);
2205     nsresult PrefHasUserValue(const char *aPrefName, PRBool *_retval);
2206     nsresult PrefIsLocked(const char *aPrefName, PRBool *_retval);
2207     nsresult UnlockPref(const char *aPrefName);
2208     nsresult DeleteBranch(const char *aStartingAt);
2209     nsresult GetChildList(const char *aStartingAt, PRUint32 *aCount, char ***aChildArray);
2210     nsresult ResetBranch(const char *aStartingAt);
2211 }
2212
2213 [
2214     object,
2215     uuid(bbf8cab0-d43a-11d3-8cc2-00609792278c),
2216     local
2217 ]
2218 interface nsIDirectoryServiceProvider : nsISupports
2219 {
2220     nsresult GetFile(const char *prop, PRBool *persistent, nsIFile **_retval);
2221 }
2222
2223 [
2224     object,
2225     uuid(15fd6940-8ea7-11d3-93ad-00104ba0fd40),
2226     local
2227 ]
2228 interface nsIProtocolHandler : nsISupports
2229 {
2230     nsresult GetScheme(nsACString *aScheme);
2231     nsresult GetDefaultPort(PRInt32 *aDefaultPort);
2232     nsresult GetProtocolFlags(PRUint32 *aProtocolFlags);
2233     nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset,
2234                     nsIURI *aBaseURI, nsIURI **_retval);
2235     nsresult NewChannel(nsIURI *aURI, nsIChannel **_retval);
2236     nsresult AllowPort(PRInt32 port, const char *scheme, PRBool *_retval);
2237 }
2238
2239 [
2240     object,
2241     uuid(0e61f3b2-34d7-4c79-bfdc-4860bc7341b7),
2242     local
2243 ]
2244 interface nsIExternalProtocolHandler : nsIProtocolHandler
2245 {
2246     nsresult ExternalAppExistsForScheme(const nsACString *scheme, PRBool *_retval);
2247 }
2248
2249 [
2250     object,
2251     uuid(bddeda3f-9020-4d12-8c70-984ee9f7935e),
2252     local
2253 ]
2254 interface nsIIOService : nsISupports
2255 {
2256     nsresult GetProtocolHandler(const char *aScheme, nsIProtocolHandler **_retval);
2257     nsresult GetProtocolFlags(const char *aScheme, PRUint32 *_retval);
2258     nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
2259                     nsIURI **_retval);
2260     nsresult NewFileURI(nsIFile *aFile, nsIURI **_retval);
2261     nsresult NewChannelFromURI(nsIURI *aURI, nsIChannel **_retval);
2262     nsresult NewChannel(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
2263                         nsIChannel **_retval);
2264     nsresult GetOffline(PRBool *aOffline);
2265     nsresult SetOffline(PRBool aOffline);
2266     nsresult AllowPort(PRInt32 aPort, const char *aScheme, PRBool *_retval);
2267     nsresult ExtractScheme(const nsACString *urlString, nsACString * _retval);
2268 }
2269
2270 [
2271     object,
2272     uuid(ca68c485-9db3-4c12-82a6-4fab7948e2d5),
2273     local,
2274 ]
2275 interface nsINetUtil : nsISupports
2276 {
2277     nsresult ParseContentType(const nsACString *aTypeHeader, nsACString *aCharset,
2278             PRBool *aHadCharset, nsACString *_retval);
2279     nsresult ProtocolHasFlags(nsIURI *aURI, PRUint32 aFlag, PRBool *_retval);
2280     nsresult URIChainHasFlags(nsIURI *aURI, PRUint32 aFlags, PRBool *_retval);
2281     nsresult ToImmutableURI(nsIURI *aURI, nsIURI **_retval);
2282     nsresult NewSimpleNestedURI(nsIURI *aURI, nsIURI **_retval);
2283     nsresult EscapeString(const nsACString *aString, PRUint32 aEscapeType, nsACString *_retval);
2284     nsresult EscapeURL(const nsACString *aStr, PRUint32 aFlags, nsACString *_retval);
2285     nsresult UnescapeString(const nsACString *aStr, PRUint32 aFlags, nsACString *_retval);
2286     nsresult ExtractCharsetFromContentType(const nsACString *aTypeHeader, nsACString *aCharset,
2287             PRInt32 *aCharsetStart, PRInt32 *aCharsetEnd, PRBool *_retval);
2288 }
2289
2290 [
2291     object,
2292     uuid(9c5d3c58-1dd1-11b2-a1c9-f3699284657a),
2293     local
2294 ]
2295 interface nsIWebBrowserFocus : nsISupports
2296 {
2297     nsresult Activate();
2298     nsresult Deactivate();
2299     nsresult SetFocusAtFirstElement();
2300     nsresult SetFocusAtLastElement();
2301     nsresult GetFocusedWindow(nsIDOMWindow **aFocusedWindow);
2302     nsresult SetFocusedWindow(nsIDOMWindow *aFocusedWindow);
2303     nsresult GetFocusedElement(nsIDOMElement **aFocusedElement);
2304     nsresult SetFocusedElement(nsIDOMElement *aFocusedElement);
2305 }
2306
2307 [
2308     object,
2309     uuid(ba434c60-9d52-11d3-afb0-00a024ffc08c),
2310     local
2311 ]
2312 interface nsIWebBrowserChrome : nsISupports
2313 {
2314     nsresult SetStatus(PRUint32 statusType, const PRUnichar *status);
2315     nsresult GetWebBrowser(nsIWebBrowser **aWebBrowser);
2316     nsresult SetWebBrowser(nsIWebBrowser *aWebBrowser);
2317     nsresult GetChromeFlags(PRUint32 *aChromeFlags);
2318     nsresult SetChromeFlags(PRUint32 aChromeFlags);
2319     nsresult DestroyBrowserWindow();
2320     nsresult SizeBrowserTo(PRInt32 aCX, PRInt32 aCY);
2321     nsresult ShowAsModal();
2322     nsresult IsWindowModal(PRBool *_retval);
2323     nsresult ExitModalEventLoop(nsresult aStatus);
2324 }
2325
2326 [
2327     object,
2328     uuid(df31c120-ded6-11d1-bd85-00805f8ae3f4),
2329     local
2330 ]
2331 interface nsIDOMEventListener : nsISupports
2332 {
2333     nsresult HandleEvent(nsIDOMEvent *event);
2334 }
2335
2336 [
2337     object,
2338     uuid(1c773b30-d1cf-11d2-bd95-00805f8ae3f4),
2339     local
2340 ]
2341 interface nsIDOMEventTarget : nsISupports
2342 {
2343     nsresult AddEventListener(const nsAString *type, nsIDOMEventListener *listener, PRBool useCapture);
2344     nsresult RemoveEventListener(const nsAString *type, nsIDOMEventListener *listener, PRBool useCapture);
2345     nsresult DispatchEvent(nsIDOMEvent *evt, PRBool *_retval);
2346 }
2347
2348 [
2349     object,
2350     uuid(a66b7b80-ff46-bd97-0080-5f8ae38add32),
2351     local
2352 ]
2353 interface nsIDOMEvent : nsISupports
2354 {
2355     nsresult GetType(nsAString *aType);
2356     nsresult GetTarget(nsIDOMEventTarget **aTarget);
2357     nsresult GetCurrentTarget(nsIDOMEventTarget **aCurrentTarget);
2358     nsresult GetEventPhase(PRUint16 *aEventPhase);
2359     nsresult GetBubbles(PRBool *aBubbles);
2360     nsresult GetCancelable(PRBool *aCancelable);
2361     nsresult GetTimeStamp(DOMTimeStamp *aTimeStamp);
2362     nsresult StopPropagation();
2363     nsresult PreventDefault();
2364     nsresult InitEvent(const nsAString *eventTypeArg, PRBool canBubbleArg, PRBool cancelableArg);
2365 }
2366
2367 cpp_quote("#define CONTEXT_NONE              0x00")
2368 cpp_quote("#define CONTEXT_LINK              0x01")
2369 cpp_quote("#define CONTEXT_IMAGE             0x02")
2370 cpp_quote("#define CONTEXT_DOCUMENT          0x04")
2371 cpp_quote("#define CONTEXT_TEXT              0x08")
2372 cpp_quote("#define CONTEXT_INPUT             0x10")
2373 cpp_quote("#define CONTEXT_BACKGROUND_IMAGE  0x20")
2374
2375 [
2376     object,
2377     uuid(3478b6b0-3875-11d4-94ef-0020183bf181),
2378     local
2379 ]
2380 interface nsIContextMenuListener : nsISupports
2381 {
2382     nsresult OnShowContextMenu(PRUint32 aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode);
2383 }
2384
2385 [
2386     object,
2387     uuid(a6cf90c3-15b3-11d2-932e-00805f8add32),
2388     local
2389 ]
2390 interface nsIDOMUIEvent : nsIDOMEvent
2391 {
2392     nsresult GetView(nsIDOMAbstractView **aView);
2393     nsresult GetDetail(PRInt32 *aDetail);
2394     nsresult InitUIEvent(const nsAString *typeArg, PRBool canBubbleArg, PRBool cancelableArg,
2395             nsIDOMAbstractView *viewArg, PRInt32 detailArg);
2396 }
2397
2398 [
2399     object,
2400     uuid(ff751edc-8b02-aae7-0010-8301838a3123),
2401     local
2402 ]
2403 interface nsIDOMMouseEvent : nsIDOMUIEvent
2404 {
2405     nsresult GetScreenX(PRInt32 *aScreenX);
2406     nsresult GetScreenY(PRInt32 *aScreenY);
2407     nsresult GetClientX(PRInt32 *aClientX);
2408     nsresult GetClientY(PRInt32 *aClientY);
2409     nsresult GetCtrlKey(PRBool *aCtrlKey);
2410     nsresult GetShiftKey(PRBool *aShiftKey);
2411     nsresult GetAltKey(PRBool *aAltKey);
2412     nsresult GetMetaKey(PRBool *aMetaKey);
2413     nsresult GetButton(PRUint16 *aButton);
2414     nsresult GetRelatedTarget(nsIDOMEventTarget **aRelatedTarget);
2415     nsresult InitMouseEvent(const nsAString *typeArg, PRBool canBubbleArg, PRBool cancelableArg,
2416             nsIDOMAbstractView *viewArg, PRInt32 detailArg, PRInt32 screenXArg, PRInt32 screenYArg,
2417             PRInt32 clientXArg, PRInt32 clientYArg, PRBool ctrlKeyArg, PRBool altKeyArg,
2418             PRBool shiftKeyArg, PRBool metaKeyArg, PRUint16 buttonArg,
2419             nsIDOMEventTarget *relatedTargetArg);
2420 }
2421
2422 [
2423     object,
2424     uuid(028e0e6e-8b01-11d3-aae7-0010838a3123),
2425     local
2426 ]
2427 interface nsIDOMKeyEvent : nsIDOMUIEvent
2428 {
2429     nsresult GetCharCode(PRUint32 *aCharCode);
2430     nsresult GetKeyCode(PRUint32 *aKeyCode);
2431     nsresult GetAltKey(PRBool *aAltKey);
2432     nsresult GetCtrlKey(PRBool *aCtrlKey);
2433     nsresult GetShiftKey(PRBool *aShiftKey);
2434     nsresult GetMetaKey(PRBool *aMetaKey);
2435     nsresult InitKeyEvent(const nsAString *typeArg, PRBool canBubbleArg,
2436             PRBool cancelableArg, nsIDOMAbstractView *viewArg, PRBool ctrlKeyArg,
2437             PRBool altKeyArg, PRBool shiftKeyArg, PRBool metaKeyArg, PRUint32 keyCodeArg,
2438             PRUint32 charCodeArg);
2439 }
2440
2441 [
2442     object,
2443     uuid(3e5432cd-9568-4bd1-8cbe-d50aba110743),
2444     local
2445 ]
2446 interface nsIEmbeddingSiteWindow : nsISupports
2447 {
2448     nsresult SetDimensions(PRUint32 flags, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy);
2449     nsresult GetDimensions(PRUint32 flags, PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy);
2450     nsresult SetFocus();
2451     nsresult GetVisibility(PRBool *aVisibility);
2452     nsresult SetVisibility(PRBool aVisibility);
2453     nsresult GetTitle(PRUnichar **aTitle);
2454     nsresult SetTitle(const PRUnichar *aTitle);
2455     nsresult GetSiteWindow(void **aSiteWindow);
2456 }
2457
2458 [
2459     object,
2460     uuid(2417cbfe-65ad-48a6-b4b6-eb84db174392),
2461     local
2462 ]
2463 interface nsIComponentRegistrar : nsISupports
2464 {
2465     nsresult AutoRegister(nsIFile *aSpec);
2466     nsresult AutoUnregister(nsIFile *aSpec);
2467     nsresult RegisterFactory(const nsCID *aClass, const char *aClassName,
2468             const char *aContractID, nsIFactory *aFactory);
2469     nsresult UnregisterFactory(const nsCID *aClass, nsIFactory *aFactory);
2470     nsresult RegisterFactoryLocation(const nsCID *aClass, const char *aClassName,
2471             const char *aContractID, nsIFile *aFile, const char *aLoaderStr,
2472             const char *aType);
2473     nsresult UnregisterFactoryLocation(const nsCID *aClass, nsIFile *aFile);
2474     nsresult IsCIDRegistered(const nsCID *aClass, PRBool *_retval);
2475     nsresult IsContractIDRegistered(const char *aContractID, PRBool *_retval);
2476     nsresult EnumerateCIDs(nsISimpleEnumerator **_retval);
2477     nsresult EnumerateContractIDs(nsISimpleEnumerator **_retval);
2478     nsresult CIDToContractID(const nsCID *aClass, char **_retval);
2479     nsresult ContractIDToCID(const char *aContractID, nsCID **_retval);
2480 }
2481
2482 [
2483     object,
2484     uuid(1630c61a-325e-49ca-8759-a31b16c47aa5),
2485     local
2486 ]
2487 interface nsIPromptService : nsISupports
2488 {
2489     nsresult Alert(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2490             const PRUnichar *aText);
2491     nsresult AlertCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2492             const PRUnichar *aText, const PRUnichar *aCheckMsg, PRBool *aCheckState);
2493     nsresult Confirm(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2494             const PRUnichar *aText, PRBool *_retval);
2495     nsresult ConfirmCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2496             const PRUnichar *aText, const PRUnichar *aCheckMsg, PRBool *aCheckState,
2497             PRBool *_retval);
2498     nsresult ConfirmEx(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2499             const PRUnichar *aText, PRUint32 aButtonFlags, const PRUnichar *aButton0Title,
2500             const PRUnichar *aButton1Title, const PRUnichar *aButton2Title,
2501             const PRUnichar *aCheckMsg, PRBool *aCheckState, PRInt32 *_retval);
2502     nsresult Prompt(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2503             const PRUnichar *aText, PRUnichar **aValue, const PRUnichar *aCheckMsg,
2504             PRBool *aCheckState, PRBool *_retval);
2505     nsresult PromptUsernameAndPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2506             const PRUnichar *aText, PRUnichar **aUsername, PRUnichar **aPassword,
2507             const PRUnichar *aCheckMsg, PRBool *aCheckState, PRBool *_retval);
2508     nsresult PromptPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2509             const PRUnichar *aText, PRUnichar **aPassword, const PRUnichar *aCheckMsg,
2510             PRBool *aCheckState, PRBool *_retval);
2511     nsresult Select(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
2512             const PRUnichar *aText, PRUint32 aCount, const PRUnichar **aSelectList,
2513             PRInt32 *aOutSelection, PRBool *_retval);
2514 }
2515
2516 [
2517     object,
2518     uuid(b128a1e6-44f3-4331-8fbe-5af360ff21ee),
2519     local
2520 ]
2521 interface nsITooltipTextProvider : nsISupports
2522 {
2523     nsresult GetNodeText(nsIDOMNode *aNode, PRUnichar **aText, PRBool *_retval);
2524 }
2525
2526 [
2527     object,
2528     uuid(02b0625a-e7f3-11d2-9f5a-006008a6efe9),
2529     local
2530 ]
2531 interface nsIProfile : nsISupports
2532 {
2533     nsresult GetProfileCount(PRInt32 *aProfileCount);
2534     nsresult GetProfileList(PRUint32 *length, PRUnichar ***profileNames);
2535     nsresult ProfileExists(const PRUnichar *profileName, PRBool *_retval);
2536     nsresult GetCurrentProfile(PRUnichar **aCurrentProfile);
2537     nsresult SetCurrentProfile(const PRUnichar * aCurrentProfile);
2538     nsresult ShutDownCurrentProfile(PRUint32 shutDownType);
2539     nsresult CreateNewProfile(const PRUnichar *profileName,
2540             const PRUnichar *nativeProfileDir, const PRUnichar *langcode,
2541             PRBool useExistingDir);
2542     nsresult RenameProfile(const PRUnichar *oldName, const PRUnichar *newName);
2543     nsresult DeleteProfile(const PRUnichar *name, PRBool canDeleteFiles);
2544     nsresult CloneProfile(const PRUnichar *profileName);
2545 }
2546
2547 [
2548     object,
2549     uuid(30465632-a777-44cc-90f9-8145475ef999),
2550     local
2551 ]
2552 interface nsIWindowCreator : nsISupports
2553 {
2554     nsresult CreateChromeWindow(nsIWebBrowserChrome *parent, PRUint32 chromeFlags,
2555                                    nsIWebBrowserChrome **_retval);
2556 }
2557
2558 [
2559     object,
2560     uuid(f673ec81-a4b0-11d6-964b-eb5a2bf216fc),
2561     local
2562 ]
2563 interface nsIWindowCreator2 : nsIWindowCreator
2564 {
2565     nsresult CreateChromeWindow2(nsIWebBrowserChrome *parent, PRUint32 chromeFlags,
2566                                  PRUint32 contextFlags, nsIURI *uri, PRBool *cancel,
2567                                  nsIWebBrowserChrome **_retval);
2568 }
2569
2570 [
2571     object,
2572     uuid(002286a8-494b-43b3-8ddd-49e3fc50622b),
2573     local
2574 ]
2575 interface nsIWindowWatcher : nsISupports
2576 {
2577     nsresult OpenWindow(nsIDOMWindow *aParent, const char *aUrl, const char *aName,
2578                         const char *aFeatures, nsISupports *aArguments, nsIDOMWindow **_retval);
2579     nsresult RegisterNotification(nsIObserver *aObserver);
2580     nsresult UnregisterNotification(nsIObserver *aObserver);
2581     nsresult GetWindowEnumerator(nsISimpleEnumerator **_retval);
2582     nsresult GetNewPrompter(nsIDOMWindow *aParent, nsIPrompt **_retval);
2583     nsresult GetNewAuthPrompter(nsIDOMWindow *aParent, nsIAuthPrompt **_retval);
2584     nsresult SetWindowCreator(nsIWindowCreator *creator);
2585     nsresult GetChromeForWindow(nsIDOMWindow *aWindow, nsIWebBrowserChrome **_retval);
2586     nsresult GetWindowByName(const PRUnichar *aTargetName, nsIDOMWindow *aCurrentWindow,
2587                              nsIDOMWindow **_retval);
2588     nsresult GetActiveWindow(nsIDOMWindow **aActiveWindow);
2589     nsresult SetActiveWindow(nsIDOMWindow *aActiveWindow);
2590 }
2591
2592 [
2593     object,
2594     uuid(24f3f4da-18a4-448d-876d-7360fefac029),
2595     local
2596 ]
2597 interface nsIEditingSession : nsISupports
2598 {
2599     nsresult GetEditorStatus(PRUint32 *aEditorStatus);
2600     nsresult MakeWindowEditable(nsIDOMWindow *window, const char *aEditorType,
2601             PRBool doAfterUriLoad, PRBool aMakeWholeDocumentEditable, PRBool aInteractive);
2602     nsresult WindowIsEditable(nsIDOMWindow *window, PRBool *_retval);
2603     nsresult GetEditorForWindow(nsIDOMWindow *window, nsIEditor **_retval);
2604     nsresult SetupEditorOnWindow(nsIDOMWindow *window);
2605     nsresult TearDownEditorOnWindow(nsIDOMWindow *window);
2606     nsresult SetEditorOnControllers(nsIDOMWindow *aWindow, nsIEditor *aEditor);
2607     nsresult DisableJSAndPlugins(nsIDOMWindow *aWindow);
2608     nsresult RestoreJSAndPlugins(nsIDOMWindow *aWindow);
2609     nsresult DetachFromWindow(nsIDOMWindow *aWindow);
2610     nsresult ReattachToWindow(nsIDOMWindow *aWindow);
2611     nsresult GetJsAndPluginsDisabled(PRBool *aJsAndPluginsDisabled);
2612 }
2613
2614 [
2615     object,
2616     uuid(83f892cf-7ed3-490e-967a-62640f3158e1),
2617     local
2618 ]
2619 interface nsICommandParams : nsISupports
2620 {
2621     nsresult GetValueType(const char *name, PRInt16 *_retval);
2622     nsresult GetBooleanValue(const char *name, PRBool *_retval);
2623     nsresult GetLongValue(const char *name, PRInt32 *_retval);
2624     nsresult GetDoubleValue(const char *name, double *_retval);
2625     nsresult GetStringValue(const char *name, nsAString *_retval);
2626     nsresult GetCStringValue(const char *name, char **_retval);
2627     nsresult GetISupportsValue(const char *name, nsISupports **_retval);
2628     nsresult SetBooleanValue(const char *name, PRBool value);
2629     nsresult SetLongValue(const char *name, PRInt32 value);
2630     nsresult SetDoubleValue(const char *name, double value);
2631     nsresult SetStringValue(const char *name, const nsAString *value);
2632     nsresult SetCStringValue(const char *name, const char *value);
2633     nsresult SetISupportsValue(const char *name, nsISupports *value);
2634     nsresult RemoveValue(const char *name);
2635     nsresult HasMoreElements(PRBool *_retval);
2636     nsresult First();
2637     nsresult GetNext(char **_retval);
2638 }
2639
2640 [
2641     object,
2642     uuid(080d2001-f91e-11d4-a73c-f9242928207c),
2643     local
2644 ]
2645 interface nsICommandManager : nsISupports
2646 {
2647     nsresult AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve);
2648     nsresult RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved);
2649     nsresult IsCommandSupported(const char *aCommandName, nsIDOMWindow *aTargetWindow, PRBool *_retval);
2650     nsresult IsCommandEnabled(const char *aCommandName, nsIDOMWindow *aTargetWindow, PRBool *_retval);
2651     nsresult GetCommandState(const char *aCommandName, nsIDOMWindow *aTargetWindow,
2652             nsICommandParams *aCommandParams);
2653     nsresult DoCommand(const char *aCommandName, nsICommandParams *aCommandParams,
2654             nsIDOMWindow *aTargetWindow);
2655 }
2656
2657 [
2658     object,
2659     uuid(47b82b60-a36f-4167-8072-6f421151ed50),
2660     local
2661 ]
2662 interface nsIControllerContext : nsISupports
2663 {
2664     nsresult Init(nsIControllerCommandTable *aCommandTable);
2665     nsresult SetCommandContext(nsISupports *aCommandContext);
2666 }
2667
2668 [
2669     object,
2670     uuid(d5b61b82-1da4-11d3-bf87-00105a1b0627),
2671     local
2672 ]
2673 interface nsIController : nsISupports
2674 {
2675     nsresult IsCommandEnabled(const char *command, PRBool *_retval);
2676     nsresult SupportsCommand(const char *command, PRBool *_retval);
2677     nsresult DoCommand(const char *command);
2678     nsresult OnEvent(const char *eventName);
2679 }
2680
2681 [
2682     object,
2683     uuid(71afb9e6-e8a7-475d-89c4-e46221ebe1a4),
2684     local
2685 ]
2686 interface nsIContent : nsISupports
2687 {
2688     /* This is not a real interface declaration. It's too internal for us. */
2689 }
2690
2691 [
2692     object,
2693     uuid(c38a7935-c854-4df7-8fd4-a26f0d279f31),
2694     local
2695 ]
2696 interface nsIDocument : nsISupports
2697 {
2698     /* This is not a real interface declaration. It's too internal for us. */
2699 }
2700
2701 [
2702     object,
2703     uuid(b1ee32f2-b8c4-49b9-93df-b6fab5d54688),
2704     local
2705 ]
2706 interface nsIContentSerializer : nsISupports
2707 {
2708     nsresult Init(PRUint32 flags, PRUint32 aWrapColumn, const char* aCharSet, PRBool aIsCopying,
2709             PRBool aIsWholeDocument);
2710     nsresult AppendText(nsIContent *aText, PRInt32 aStartOffset, PRInt32 aEndOffset, nsAString *aStr);
2711     nsresult AppendCDATASection(nsIContent *aCDATASection, PRInt32 aStartOffset,
2712             PRInt32 aEndOffset, nsAString *aStr);
2713     nsresult AppendProcessingInstruction(nsIContent* aPI, PRInt32 aStartOffset,
2714             PRInt32 aEndOffset, nsAString *aStr);
2715     nsresult AppendComment(nsIContent *aComment, PRInt32 aStartOffset, PRInt32 aEndOffset,
2716             nsAString *aStr);
2717     nsresult AppendDoctype(nsIContent *aDoctype, nsAString *aStr);
2718     nsresult AppendElementStart(nsIContent *aElement, nsIContent *aOriginalElement,
2719             nsAString *aStr);
2720     nsresult AppendElementEnd(nsIContent *aElement, nsAString *aStr);
2721     nsresult Flush(nsAString *aStr);
2722     nsresult AppendDocumentStart(nsIDocument *aDocument, nsAString *aStr);
2723 }
2724
2725 [
2726     object,
2727     uuid(972e54e1-dec3-4e3f-87ec-408a7dbcfd92),
2728     local
2729 ]
2730 interface nsIEditor  : nsISupports
2731 {
2732     typedef void *nsIPresShellPtr;
2733     typedef void *nsIContentPtr;
2734
2735     nsresult GetSelection([out] nsISelection *_retval);
2736     nsresult Init([in] nsIDOMDocument *doc, [in] nsIPresShellPtr shell, [in] nsIContentPtr aRoot, [in] nsISelectionController *aSelCon, [in] PRUint32 aFlags);
2737     nsresult SetAttributeOrEquivalent([in] nsIDOMElement *element, [in] const nsAString *sourceAttrName, [in] const nsAString *sourceAttrValue, [in] PRBool aSuppressTransaction);
2738     nsresult RemoveAttributeOrEquivalent([in] nsIDOMElement *element, [in] const nsAString *sourceAttrName, [in] PRBool aSuppressTransaction);
2739     nsresult PostCreate();
2740     nsresult PreDestroy();
2741     nsresult GetFlags([out] PRUint32 *_retval);
2742     nsresult SetFlags([in] PRUint32 val);
2743     nsresult GetContentsMIMEType([out] char **_retval);
2744     nsresult SetContentsMIMEType([in] const char *val);
2745     nsresult GetIsDocumentEditable([out] PRBool *_retval);
2746     nsresult GetDocument([out] nsIDOMDocument **_retval);
2747     nsresult GetRootElement([out] nsIDOMElement **_retval);
2748     nsresult GetSelectionController([out] nsISelectionController **_retval);
2749     nsresult DeleteSelection([in] PRInt16 action);
2750     nsresult GetDocumentIsEmpty([out] PRBool *_retval);
2751     nsresult GetDocumentModified([out] PRBool *_retval);
2752     nsresult GetDocumentCharacterSet([out] nsACString *_retval);
2753     nsresult SetDocumentCharacterSet([in] const nsACString *val);
2754     nsresult ResetModificationCount();
2755     nsresult GetModificationCount([out] PRInt32 *_retval);
2756     nsresult IncrementModificationCount([in] PRInt32 aModCount);
2757     nsresult GetTransactionManager([out] nsITransactionManager **_retval);
2758     nsresult SetTransactionManager(nsITransactionManager *aTransactionManager);
2759     nsresult DoTransaction([in] nsITransaction *txn);
2760     nsresult EnableUndo([in] PRBool enable);
2761     nsresult Undo([in] PRUint32 count);
2762     nsresult CanUndo([out] PRBool *isEnabled, [out] PRBool *canUndo);
2763     nsresult Redo([in] PRUint32 count);
2764     nsresult CanRedo([out] PRBool *isEnabled, [out] PRBool *canRedo);
2765     nsresult BeginTransaction();
2766     nsresult EndTransaction();
2767     nsresult BeginPlaceHolderTransaction([in] nsIAtom *name);
2768     nsresult EndPlaceHolderTransaction();
2769     nsresult ShouldTxnSetSelection([out] PRBool *_retval);
2770     nsresult SetShouldTxnSetSelection([in] PRBool should);
2771     nsresult GetInlineSpellChecker([out] nsIInlineSpellChecker **_retval);
2772     nsresult SyncRealTimeSpell();
2773     nsresult SetSpellcheckUserOverride(PRBool enable);
2774     nsresult Cut();
2775     nsresult CanCut([out] PRBool *_retval);
2776     nsresult Copy();
2777     nsresult CanCopy([out] PRBool *_retval);
2778     nsresult Paste([in] PRInt32 aSelectionType);
2779     nsresult PasteTransferable(nsITransferable *aTransferable);
2780     nsresult CanPaste([in] PRInt32 aSelectionType, [out] PRBool *_retval);
2781     nsresult CanPasteTransferable(nsITransferable *aTransferable, PRBool *_retval);
2782     nsresult SelectAll();
2783     nsresult BeginningOfDocument();
2784     nsresult EndOfDocument();
2785     nsresult CanDrag([in] nsIDOMEvent *aEvent, [out] PRBool *_retval);
2786     nsresult DoDrag([in] nsIDOMEvent *aEvent);
2787     nsresult InsertFromDrop([in] nsIDOMEvent *aEvent);
2788     nsresult SetAttribute([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [in] const nsAString *attvalue);
2789     nsresult GetAttributeValue([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [out] nsAString *resultValue, PRBool *_retval);
2790     nsresult RemoveAttribute([in] nsIDOMElement *aElement, [in] const nsAString *aAttribute);
2791     nsresult CloneAttribute([in] const nsAString *aAttribute, [in] nsIDOMNode *aDestNode, [in] nsIDOMNode *aSourceNode);
2792     nsresult CloneAttributes([in] nsIDOMNode *destNode, [in] nsIDOMNode *sourceNode);
2793     nsresult CreateNode([in] const nsAString *tag, [in] nsIDOMNode *parent, [in] PRInt32 position, [out] nsIDOMNode **_retval);
2794     nsresult InsertNode([in] nsIDOMNode *node, [in] nsIDOMNode *parent, [in] PRInt32 aPosition);
2795     nsresult SplitNode([in] nsIDOMNode *existingRightNode, [in] PRInt32 offset, [out] nsIDOMNode **newLeftNode);
2796     nsresult JoinNodes([in] nsIDOMNode *leftNode, [in] nsIDOMNode *rightNode, [in] nsIDOMNode *parent);
2797     nsresult DeleteNode([in] nsIDOMNode *child);
2798     nsresult MarkNodeDirty([in] nsIDOMNode *node);
2799     nsresult SwitchTextDirection();
2800     nsresult OutputToString([in] nsAString formatType, [in] PRUint32 flags, [out] nsAString *_retval);
2801     nsresult OutputToStream([in] nsIOutputStream *aStream, [in] nsAString *formatType, [in] nsACString *charsetOverride, [in] PRUint32 flags);
2802     nsresult AddEditorObserver([in] nsIEditorObserver *observer);
2803     nsresult RemoveEditorObserver([in] nsIEditorObserver *observer);
2804     nsresult AddEditActionListener([in] nsIEditActionListener *listener);
2805     nsresult RemoveEditActionListener([in] nsIEditActionListener *listener);
2806     nsresult AddDocumentStateListener([in] nsIDocumentStateListener *listener);
2807     nsresult RemoveDocumentStateListener([in] nsIDocumentStateListener *listener);
2808     nsresult DumpContentTree();
2809     nsresult DebugDumpContent();
2810     nsresult DebugUnitTests([out] PRInt32 *outNumTests, [out] PRInt32 *outNumTestsFailed);
2811     PRBool IsModifiableNode(nsIDOMNode *aNode);
2812 }
2813
2814 [
2815     object,
2816     uuid(afc36593-5787-4420-93d9-b2c0ccbf0cad),
2817     local
2818 ]
2819 interface nsIHTMLEditor : nsISupports
2820 {
2821     nsresult AddDefaultProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
2822     nsresult RemoveDefaultProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
2823     nsresult RemoveAllDefaultProperties();
2824     nsresult SetCSSInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
2825     nsresult SetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
2826     nsresult GetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue, [out] PRBool *aFirst, [out] PRBool *aAny, [out] PRBool *aAll);
2827     nsresult GetInlinePropertyWithAttrValue([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue, [out] PRBool *aFirst, [out] PRBool *aAny, [out] PRBool *aAll, [out] nsAString *_retval);
2828     nsresult RemoveAllInlineProperties();
2829     nsresult RemoveInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute);
2830     nsresult IncreaseFontSize();
2831     nsresult DecreaseFontSize();
2832     nsresult CanDrag([in] nsIDOMEvent *aEvent, [out] PRBool *_retval);
2833     nsresult DoDrag([in] nsIDOMEvent *aEvent);
2834     nsresult InsertFromDrop([in] nsIDOMEvent *aEvent);
2835     nsresult NodeIsBlock([in] nsIDOMNode *node, PRBool *_retval);
2836     nsresult InsertHTML([in] nsAString *aInputString);
2837     nsresult PasteNoFormatting([in] PRInt32 aSelectionType);
2838     nsresult RebuildDocumentFromSource([in] nsAString *aSourceString);
2839     nsresult InsertHTMLWithContext([in] nsAString *aInputString, [in] nsAString *aContextStr, [in] nsAString *aInfoStr, [in] nsAString *aFlavor, [in] nsIDOMDocument *aSourceDoc, [in] nsIDOMNode *aDestinationNode, [in] PRInt32 aDestinationOffset, [in] PRBool aDeleteSelection);
2840     nsresult InsertElementAtSelection([in] nsIDOMElement *aElement, [in] PRBool aDeleteSelection);
2841     nsresult SetDocumentTitle([in] nsAString *aTitle);
2842     nsresult UpdateBaseURL();
2843     nsresult SelectElement([in] nsIDOMElement *aElement);
2844     nsresult SetCaretAfterElement([in] nsIDOMElement *aElement);
2845     nsresult SetParagraphFormat([in] nsAString *aParagraphFormat);
2846     nsresult GetParagraphState([out] PRBool *aMixed, [out] nsAString *_retval);
2847     nsresult GetFontFaceState([out] PRBool *aMixed, [out] nsAString *_retval);
2848     nsresult GetFontColorState([out] PRBool *aMixed, [out] nsAString *_retval);
2849     nsresult GetBackgroundColorState([out] PRBool *aMixed, [out] nsAString *_retval);
2850     nsresult GetHighlightColorState([out] PRBool *aMixed, [out] nsAString *_retval);
2851     nsresult GetListState([out] PRBool *aMixed, [out] PRBool *aOL, [out] PRBool *aUL, [out] PRBool *aDL);
2852     nsresult GetListItemState([out] PRBool *aMixed, [out] PRBool *aLI, [out] PRBool *aDT, [out] PRBool *aDD);
2853     nsresult GetAlignment([out] PRBool *aMixed, [out] PRInt16 *aAlign);
2854     nsresult GetIndentState([out] PRBool *aCanIndent, [out] PRBool *aCanOutdent);
2855     nsresult MakeOrChangeList([in] nsAString *aListType, [in] PRBool entireList, [in] nsAString *aBulletType);
2856     nsresult RemoveList([in] nsAString *aListType);
2857     nsresult Indent([in] nsAString *aIndent);
2858     nsresult Align([in] nsAString *aAlign);
2859     nsresult GetElementOrParentByTagName([in] nsAString *aTagName, [in] nsIDOMNode *aNode, [out] nsIDOMElement **_retval);
2860     nsresult GetSelectedElement([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
2861     nsresult GetHeadContentsAsHTML([out] nsAString *_retval);
2862     nsresult ReplaceHeadContentsWithHTML([in] nsAString *aSourceToInsert);
2863     nsresult CreateElementWithDefaults([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
2864     nsresult InsertLinkAroundSelection([in] nsIDOMElement *aAnchorElement);
2865     nsresult SetBackgroundColor([in] nsAString *aColor);
2866     nsresult SetBodyAttribute([in] nsAString *aAttr, [in] nsAString *aValue);
2867     nsresult IgnoreSpuriousDragEvent([in] PRBool aIgnoreSpuriousDragEvent);
2868     nsresult GetLinkedObjects([out] nsISupportsArray **_retval);
2869     nsresult GetIsCSSEnabled([out] PRBool *_retval);
2870     nsresult SetIsCSSEnabled([in] PRBool prb);
2871     nsresult AddInsertionListener([in] nsIContentFilter *inFilter);
2872     nsresult RemoveInsertionListener([in] nsIContentFilter *inFilter);
2873     nsresult CreateAnonymousElement([in] nsAString *aTag, [in] nsIDOMNode *aParentNode, [in] nsAString *aAnonClass, [in] PRBool aIsCreatedHidden, [out] nsIDOMElement **_retval);
2874     nsresult GetSelectionContainer([out] nsIDOMElement **_retval);
2875     nsresult CheckSelectionStateForAnonymousButtons([in] nsISelection *aSelection);
2876     nsresult IsAnonymousElement([in] nsIDOMElement *aElement, [out] PRBool *_retval);
2877     nsresult GetReturnInParagraphCreatesNewParagraph([out] PRBool *_retval);
2878     nsresult SetReturnInParagraphCreatesNewParagraph([in] PRBool prb);
2879 }
2880
2881 [
2882     object,
2883     uuid(98cdbcc4-2d81-4191-a63f-b6c52085edbc),
2884     local
2885 ]
2886 interface nsIDocShell : nsISupports
2887 {
2888     nsresult LoadURI(nsIURI *uri, nsIDocShellLoadInfo *loadInfo, PRUint32 aLoadFlags, PRBool firstParty);
2889     nsresult LoadStream(nsIInputStream *aStream, nsIURI *aURI, const nsACString *aContentType,
2890             const nsACString *aContentCharset, nsIDocShellLoadInfo *aLoadInfo);
2891     nsresult InternalLoad(nsIURI *aURI, nsIURI *aReferrer, nsISupports *aOwner, PRUint32 aFlags, const PRUnichar *aWindowTarget,
2892             const char *aTypeHint, nsIInputStream *aPostDataStream, nsIInputStream *aHeadersStream, PRUint32 aLoadFlags,
2893             nsISHEntry *aSHEntry, PRBool firstParty, nsIDocShell **aDocShell, nsIRequest **aRequest);
2894     nsresult AddState(nsIVariant *aData, const nsAString *aTitle, const nsAString *aURL, PRBool aReplace);
2895     nsresult CreateLoadInfo(nsIDocShellLoadInfo **loadInfo);
2896     nsresult PrepareForNewContentModel();
2897     nsresult SetCurrentURI(nsIURI *aURI);
2898     nsresult FirePageHideNotification(PRBool isUnload);
2899     nsresult GetPresContext(void /*nsPresContext*/ **aPresContext);
2900     nsresult GetPresShell(nsIPresShell **aPresShell);
2901     nsresult GetEldestPresShell(nsIPresShell **aEldestPresShell);
2902     nsresult GetContentViewer(nsIContentViewer **aContentViewer);
2903     nsresult GetChromeEventHandler(nsIDOMEventTarget **aChromeEventHandler);
2904     nsresult SetChromeEventHandler(nsIDOMEventTarget *aChromeEventHandler);
2905     nsresult GetDocumentCharsetInfo(nsIDocumentCharsetInfo **aDocumentCharsetInfo);
2906     nsresult SetDocumentCharsetInfo(nsIDocumentCharsetInfo *aDocumentCharsetInfo);
2907     nsresult GetAllowPlugins(PRBool *aAllowPlugins);
2908     nsresult SetAllowPlugins(PRBool aAllowPlugins);
2909     nsresult GetAllowJavascript(PRBool *aAllowJavascript);
2910     nsresult SetAllowJavascript(PRBool aAllowJavascript);
2911     nsresult GetAllowMetaRedirects(PRBool *aAllowMetaRedirects);
2912     nsresult SetAllowMetaRedirects(PRBool aAllowMetaRedirects);
2913     nsresult GetAllowSubframes(PRBool *aAllowSubframes);
2914     nsresult SetAllowSubframes(PRBool aAllowSubframes);
2915     nsresult GetAllowImages(PRBool *aAllowImages);
2916     nsresult SetAllowImages(PRBool aAllowImages);
2917     nsresult GetAllowDNSPrefetch(PRBool *aAllowDNSPrefetch);
2918     nsresult SetAllowDNSPrefetch(PRBool aAllowDNSPrefetch);
2919     nsresult GetDocShellEnumerator(PRInt32 aItemType, PRInt32 aDirection, nsISimpleEnumerator **_retval);
2920     nsresult GetAppType(PRUint32 *aAppType);
2921     nsresult SetAppType(PRUint32 aAppType);
2922     nsresult GetAllowAuth(PRBool *aAllowAuth);
2923     nsresult SetAllowAuth(PRBool aAllowAuth);
2924     nsresult GetZoom(float *aZoom);
2925     nsresult SetZoom(float aZoom);
2926     nsresult GetMarginWidth(PRInt32 *aMarginWidth);
2927     nsresult SetMarginWidth(PRInt32 aMarginWidth);
2928     nsresult GetMarginHeight(PRInt32 *aMarginHeight);
2929     nsresult SetMarginHeight(PRInt32 aMarginHeight);
2930     nsresult TabToTreeOwner(PRBool forward, PRBool *tookFocus);
2931     nsresult GetBusyFlags(PRUint32 *aBusyFlags);
2932     nsresult GetLoadType(PRUint32 *aLoadType);
2933     nsresult SetLoadType(PRUint32 aLoadType);
2934     nsresult IsBeingDestroyed(PRBool *_retval);
2935     nsresult GetIsExecutingOnLoadHandler(PRBool *aIsExecutingOnLoadHandler);
2936     nsresult GetLayoutHistoryState(nsILayoutHistoryState **aLayoutHistoryState);
2937     nsresult SetLayoutHistoryState(nsILayoutHistoryState *aLayoutHistoryState);
2938     nsresult GetShouldSaveLayoutState(PRBool *aShouldSaveLayoutState);
2939     nsresult GetSecurityUI(nsISecureBrowserUI **aSecurityUI);
2940     nsresult SetSecurityUI(nsISecureBrowserUI *aSecurityUI);
2941     nsresult SuspendRefreshURIs();
2942     nsresult ResumeRefreshURIs();
2943     nsresult BeginRestore(nsIContentViewer *viewer, PRBool top);
2944     nsresult FinishRestore();
2945     nsresult GetRestoringDocument(PRBool *aRestoringDocument);
2946     nsresult GetUseErrorPages(PRBool *aUseErrorPages);
2947     nsresult SetUseErrorPages(PRBool aUseErrorPages);
2948     nsresult GetPreviousTransIndex(PRInt32 *aPreviousTransIndex);
2949     nsresult GetLoadedTransIndex(PRInt32 *aLoadedTransIndex);
2950     nsresult HistoryPurged(PRInt32 numEntries);
2951     nsresult GetSessionStorageForURI(nsIURI *uri, const nsAString *documentURI, nsIDOMStorage **_retval);
2952     nsresult GetSessionStorageForPrincipal(nsIPrincipal *principal, const nsAString *documentURI,
2953             PRBool create, nsIDOMStorage **_retval);
2954     nsresult AddSessionStorage(nsIPrincipal *principal, nsIDOMStorage *storage);
2955     nsresult GetCurrentDocumentChannel(nsIChannel **aCurrentDocumentChannel);
2956     nsresult SetChildOffset(PRUint32 offset);
2957     nsresult GetIsInUnload(PRBool *aIsInUnload);
2958     nsresult GetChannelIsUnsafe(PRBool *aChannelIsUnsafe);
2959     void DetachEditorFromWindow();
2960     nsresult GetIsOffScreenBrowser(PRBool *aIsOffScreenBrowser);
2961     nsresult SetIsOffScreenBrowser(PRBool aIsOffScreenBrowser);
2962     nsresult GetPrintPreview(nsIWebBrowserPrint **aPrintPreview);
2963     nsresult GetCanExecuteScripts(PRBool *aCanExecuteScripts);
2964     nsresult GetIsActive(PRBool *aIsActive);
2965     nsresult SetIsActive(PRBool aIsActive);
2966     nsresult GetHistoryID(PRUint64 *aHistoryID);
2967     nsresult GetIsAppTab(PRBool *aIsAppTab);
2968     nsresult SetIsAppTab(PRBool aIsAppTab);
2969 }
2970
2971 [
2972     object,
2973     uuid(85eea794-ed8e-4e1b-a128-d09300ae51aa),
2974     local
2975 ]
2976 interface nsIMutationObserver : nsISupports
2977 {
2978     void CharacterDataWillChange(nsIDocument *aDocument, nsIContent *aContent,
2979                                  void /*CharacterDataChangeInfo*/ *aInfo);
2980     void CharacterDataChanged(nsIDocument *aDocument, nsIContent *aContent,
2981                               void /*CharacterDataChangeInfo*/ *aInfo);
2982     void AttributeWillChange(nsIDocument *aDocument, nsIContent * aContent, PRInt32 aNameSpaceID,
2983                              nsIAtom *aAttribute, PRInt32 aModType);
2984     void AttributeChanged(nsIDocument *aDocument, nsIContent *aContent, PRInt32 aNameSpaceID,
2985                           nsIAtom *aAttribute, PRInt32 aModType);
2986     void ContentAppended(nsIDocument *aDocument, nsIContent *aContainer, nsIContent* aFirstNewContent,
2987                          PRInt32 aNewIndexInContainer);
2988     void ContentInserted(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
2989                          PRInt32 aIndexInContainer);
2990     void ContentRemoved(nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild,
2991                         PRInt32 aIndexInContainer, nsIContent *aPreviousSibling);
2992     void NodeWillBeDestroyed(const nsINode *aNode);
2993     void ParentChainChanged(nsIContent *aContent);
2994 }
2995
2996 [
2997     object,
2998     uuid(cbc0cbd8-bbb7-46d6-a551-378a6953a714),
2999     local
3000 ]
3001 interface nsIParser : nsISupports
3002 {
3003     typedef int nsDTDMode;
3004     typedef int eParserCommands;
3005
3006     void SetContentSink(nsIContentSink *aSink);
3007     nsIContentSink *GetContentSink();
3008     void GetCommand(nsACString *aCommand);
3009     void SetCommand2(const char *aCommand);
3010     void SetCommand(eParserCommands aParserCommand);
3011     void SetDocumentCharset(const nsACString *aCharset, PRInt32 aSource);
3012     void GetDocumentCharset(nsACString *oCharset, PRInt32 *oSource);
3013     void SetParserFilter(nsIParserFilter *aFilter);
3014     nsresult GetChannel(nsIChannel **aChannel);
3015     nsresult GetDTD(nsIDTD **aDTD);
3016     nsresult GetStreamListener(nsIStreamListener **aListener);
3017     nsresult ContinueInterruptedParsing();
3018     void BlockParser();
3019     void UnblockParser();
3020     PRBool IsParserEnabled();
3021     PRBool IsComplete();
3022     nsresult Parse(nsIURI *aURL, nsIRequestObserver *aListener, void *aKey, nsDTDMode aMode);
3023     nsresult Parse2(const nsAString *aSourceBuffer, void *aKey, const nsACString *aMimeType, PRBool aLastCall, nsDTDMode aMode);
3024     void *GetRootContextKey();
3025     nsresult Terminate();
3026     nsresult ParseFragment(const nsAString *aSourceBuffer, void *aKey, void /*nsTArray<nsString>*/ *aTagStack,
3027             PRBool aXMLMode, const nsACString *aContentType, nsDTDMode aMode);
3028     nsresult ParseFragment2(const nsAString *aSourceBuffer, nsIContent *aTargetNode, nsIAtom *aContextLocalName,
3029             PRInt32 aContextNamespace, PRBool aQuirks);
3030     nsresult BuildModel();
3031     nsresult CancelParsingEvents();
3032     void cdecl Reset();
3033     PRBool cdecl CanInterrupt();
3034     PRBool cdecl IsInsertionPointDefined();
3035     void cdecl BeginEvaluatingParserInsertedScript();
3036     void cdecl EndEvaluatingParserInsertedScript();
3037     void cdecl MarkAsNotScriptCreated();
3038     PRBool cdecl IsScriptCreated();
3039 }
3040
3041 [
3042     object,
3043     uuid(3d005225-210f-4b07-b1d9-96020574c437),
3044     local
3045 ]
3046 interface nsIDocumentObserver : nsIMutationObserver
3047 {
3048     typedef int nsUpdateType;
3049
3050     typedef struct {
3051         PRUint64 mStates;
3052     } nsEventStates;
3053
3054     void BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
3055     void EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType);
3056     void BeginLoad(nsIDocument *aDocument);
3057     void EndLoad(nsIDocument *aDocument);
3058     void ContentStatesChanged(nsIDocument *aDocument, nsIContent *aContent1, nsIContent *aContent2,
3059                               nsEventStates aStateMask);
3060     void DocumentStatesChanged(nsIDocument* aDocument, nsEventStates aStateMask);
3061     void StyleSheetAdded(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, PRBool aDocumentSheet);
3062     void StyleSheetRemoved(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, PRBool aDocumentSheet);
3063     void StyleSheetApplicableStateChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet,
3064                                           PRBool aApplicable);
3065     void StyleRuleChanged(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aOldStyleRule,
3066                           nsIStyleRule *aNewStyleRule);
3067     void StyleRuleAdded(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule);
3068     void StyleRuleRemoved(nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule);
3069     void BindToDocument(nsIDocument *aDocument, nsIContent *aContent);
3070     nsresult DoneAddingChildren(nsIContent *aContent, PRBool aHaveNotified, nsIParser *aParser);
3071 }
3072
3073 [
3074     object,
3075     uuid(3682dd99-8560-44f4-9b8f-ccce9d7b96fb),
3076     local
3077 ]
3078 interface nsIContentUtils : nsISupports
3079 {
3080     PRBool IsSafeToRunScript();
3081     PRBool ParseIntMarginValue(const nsAString *aString, nsIntMargin *result);
3082     void /*already_AddRefed<nsIDocumentLoaderFactory>*/ FindInternalContentViewer(
3083             const char *aType, int /*ContentViewerType*/ *aLoaderType);
3084     nsresult AddDocumentObserver(nsIDocument *aDocument, nsIDocumentObserver *aObserver);
3085     nsresult RemoveDocumentObserver(nsIDocument *aDocument, nsIDocumentObserver *aObserver);
3086     nsresult AddMutationObserver(nsINode *aNode, nsIMutationObserver *aObserver);
3087     nsresult RemoveMutationObserver(nsINode *aNode, nsIMutationObserver *aObserver);
3088     nsresult AddScriptRunner(nsIRunnable *aRunnable);
3089 }
3090
3091 /* Parts of npapi.h */
3092
3093 cpp_quote("#define NP_VERSION_MAJOR 0")
3094 cpp_quote("#define NP_VERSION_MINOR 25")
3095
3096 typedef unsigned char NPBool;
3097 typedef INT16 NPError;
3098 typedef INT16 NPReason;
3099 typedef char *NPMIMEType;
3100
3101 typedef struct _NPP {
3102     void *pdata;
3103     void *ndata;
3104 } NPP_t, *NPP;
3105
3106 typedef struct _NPStream {
3107     void *pdata;
3108     void *ndata;
3109     const char *url;
3110     UINT32 end;
3111     UINT32 lastmodified;
3112     void *notifyData;
3113     const char *headers;
3114 } NPStream;
3115
3116 typedef struct _NPSavedData {
3117     INT32 len;
3118     void *buf;
3119 } NPSavedData;
3120
3121 typedef struct _NPRect {
3122     UINT16 top;
3123     UINT16 left;
3124     UINT16 bottom;
3125     UINT16 right;
3126 } NPRect;
3127
3128 typedef enum {
3129     NPFocusNext = 0,
3130     NPFocusPrevious = 1
3131 } NPFocusDirection;
3132
3133 #define NP_ABI_MASK 0
3134
3135 typedef enum {
3136     NPPVpluginNameString = 1,
3137     NPPVpluginDescriptionString,
3138     NPPVpluginWindowBool,
3139     NPPVpluginTransparentBool,
3140     NPPVjavaClass,
3141     NPPVpluginWindowSize,
3142     NPPVpluginTimerInterval,
3143     NPPVpluginScriptableInstance = (10 | NP_ABI_MASK),
3144     NPPVpluginScriptableIID = 11,
3145     NPPVjavascriptPushCallerBool = 12,
3146     NPPVpluginKeepLibraryInMemory = 13,
3147     NPPVpluginNeedsXEmbed = 14,
3148     NPPVpluginScriptableNPObject = 15,
3149     NPPVformValue = 16,
3150     NPPVpluginUrlRequestsDisplayedBool = 17,
3151     NPPVpluginWantsAllNetworkStreams = 18,
3152     NPPVpluginNativeAccessibleAtkPlugId = 19,
3153     NPPVpluginCancelSrcStream = 20,
3154     NPPVSupportsAdvancedKeyHandling = 21
3155 } NPPVariable;
3156
3157 typedef enum {
3158     NPNVxDisplay = 1,
3159     NPNVxtAppContext,
3160     NPNVnetscapeWindow,
3161     NPNVjavascriptEnabledBool,
3162     NPNVasdEnabledBool,
3163     NPNVisOfflineBool,
3164     NPNVserviceManager = (10 | NP_ABI_MASK),
3165     NPNVDOMElement     = (11 | NP_ABI_MASK),
3166     NPNVDOMWindow      = (12 | NP_ABI_MASK),
3167     NPNVToolkit        = (13 | NP_ABI_MASK),
3168     NPNVSupportsXEmbedBool = 14,
3169     NPNVWindowNPObject = 15,
3170     NPNVPluginElementNPObject = 16,
3171     NPNVSupportsWindowless = 17,
3172     NPNVprivateModeBool = 18,
3173     NPNVsupportsAdvancedKeyHandling = 21
3174 } NPNVariable;
3175
3176 typedef enum {
3177     NPWindowTypeWindow = 1,
3178     NPWindowTypeDrawable
3179 } NPWindowType;
3180
3181 typedef struct _NPWindow {
3182     void *window;
3183     INT32 x;
3184     INT32 y;
3185     UINT32 width;
3186     UINT32 height;
3187     NPRect clipRect;
3188     NPWindowType type;
3189 } NPWindow;
3190
3191 typedef struct _NPFullPrint {
3192     NPBool pluginPrinted;
3193     NPBool printOne;
3194     void *platformPrint;
3195 } NPFullPrint;
3196
3197 typedef struct _NPEmbedPrint {
3198     NPWindow window;
3199     void *platformPrint;
3200 } NPEmbedPrint;
3201
3202 typedef struct _NPPrint {
3203     UINT16 mode;
3204     union {
3205         NPFullPrint fullPrint;
3206         NPEmbedPrint embedPrint;
3207     } print;
3208 } NPPrint;
3209
3210 typedef HRGN NPRegion;
3211
3212 [
3213     object,
3214     uuid(84994340-e120-4051-824f-d4ee8aef1a3e),
3215     local
3216 ]
3217 interface nsIPluginInstance : nsISupports
3218 {
3219     typedef void *JSContext;
3220     typedef void *JSObject;
3221     typedef void *gfxASurface;
3222
3223     nsresult Initialize(nsIPluginInstanceOwner *aOwner, const char *aMIMEType);
3224     nsresult Start();
3225     nsresult Stop();
3226     nsresult SetWindow(NPWindow *aWindow);
3227     nsresult NewStreamToPlugin(nsIPluginStreamListener **aListener);
3228     nsresult NewStreamFromPlugin(const char *aType, const char *aTarget, nsIOutputStream **aResult);
3229     nsresult Print(NPPrint *aPlatformPrint);
3230     nsresult HandleEvent(void *aEvent, PRInt16 *aHandled);
3231     nsresult InvalidateRect(NPRect *aRect);
3232     nsresult InvalidateRegion(NPRegion aRegion);
3233     nsresult ForceRedraw();
3234     nsresult GetMIMEType(const char **aValue);
3235     nsresult GetJSContext(JSContext **aJSContext);
3236     nsresult GetOwner(nsIPluginInstanceOwner **aOwner);
3237     nsresult SetOwner(nsIPluginInstanceOwner *aOwner);
3238     nsresult ShowStatus(const char *aMessage);
3239     nsresult InvalidateOwner();
3240     nsresult GetJSObject(JSContext *cx, JSObject **_retval);
3241     nsresult GetFormValue(nsAString *aFormValue);
3242     nsresult PushPopupsEnabledState(PRBool aEnabled);
3243     nsresult PopPopupsEnabledState();
3244     nsresult GetPluginAPIVersion(PRUint16 *aPluginAPIVersion);
3245     nsresult DefineJavaProperties();
3246     nsresult ShouldCache(PRBool *_retval);
3247     nsresult IsWindowless(PRBool *_retval);
3248     nsresult IsTransparent(PRBool *_retval);
3249     nsresult GetValueFromPlugin(NPPVariable variable, void *aValue);
3250     nsresult GetDrawingModel(PRInt32 *_retval);
3251     nsresult AsyncSetWindow(NPWindow *aWindow);
3252     nsresult NotifyPainted();
3253     nsresult GetSurface(gfxASurface **aSurface);
3254     nsresult UseAsyncPainting(PRBool *_retval);
3255
3256 }
3257
3258 [
3259     object,
3260     uuid(6d827df5-b5cd-416c-85cb-3cdd05c7aed1),
3261     local
3262 ]
3263 interface nsIPluginTagInfo : nsISupports
3264 {
3265     typedef enum {
3266         nsPluginTagType_Unknown,
3267         nsPluginTagType_Embed,
3268         nsPluginTagType_Object,
3269         nsPluginTagType_Applet
3270     }  nsPluginTagType;
3271
3272     nsresult GetAttributes(PRUint16 *aCount, const char ***aNames, const char ***aValues);
3273     nsresult GetAttribute(const char *aName, const char **aResult);
3274     nsresult GetTagType(nsPluginTagType *aTagType);
3275     nsresult GetTagText(const char **aTagText);
3276     nsresult GetParameters(PRUint16 *aCount, const char ***aNames, const char ***aValues);
3277     nsresult GetParameter(const char *aName, const char **aResult);
3278     nsresult GetDocumentBase(const char **aDocumentBase);
3279     nsresult GetDocumentEncoding(const char **aDocumentEncoding);
3280     nsresult GetAlignment(const char **aElignment);
3281     nsresult GetWidth(PRUint32 *aWidth);
3282     nsresult GetHeight(PRUint32 *aHeight);
3283     nsresult GetBorderVertSpace(PRUint32 *aBorderVertSpace);
3284     nsresult GetBorderHorizSpace(PRUint32 *aBorderHorizSpace);
3285     nsresult GetUniqueID(PRUint32 *aUniqueID);
3286     nsresult GetDOMElement(nsIDOMElement **aDOMElement);
3287 }