git.oblomov.eu Git - wine/blob - 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 an usual idl file. Interfaces in this file are XPCOM interfaces
  22  * (NOT MSCOM!), but we generate the header file with WIDL compatibile with XPCOM,
  23  * useable in C code.
  24  */
  25
  26 cpp_quote("#define GECKO_VERSION \"0.1.0\"");
  27 cpp_quote("#define GECKO_VERSION_STRING \"Wine Gecko \" GECKO_VERSION");
  28
  29 import "wtypes.idl";
  30
  31 typedef HRESULT nsresult;
  32 typedef ULONG nsrefcnt;
  33
  34 typedef IID nsID;
  35 typedef IID nsIID;
  36 typedef nsIID nsCID;
  37 typedef REFIID nsIIDRef;
  38 typedef nsIIDRef nsCIDRef;
  39
  40 typedef void** nsQIResult;
  41 typedef WCHAR PRUnichar;
  42 typedef ULONG PRUint32;
  43 typedef LONG PRInt32;
  44 typedef WORD PRUint16;
  45 typedef INT16 PRInt16;
  46 typedef BYTE PRUint8;
  47 typedef BOOL PRBool;
  48 typedef LARGE_INTEGER PRInt64;
  49 typedef ULARGE_INTEGER PRUint64;
  50 typedef PRUint64 DOMTimeStamp;
  51 typedef PRUint32 nsLoadFlags;
  52
  53 typedef struct {
  54     void *v;
  55     void *d1;
  56     PRUint32 d2;
  57     void *d3;
  58 } nsCStringContainer;
  59
  60 typedef struct {
  61     void *v;
  62     void *d1;
  63     PRUint32 d2;
  64     void *d3;
  65 } nsStringContainer;
  66
  67 typedef nsCStringContainer nsACString;
  68 typedef nsStringContainer nsAString;
  69
  70 interface nsIWebBrowserChrome;
  71 interface nsILoadGroup;
  72 interface nsIDOMNode;
  73 interface nsIDOMDocument;
  74 interface nsIDOMEvent;
  75 interface nsIEditor;
  76 interface nsISelectionController;
  77 interface nsITransactionManager;
  78 interface nsITransaction;
  79 interface nsIInlineSpellChecker;
  80 interface nsIOutputStream;
  81 interface nsIEditorObserver;
  82 interface nsIEditActionListener;
  83 interface nsIDocumentStateListener;
  84
  85 interface IMoniker;
  86
  87 [
  88     object,
  89     uuid(00000000-0000-0000-c000-000000000046)
  90 ]
  91 interface nsISupports
  92 {
  93     nsresult QueryInterface(nsIIDRef riid, nsQIResult result);
  94     nsrefcnt AddRef();
  95     nsrefcnt Release();
  96 }
  97
  98 /* Currently we don't need a full declaration of these interfaces */
  99 typedef nsISupports nsISHistory;
 100 typedef nsISupports nsIWidget;
 101 typedef nsISupports nsIDOMAbstractView;
 102 typedef nsISupports nsIHttpHeaderVisitor;
 103 typedef nsISupports nsIDOMBarProp;
 104 typedef nsISupports nsIDOMWindowCollection;
 105 typedef nsISupports nsIPrompt;
 106 typedef nsISupports nsIAuthPrompt;
 107 typedef nsISupports nsIDOMNamedNodeMap;
 108 typedef nsISupports nsIDOMAttr;
 109 typedef nsISupports nsIDOMDocumentType;
 110 typedef nsISupports nsIDOMDOMImplementation;
 111 typedef nsISupports nsIDOMCDATASection;
 112 typedef nsISupports nsIDOMProcessingInstruction;
 113 typedef nsISupports nsIDOMEntityReference;
 114 typedef nsISupports nsIDOMHTMLFormElement;
 115 typedef nsISupports nsIDOMHTMLOptionsCollection;
 116 typedef nsISupports nsIDOMHTMLCollection;
 117 typedef nsISupports nsIWebProgressListener;
 118 typedef nsISupports nsIDOMCSSValue;
 119 typedef nsISupports nsIDOMCSSRule;
 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 nsIDOMCSSRuleList;
 128
 129 [
 130     object,
 131     uuid(8bb35ed9-e332-462d-9155-4a002ab5c958)
 132     /* FROZEN */
 133 ]
 134 interface nsIServiceManager : nsISupports
 135 {
 136     nsresult GetService(nsCIDRef aClass, nsIIDRef aIID, void **result);
 137     nsresult GetServiceByContractID(const char *aContractID, nsIIDRef aIID, void **result);
 138     nsresult IsServiceInstantiated(nsCIDRef aClass, nsIIDRef aIID, BOOL *_retval);
 139     nsresult IsServiceInstantiatedByContractID(const char *aContractID, nsIIDRef aIID, BOOL *_retval);
 140 }
 141
 142 [
 143     object,
 144     uuid(00000001-0000-0000-c000-000000000046)
 145     /* FROZEN */
 146 ]
 147 interface nsIFactory : nsISupports
 148 {
 149     nsresult CreateInstance(nsISupports *aOuter, const nsIID *iid, void **result);
 150     nsresult LockFactory(PRBool lock);
 151 }
 152
 153 [
 154     object,
 155     uuid(db242e01-e4d9-11d2-9dde-000064657374)
 156     /* FROZEN */
 157 ]
 158 interface nsIObserver : nsISupports
 159 {
 160     nsresult Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData);
 161 }
 162
 163 [
 164     object,
 165     uuid(a88e5a60-205a-4bb1-94e1-2628daf51eae)
 166     /* FROZEN */
 167 ]
 168 interface nsIComponentManager : nsISupports
 169 {
 170     nsresult GetClassObject(nsCIDRef aClass, nsIIDRef aIID, nsQIResult result);
 171     nsresult GetClassObjectByContractID(const char *aContractID, nsIIDRef aIID, nsQIResult result);
 172     nsresult CreateInstance(nsCIDRef aClass, nsISupports *aDelegate, nsIIDRef aIID,
 173             nsQIResult result);
 174     nsresult CreateInstanceByContractID(const char *aContractID, nsISupports *aDelegate,
 175             nsIIDRef aIID, nsQIResult result);
 176 }
 177
 178 [
 179     object,
 180     uuid(59e7e77a-38e4-11d4-8cf5-0060b0fc14a3)
 181     /* FROZEN */
 182 ]
 183 interface nsIMemory : nsISupports
 184 {
 185     void *Alloc(/*size_t*/ int size);
 186     void *Realloc(void *_ptr, /*size_t*/ int newSize);
 187     void Free(void *_ptr);
 188     nsresult HeapMinimize(PRBool immediate);
 189     nsresult IsLowMemory(PRBool *_retval);
 190 }
 191
 192 [
 193     object,
 194     uuid(9188bc85-f92e-11d2-81ef-0060083a0bcf)
 195     /* FROZEN */
 196 ]
 197 interface nsIWeakReference : nsISupports
 198 {
 199     nsresult QueryReferent(const nsIID *riid, void **result);
 200 }
 201
 202 [
 203     object,
 204     uuid(9188bc86-f92e-11d2-81ef-0060083a0bcf)
 205     /* FROZEN */
 206 ]
 207 interface nsISupportsWeakReference : nsISupports
 208 {
 209     nsresult GetWeakReference(nsIWeakReference **_retval);
 210 }
 211
 212 [
 213     object,
 214     uuid(033a1470-8b2a-11d3-af88-00a024ffc08c)
 215     /* FROZEN */
 216 ]
 217 interface nsIInterfaceRequestor : nsISupports
 218 {
 219     nsresult GetInterface(const nsIID *riid, void **result);
 220 }
 221
 222 [
 223     object,
 224     uuid(d1899240-f9d2-11d2-bdd6-000064657374)
 225     /* FROZEN */
 226 ]
 227 interface nsISimpleEnumerator : nsISupports
 228 {
 229     nsresult HasMoreElements(PRBool *_retval);
 230     nsresult GetNext(nsISupports **_retval);
 231 }
 232
 233 [
 234     object,
 235     uuid(114744d9-c369-456e-b55a-52fe52880d2d)
 236     /* NOT_FROZEN */
 237 ]
 238 interface nsIArray : nsISupports
 239 {
 240     nsresult GetLength(PRUint32 *aLength);
 241     nsresult QueryElementAt(PRUint32 index, const nsIID *uuid, void **result);
 242     nsresult IndexOf(PRUint32 startIndex, nsISupports *element, PRUint32 *_retval);
 243     nsresult Enumerate(nsISimpleEnumerator **_retval);
 244 }
 245
 246 [
 247     object,
 248     uuid(af059da0-c85b-40ec-af07-ae4bfdc192cc)
 249     /* NOT_FROZEN */
 250 ]
 251 interface nsIMutableArray : nsIArray
 252 {
 253     nsresult AppendElement(nsISupports *element, PRBool weak);
 254     nsresult RemoveElementAt(PRUint32 index);
 255     nsresult InsertElementAt(nsISupports *element, PRUint32 index, PRBool weak);
 256     nsresult Clear();
 257 }
 258
 259 [
 260     object,
 261     uuid(4d12e540-83d7-11d5-90ed-0010a4e73d9a)
 262     /* NOT_FROZEN */
 263 ]
 264 interface nsIVariant : nsISupports
 265 {
 266     enum nsDataType {
 267         TYPE_INT8,
 268         TYPE_INT16,
 269         TYPE_INT32,
 270         TYPE_INT64,
 271         TYPE_UINT8,
 272         TYPE_UINT16,
 273         TYPE_UINT32,
 274         TYPE_UINT64,
 275         TYPE_FLOAT,
 276         TYPE_DOUBLE,
 277         TYPE_BOOL,
 278         TYPE_CHAR,
 279         TYPE_WCHAR,
 280         TYPE_VOID,
 281         TYPE_ID,
 282         TYPE_DOMSTRING,
 283         TYPE_CHAR_STR,
 284         TYPE_WCHAR_STR,
 285         TYPE_INTERFACE,
 286         TYPE_INTERFACE_IS,
 287         TYPE_ARRAY,
 288         TYPE_STRING_SIZE_IS,
 289         TYPE_WSTRING_SIZE_IS,
 290         TYPE_UTF8STRING,
 291         TYPE_CSTRING,
 292         TYPE_ASTRING,
 293         TYPE_AMPTY_ARRAY,
 294         TYPE_EMPTY
 295     };
 296
 297     nsresult GetDataType(PRUint16 *aDataType);
 298     nsresult GetAsInt8(PRUint8 *_retval);
 299     nsresult GetAsInt16(PRInt16 *_retval);
 300     nsresult GetAsInt32(PRInt32 *_retval);
 301     nsresult GetAsInt64(PRInt64 *_retval);
 302     nsresult GetAsUint8(PRUint8 *_retval);
 303     nsresult GetAsUint16(PRUint16 *_retval);
 304     nsresult GetAsUint32(PRUint32 *_retval);
 305     nsresult GetAsUint64(PRUint64 *_retval);
 306     nsresult GetAsFloat(float *_retval);
 307     nsresult GetAsDouble(double *_retval);
 308     nsresult GetAsBool(PRBool *_retval);
 309     nsresult GetAsChar(char *_retval);
 310     nsresult GetAsWChar(PRUnichar *_retval);
 311     nsresult GetAsID(nsID *retval);
 312     nsresult GetAsAString(nsAString *_retval);
 313     nsresult GetAsDOMString(nsAString *_retval);
 314     nsresult GetAsACString(nsACString *_retval);
 315     nsresult GetAsAUTF8String(nsACString *_retval);
 316     nsresult GetAsString(char **_retval);
 317     nsresult GetAsWString(PRUnichar **_retval);
 318     nsresult GetAsISupports(nsISupports **_retval);
 319     nsresult GetAsInterface(nsIID * *iid, void **iface);
 320     nsresult GetAsArray(PRUint16 *type, nsIID *iid, PRUint32 *count, void **ptr);
 321     nsresult GetAsStringWithSize(PRUint32 *size, char **str);
 322     nsresult GetAsWStringWithSize(PRUint32 *size, PRUnichar **str);
 323 }
 324
 325 [
 326     object,
 327     uuid(5586a590-8c82-11d5-90f3-0010a4e73d9a)
 328     /* NOT_FROZEN */
 329 ]
 330 interface nsIWritableVariant : nsIVariant
 331 {
 332     nsresult GetWritable(PRBool *aWritable);
 333     nsresult SetWritable(PRBool aWritable);
 334     nsresult SetAsInt8(PRUint8 aValue);
 335     nsresult SetAsInt16(PRInt16 aValue);
 336     nsresult SetAsInt32(PRInt32 aValue);
 337     nsresult SetAsInt64(PRInt64 aValue);
 338     nsresult SetAsUint8(PRUint8 aValue);
 339     nsresult SetAsUint16(PRUint16 aValue);
 340     nsresult SetAsUint32(PRUint32 aValue);
 341     nsresult SetAsUint64(PRUint64 aValue);
 342     nsresult SetAsFloat(float aValue);
 343     nsresult SetAsDouble(double aValue);
 344     nsresult SetAsBool(PRBool aValue);
 345     nsresult SetAsChar(char aValue);
 346     nsresult SetAsWChar(PRUnichar aValue);
 347     nsresult SetAsID(const nsID *aValue);
 348     nsresult SetAsAString(const nsAString *aValue);
 349     nsresult SetAsDOMString(const nsAString *aValue);
 350     nsresult SetAsACString(const nsACString *aValue);
 351     nsresult SetAsAUTF8String(const nsACString *aValue);
 352     nsresult SetAsString(const char *aValue);
 353     nsresult SetAsWString(const PRUnichar *aValue);
 354     nsresult SetAsISupports(nsISupports *aValue);
 355     nsresult SetAsInterface(const nsIID *iid, void *iface);
 356     nsresult SetAsArray(PRUint16 type, const nsIID *iid, PRUint32 count, void *ptr);
 357     nsresult SetAsStringWithSize(PRUint32 size, const char *str);
 358     nsresult SetAsWStringWithSize(PRUint32 size, const PRUnichar *str);
 359     nsresult SetAsVoid();
 360     nsresult SetAsEmpty();
 361     nsresult SetAsEmptyArray();
 362     nsresult SetFromVariant(nsIVariant *aValue);
 363 }
 364
 365 [
 366     object,
 367     uuid(fa9c7f6c-61b3-11d4-9877-00c04fa0cf4a)
 368     /* FROZEN */
 369 ]
 370 interface nsIInputStream : nsISupports
 371 {
 372     nsresult Close();
 373     nsresult Available(PRUint32 *_retval);
 374     nsresult Read(char *aBuf, PRUint32 aCount, PRUint32 *_retval);
 375     nsresult ReadSegments(nsresult (*aWriter)(nsIInputStream *aInStream,
 376             void *aClosure, const char *aFromSegment, PRUint32 aToOffset,
 377             PRUint32 aCount, PRUint32 *aWriteCount),
 378             void *aClosure, PRUint32 aCount, PRUint32 *_retval);
 379     nsresult IsNonBlocking(PRBool *_retval);
 380 }
 381
 382 [
 383     object,
 384     uuid(450cd2d4-f0fd-424d-b365-b1251f80fd53)
 385     /* NOT_FROZEN */
 386 ]
 387 interface nsIStringInputStream : nsIInputStream
 388 {
 389     nsresult SetData(const char *data, PRInt32 dataLen);
 390     nsresult AdoptData(char *data, PRInt32 dataLen);
 391     nsresult ShareData(const char *data, PRInt32 dataLen);
 392 }
 393
 394 [
 395     object,
 396     uuid(07a22cc0-0ce5-11d3-9331-00104ba0fd40)
 397     /* FROZEN */
 398 ]
 399 interface nsIURI : nsISupports
 400 {
 401     nsresult GetSpec(nsACString *aSpec);
 402     nsresult SetSpec(const nsACString *aSpec);
 403     nsresult GetPrePath(nsACString *aPrePath);
 404     nsresult GetScheme(nsACString *aScheme);
 405     nsresult SetScheme(const nsACString *aScheme);
 406     nsresult GetUserPass(nsACString *aUserPass);
 407     nsresult SetUserPass(const nsACString *aUserPass);
 408     nsresult GetUsername(nsACString *aUsername);
 409     nsresult SetUsername(const nsACString *aUsername);
 410     nsresult GetPassword(nsACString *aPassword);
 411     nsresult SetPassword(const nsACString *aPassword);
 412     nsresult GetHostPort(nsACString *aHostPort);
 413     nsresult SetHostPort(const nsACString *aHostPort);
 414     nsresult GetHost(nsACString *aHost);
 415     nsresult SetHost(const nsACString *aHost);
 416     nsresult GetPort(PRInt32 *aPort);
 417     nsresult SetPort(PRInt32 aPort);
 418     nsresult GetPath(nsACString *aPath);
 419     nsresult SetPath(const nsACString *aPath);
 420     nsresult Equals(nsIURI *other, PRBool *_retval);
 421     nsresult SchemeIs(const char *scheme, PRBool *_retval);
 422     nsresult Clone(nsIURI **_retval);
 423     nsresult Resolve(const nsACString *relativePath, nsACString *_retval);
 424     nsresult GetAsciiSpec(nsACString *aAsciiSpec);
 425     nsresult GetAsciiHost(nsACString *aAsciiHost);
 426     nsresult GetOriginCharset(nsACString *aOriginCharset);
 427 }
 428
 429 [
 430     object,
 431     uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe)
 432     /* FROZEN */
 433 ]
 434 interface nsIRequest : nsISupports
 435 {
 436     nsresult GetName(nsACString *aName);
 437     nsresult IsPending(PRBool *_retval);
 438     nsresult GetStatus(nsresult *aStatus);
 439     nsresult Cancel(nsresult aStatus);
 440     nsresult Suspend();
 441     nsresult Resume();
 442     nsresult GetLoadGroup(nsILoadGroup **aLoadGroup);
 443     nsresult SetLoadGroup(nsILoadGroup *aLoadGroup);
 444     nsresult GetLoadFlags(nsLoadFlags *aLoadFlags);
 445     nsresult SetLoadFlags(nsLoadFlags aLoadFlags);
 446 }
 447
 448 [
 449     object,
 450     uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40)
 451     /* FROZEN */
 452 ]
 453 interface nsIRequestObserver : nsISupports
 454 {
 455     nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext);
 456     nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode);
 457 }
 458
 459 [
 460     object,
 461     uuid(1a637020-1482-11d3-9333-00104ba0fd40)
 462     /* FROZEN */
 463 ]
 464 interface nsIStreamListener : nsIRequestObserver
 465 {
 466     nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
 467                              nsIInputStream *aInputStream, PRUint32 aOffset, PRUint32 aCount);
 468 }
 469
 470 [
 471     object,
 472     uuid(3de0a31c-feaf-400f-9f1e-4ef71f8b20cc)
 473     /* FROZEN */
 474 ]
 475 interface nsILoadGroup : nsIRequest
 476 {
 477     nsresult GetGroupObserver(nsIRequestObserver **aGroupObserver);
 478     nsresult SetGroupObserver(nsIRequestObserver *aGroupObserver);
 479     nsresult GetDefaultLoadRequest(nsIRequest **aDefaultLoadRequest);
 480     nsresult SetDefaultLoadRequest(nsIRequest *aDefaultLoadRequest);
 481     nsresult AddRequest(nsIRequest *aRequest, nsISupports *aContext);
 482     nsresult RemoveRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatus);
 483     nsresult GetRequests(nsISimpleEnumerator **aRequests);
 484     nsresult GetActiveCount(PRUint32 *aActiveCount);
 485     nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
 486     nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
 487 }
 488
 489 [
 490     object,
 491     uuid(c63a055a-a676-4e71-bf3c-6cfa11082018)
 492     /* FROZEN */
 493 ]
 494 interface nsIChannel : nsIRequest
 495 {
 496     nsresult GetOriginalURI(nsIURI **aOriginalURI);
 497     nsresult SetOriginalURI(nsIURI *aOriginalURI);
 498     nsresult GetURI(nsIURI **aURI);
 499     nsresult GetOwner(nsISupports **aOwner);
 500     nsresult SetOwner(nsISupports *aOwner);
 501     nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
 502     nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
 503     nsresult GetSecurityInfo(nsISupports **aSecurityInfo);
 504     nsresult GetContentType(nsACString *aContentType);
 505     nsresult SetContentType(const nsACString *aContentType);
 506     nsresult GetContentCharset(nsACString *aContentCharset);
 507     nsresult SetContentCharset(const nsACString *aContentCharset);
 508     nsresult GetContentLength(PRInt32 *aContentLength);
 509     nsresult SetContentLength(PRInt32 aContentLength);
 510     nsresult Open(nsIInputStream **_retval);
 511     nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext);
 512 }
 513
 514 [
 515     object,
 516     uuid(9277fe09-f0cc-4cd9-bbce-581dd94b0260)
 517     /* FROZEN */
 518 ]
 519 interface nsIHttpChannel : nsIChannel
 520 {
 521     nsresult GetRequestMethod(nsACString *aRequestMethod);
 522     nsresult SetRequestMethod(const nsACString *aRequestMethod);
 523     nsresult GetReferrer(nsIURI **aReferrer);
 524     nsresult SetReferrer(nsIURI *aReferrer);
 525     nsresult GetRequestHeader(const nsACString *aHeader, nsACString *_retval);
 526     nsresult SetRequestHeader(const nsACString *aHeader, const nsACString *aValue, PRBool aMerge);
 527     nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
 528     nsresult GetAllowPipelining(PRBool *aAllowPipelining);
 529     nsresult SetAllowPipelining(PRBool aAllowPipelining);
 530     nsresult GetRedirectionLimit(PRUint32 *aRedirectionLimit);
 531     nsresult SetRedirectionLimit(PRUint32 aRedirectionLimit);
 532     nsresult GetResponseStatus(PRUint32 *aResponseStatus);
 533     nsresult GetResponseStatusText(nsACString *aResponseStatusText);
 534     nsresult GetRequestSucceeded(PRBool *aRequestSucceeded);
 535     nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
 536     nsresult SetResponseHeader(const nsACString *header, const nsACString *value, PRBool merge);
 537     nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor);
 538     nsresult IsNoStoreResponse(PRBool *_retval);
 539     nsresult IsNoCacheResponse(PRBool *_retval);
 540 }
 541
 542 [
 543     object,
 544     uuid(ddf633d8-e9a4-439d-ad88-de636fd9bb75)
 545     /* FROZEN */
 546 ]
 547 interface nsIUploadChannel : nsISupports
 548 {
 549     nsresult SetUploadStream(nsIInputStream *aStream, const nsACString *aContentType,
 550                              PRInt32 aContentLength);
 551     nsresult GetUploadStream(nsIInputStream **aUploadStream);
 552 }
 553
 554 [
 555     object,
 556     uuid(a6cf90be-15b3-11d2-932e-00805f8add32)
 557     /* FROZEN */
 558 ]
 559 interface nsIDOMCSSStyleDeclaration : nsISupports
 560 {
 561     nsresult GetCssText(nsAString *aCssText);
 562     nsresult SetCssText(const nsAString *aCssText);
 563     nsresult GetPropertyValue(const nsAString *propertyName, nsAString *_retval);
 564     nsresult GetPropertyCSSValue(const nsAString *propertyName, nsIDOMCSSValue **_retval);
 565     nsresult RemoveProperty(const nsAString *propertyName, nsAString *_retval);
 566     nsresult GetPropertyPriority(const nsAString *propertyName, nsAString *_retval);
 567     nsresult SetProperty(const nsAString *propertyName, const nsAString *value,
 568                          const nsAString *priority);
 569     nsresult GetLength(PRUint32 *aLength);
 570     nsresult Item(PRUint32 index, nsAString *_retval);
 571     nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
 572 }
 573
 574 [
 575     object,
 576     uuid(a6cf9080-15b3-11d2-932e-00805f8add32)
 577     /* FROZEN */
 578 ]
 579 interface nsIDOMStyleSheet : nsISupports
 580 {
 581     nsresult GetType(nsAString *aType);
 582     nsresult GetDisabled(PRBool *aDisabled);
 583     nsresult SetDisabled(PRBool aDisabled);
 584     nsresult GetOwnerNode(nsIDOMNode **aOwnerNode);
 585     nsresult GetParentStyleSheet(nsIDOMStyleSheet **aParentStyleSheet);
 586     nsresult GetHref(nsAString *aHref);
 587     nsresult GetTitle(nsAString *aTitle);
 588     nsresult GetMedia(nsIDOMMediaList **aMedia);
 589 }
 590
 591 [
 592     object,
 593     uuid(a6cf90c2-15b3-11d2-932e-00805f8add32)
 594     /* FROZEN */
 595 ]
 596 interface nsIDOMCSSStyleSheet : nsIDOMStyleSheet
 597 {
 598     nsresult GetOwnerRule(nsIDOMCSSRule **aOwnerRule);
 599     nsresult GetCssRules(nsIDOMCSSRuleList **aCssRules);
 600     nsresult InsertRule(const nsAString *rule, PRUint32 index, PRUint32 *_retval);
 601     nsresult DeleteRule(PRUint32 index);
 602 }
 603
 604 [
 605     object,
 606     uuid(a6cf9081-15b3-11d2-932e-00805f8add32)
 607     /* FROZEN */
 608 ]
 609 interface nsIDOMStyleSheetList : nsISupports
 610 {
 611     nsresult GetLength(PRUint32 *aLength);
 612     nsresult Item(PRUint32 index, nsIDOMStyleSheet **_retval);
 613 }
 614
 615 [
 616     object,
 617     uuid(a6cf907d-15b3-11d2-932e-00805f8add32)
 618     /* FROZEN */
 619 ]
 620 interface nsIDOMNodeList : nsISupports
 621 {
 622     nsresult Item(PRUint32 index, nsIDOMNode **_retval);
 623     nsresult GetLength(PRUint32 *aLength);
 624 }
 625
 626 [
 627     object,
 628     uuid(a6cf907c-15b3-11d2-932e-00805f8add32)
 629     /* FROZEN */
 630 ]
 631 interface nsIDOMNode : nsISupports
 632 {
 633     enum NSNODETYPE {
 634         ELEMENT_NODE = 1,
 635         ATTRIBUTE_NODE = 2,
 636         TEXT_NODE = 3,
 637         CDATA_SELECTION_NODE = 4,
 638         ENTITY_REFERENCE_NODE = 5,
 639         ENTITY_NODE = 6,
 640         PROCESSING_INSTRUCTION_NODE = 7,
 641         COMMENT_NODE = 8,
 642         DOCUMENT_NODE = 9,
 643         DOCUMENT_TYPE_NODE = 10,
 644         DOCUMENT_FRAGMENT_NODE = 11,
 645         NOTATION_NODE = 12
 646     };
 647
 648     nsresult GetNodeName(nsAString *aNodeName);
 649     nsresult GetNodeValue(nsAString *aNodeValue);
 650     nsresult SetNodeValue(const nsAString *aNodeValue);
 651     nsresult GetNodeType(PRUint16 *aNodeType);
 652     nsresult GetParentNode(nsIDOMNode **aParentNode);
 653     nsresult GetChildNodes(nsIDOMNodeList **aChildNodes);
 654     nsresult GetFirstChild(nsIDOMNode **aFirstChild);
 655     nsresult GetLastChild(nsIDOMNode **aLastChild);
 656     nsresult GetPreviousSibling(nsIDOMNode **aPreviousSibling);
 657     nsresult GetNextSibling(nsIDOMNode **aNextSibling);
 658     nsresult GetAttributes(nsIDOMNamedNodeMap **aAttributes);
 659     nsresult GetOwnerDocument(nsIDOMDocument **aOwnerDocument);
 660     nsresult InsertBefore(nsIDOMNode *newChild, nsIDOMNode *refChild, nsIDOMNode **_retval);
 661     nsresult ReplaceChild(nsIDOMNode *newChild, nsIDOMNode *oldChild, nsIDOMNode **_retval);
 662     nsresult RemoveChild(nsIDOMNode *oldChild, nsIDOMNode **_retval);
 663     nsresult AppendChild(nsIDOMNode *newChild, nsIDOMNode **_retval);
 664     nsresult HasChildNodes(PRBool *_retval);
 665     nsresult CloneNode(PRBool deep, nsIDOMNode **_retval);
 666     nsresult Normalize();
 667     nsresult IsSupported(const nsAString *feature, const nsAString *version, PRBool *_retval);
 668     nsresult GetNamespaceURI(nsAString *aNamespaceURI);
 669     nsresult GetPrefix(nsAString *aPrefix);
 670     nsresult SetPrefix(const nsAString *aPrefix);
 671     nsresult GetLocalName(nsAString *aLocalName);
 672     nsresult HasAttributes(PRBool *_retval);
 673 }
 674
 675 [
 676     object,
 677     uuid(a6cf9078-15b3-11d2-932e-00805f8add32)
 678     /* FROZEN */
 679 ]
 680 interface nsIDOMElement : nsIDOMNode
 681 {
 682     nsresult GetTagName(nsAString *aTagName);
 683     nsresult GetAttribute(const nsAString *name, nsAString *_retval);
 684     nsresult SetAttribute(const nsAString *name, const nsAString *value);
 685     nsresult RemoveAttribute(const nsAString *name);
 686     nsresult GetAttributeNode(const nsAString *name, nsIDOMAttr **_retval);
 687     nsresult SetAttributeNode(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
 688     nsresult RemoveAttributeNode(nsIDOMAttr *oldAttr, nsIDOMAttr **_retval);
 689     nsresult GetElementsByTagName(const nsAString *name, nsIDOMNodeList **_retval);
 690     nsresult GetAttributeNS(const nsAString *namespaceURI, const nsAString *localName,
 691                             nsAString *_retval);
 692     nsresult SetAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 693                             const nsAString *value);
 694     nsresult RemoveAttributeNS(const nsAString *namespaceURI, const nsAString *localName);
 695     nsresult GetAttributeNodeNS(const nsAString *namespaceURI, const nsAString *localName,
 696                                 nsIDOMAttr **_retval);
 697     nsresult SetAttributeNodeNS(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
 698     nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName,
 699                                     nsIDOMNodeList **_retval);
 700     nsresult HasAttribute(const nsAString *name, PRBool *_retval);
 701     nsresult HasAttributeNS(const nsAString *namespaceURI, const nsAString *localName,
 702                             PRBool *_retval);
 703 }
 704
 705 [
 706     object,
 707     uuid(99715845-95fc-4a56-aa53-214b65c26e22)
 708     /* FROZEN */
 709 ]
 710 interface nsIDOMElementCSSInlineStyle : nsISupports
 711 {
 712     nsresult GetStyle(nsIDOMCSSStyleDeclaration **aStyle);
 713 }
 714
 715 cpp_quote("#undef GetClassName");
 716
 717 [
 718     object,
 719     uuid(a6cf9085-15b3-11d2-932e-00805f8add32)
 720     /* FROZEN */
 721 ]
 722 interface nsIDOMHTMLElement : nsIDOMElement
 723 {
 724     nsresult GetId(nsAString *aId);
 725     nsresult SetId(const nsAString *aId);
 726     nsresult GetTitle(nsAString *aTitle);
 727     nsresult SetTitle(const nsAString *aTitle);
 728     nsresult GetLang(nsAString *aLang);
 729     nsresult SetLang(const nsAString *aLang);
 730     nsresult GetDir(nsAString *aDir);
 731     nsresult SetDir(const nsAString *aDir);
 732     nsresult GetClassName(nsAString *aClassName);
 733     nsresult SetClassName(const nsAString *aClassName);
 734 }
 735
 736 [
 737     object,
 738     uuid(da83b2ec-8264-4410-8496-ada3acd2ae42)
 739     /* NOT_FROZEN */
 740 ]
 741 interface nsIDOMNSHTMLElement : nsISupports
 742 {
 743     nsresult GetOffsetTop(PRInt32 *aOffsetTop);
 744     nsresult GetOffsetLeft(PRInt32 *aOffsetLeft);
 745     nsresult GetOffsetWidth(PRInt32 *aOffsetWidth);
 746     nsresult GetOffsetHeight(PRInt32 *aOffsetHeight);
 747     nsresult GetOffsetParent(nsIDOMElement **aOffsetParent);
 748     nsresult GetInnerHTML(nsAString *aInnerHTML);
 749     nsresult SetInnerHTML(const nsAString *aInnerHTML);
 750     nsresult GetScrollTop(PRInt32 *aScrollTop);
 751     nsresult SetScrollTop(PRInt32 aScrollTop);
 752     nsresult GetScrollLeft(PRInt32 *aScrollLeft);
 753     nsresult SetScrollLeft(PRInt32 aScrollLeft);
 754     nsresult GetScrollHeight(PRInt32 *aScrollHeight);
 755     nsresult GetScrollWidth(PRInt32 *aScrollWidth);
 756     nsresult GetClientHeight(PRInt32 *aClientHeight);
 757     nsresult GetClientWidth(PRInt32 *aClientWidth);
 758     nsresult GetTabIndex(PRInt32 *aTabIndex);
 759     nsresult SetTabIndex(PRInt32 aTabIndex);
 760     nsresult blur();
 761     nsresult focus();
 762     nsresult ScrollIntoView(PRBool top);
 763 }
 764
 765 [
 766     object,
 767     uuid(a6cf9072-15b3-11d2-932e-00805f8add32)
 768     /* FROZEN */
 769 ]
 770 interface nsIDOMCharacterData : nsIDOMNode
 771 {
 772     nsresult GetData(nsAString *aData);
 773     nsresult SetData(const nsAString *aData);
 774     nsresult GetLength(PRUint32 *aLength);
 775     nsresult SubstringData(PRUint32 offset, PRUint32 count, nsAString *_retval);
 776     nsresult AppendData(const nsAString *arg);
 777     nsresult InsertData(PRUint32 offset, const nsAString *arg);
 778     nsresult DeleteData(PRUint32 offset, PRUint32 count);
 779     nsresult ReplaceData(PRUint32 offset, PRUint32 count, const nsAString *arg);
 780 }
 781
 782 [
 783     object,
 784     uuid(a6cf9082-15b3-11d2-932e-00805f8add32)
 785     /* FROZEN */
 786 ]
 787 interface nsIDOMText : nsIDOMCharacterData
 788 {
 789     nsresult SplitText(PRUint32 offset, nsIDOMText **_retval);
 790 }
 791
 792 [
 793     object,
 794     uuid(a6cf9073-15b3-11d2-932e-00805f8add32)
 795     /* FROZEN */
 796 ]
 797 interface nsIDOMComment : nsIDOMCharacterData
 798 {
 799 }
 800
 801 [
 802     object,
 803     uuid(a6cf9076-15b3-11d2-932e-00805f8add32)
 804     /* FROZEN */
 805 ]
 806 interface nsIDOMDocumentFragment : nsIDOMNode
 807 {
 808 }
 809
 810 [
 811     object,
 812     uuid(a6cf9075-15b3-11d2-932e-00805f8add32)
 813     /* FROZEN */
 814 ]
 815 interface nsIDOMDocument : nsIDOMNode
 816 {
 817     nsresult GetDoctype(nsIDOMDocumentType **aDoctype);
 818     nsresult GetImplementation(nsIDOMDOMImplementation **aImplementation);
 819     nsresult GetDocumentElement(nsIDOMElement **aDocumentElement);
 820     nsresult CreateElement(const nsAString *tagName, nsIDOMElement **_retval);
 821     nsresult CreateDocumentFragment(nsIDOMDocumentFragment **_retval);
 822     nsresult CreateTextNode(const nsAString *data, nsIDOMText **_retval);
 823     nsresult CreateComment(const nsAString *data, nsIDOMComment **_retval);
 824     nsresult CreateCDATASection(const nsAString *data, nsIDOMCDATASection **_retval);
 825     nsresult CreateProcessingInstruction(const nsAString *target, const nsAString *data,
 826                                          nsIDOMProcessingInstruction **_retval);
 827     nsresult CreateAttribute(const nsAString *name, nsIDOMAttr **_retval);
 828     nsresult CreateEntityReference(const nsAString *name, nsIDOMEntityReference **_retval);
 829     nsresult GetElementsByTagName(const nsAString *tagname, nsIDOMNodeList **_retval);
 830     nsresult ImportNode(nsIDOMNode *importedNode, PRBool deep, nsIDOMNode **_retval);
 831     nsresult CreateElementNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 832                              nsIDOMElement **_retval);
 833     nsresult CreateAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 834                                nsIDOMAttr **_retval);
 835     nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName,
 836                                     nsIDOMNodeList **_retval);
 837     nsresult GetElementById(const nsAString *elementId, nsIDOMElement **_retval);
 838 }
 839
 840 [
 841     object,
 842     uuid(a6cf9084-15b3-11d2-932e-00805f8add32)
 843     /* FROZEN */
 844 ]
 845 interface nsIDOMHTMLDocument : nsIDOMDocument
 846 {
 847     nsresult GetTitle(nsAString *aTitle);
 848     nsresult SetTitle(const nsAString *aTitle);
 849     nsresult GetReferrer(nsAString *aReferrer);
 850     nsresult GetDomain(nsAString *aDomain);
 851     nsresult GetURL(nsAString *aURL);
 852     nsresult GetBody(nsIDOMHTMLElement **aBody);
 853     nsresult SetBody(nsIDOMHTMLElement *aBody);
 854     nsresult GetImages(nsIDOMHTMLCollection **aImages);
 855     nsresult GetApplets(nsIDOMHTMLCollection **aApplets);
 856     nsresult GetLinks(nsIDOMHTMLCollection **aLinks);
 857     nsresult GetForms(nsIDOMHTMLCollection **aForms);
 858     nsresult GetAnchors(nsIDOMHTMLCollection **aAnchors);
 859     nsresult GetCookie(nsAString *aCookie);
 860     nsresult SetCookie(const nsAString *aCookie);
 861     nsresult Open();
 862     nsresult Close();
 863     nsresult Write(const nsAString *text);
 864     nsresult Writeln(const nsAString *text);
 865     nsresult GetElementsByName(const nsAString *elementName, nsIDOMNodeList **_retval);
 866 }
 867
 868 [
 869     object,
 870     uuid(79beb289-3644-4b54-9432-9fb993945629)
 871     /* NOT_FROZEN */
 872 ]
 873 interface nsIDOMNSHTMLDocument : nsISupports
 874 {
 875     nsresult GetWidth(PRInt32 *aWidth);
 876     nsresult GetHeight(PRInt32 *aHeight);
 877     nsresult GetAlinkColor(nsAString *aAlinkColor);
 878     nsresult SetAlinkColor(const nsAString *aAlinkColor);
 879     nsresult GetLinkColor(nsAString *aLinkColor);
 880     nsresult SetLinkColor(const nsAString *aLinkColor);
 881     nsresult GetVlinkColor(nsAString *aVlinkColor);
 882     nsresult SetVlinkColor(const nsAString *aVlinkColor);
 883     nsresult GetBgColor(nsAString *aBgColor);
 884     nsresult SetBgColor(const nsAString *aBgColor);
 885     nsresult GetFgColor(nsAString *aFgColor);
 886     nsresult SetFgColor(const nsAString *aFgColor);
 887     nsresult GetDomain(nsAString *aDomain);
 888     nsresult SetDomain(const nsAString *aDomain);
 889     nsresult GetEmbeds(nsIDOMHTMLCollection **aEmbeds);
 890     nsresult GetSelection(nsAString *_retval);
 891     nsresult Open(nsIDOMDocument **_retval);
 892     nsresult Write();
 893     nsresult Writeln();
 894     nsresult Clear();
 895     nsresult CaptureEvents(PRInt32 eventFlags);
 896     nsresult ReleaseEvents(PRInt32 eventFlags);
 897     nsresult RouteEvent(nsIDOMEvent *evt);
 898     nsresult GetCompatMode(nsAString *aCompatMode);
 899     nsresult GetPlugins(nsIDOMHTMLCollection **aPlugins);
 900     nsresult GetDesignMode(nsAString *aDesignMode);
 901     nsresult SetDesignMode(const nsAString *aDesignMode);
 902     nsresult ExecCommand(const nsAString *commandID, PRBool doShowUI, const nsAString *value, PRBool *_retval);
 903     nsresult ExecCommandShowHelp(const nsAString *commandID, PRBool *_retval);
 904     nsresult QueryCommandEnabled(const nsAString *commandID, PRBool *_retval);
 905     nsresult QueryCommandIndeterm(const nsAString *commandID, PRBool *_retval);
 906     nsresult QueryCommandState(const nsAString *commandID, PRBool *_retval);
 907     nsresult QueryCommandSupported(const nsAString *commandID, PRBool *_retval);
 908     nsresult QueryCommandText(const nsAString *commandID, nsAString *_retval);
 909     nsresult QueryCommandValue(const nsAString *commandID, nsAString *_retval);
 910 }
 911
 912 [
 913     object,
 914     uuid(3d9f4973-dd2e-48f5-b5f7-2634e09eadd9)
 915     /* FROZEN */
 916 ]
 917 interface nsIDOMDocumentStyle : nsISupports
 918 {
 919     nsresult GetStyleSheets(nsIDOMStyleSheetList **aStyleSheets);
 920 }
 921
 922 [
 923     object,
 924     uuid(a6cf90ce-15b3-11d2-932e-00805f8add32)
 925     /* FROZEN */
 926 ]
 927 interface nsIDOMRange : nsISupports
 928 {
 929     enum {
 930         NS_START_TO_START,
 931         NS_START_TO_END,
 932         NS_END_TO_END,
 933         NS_END_TO_START
 934     };
 935
 936     nsresult GetStartContainer(nsIDOMNode **aStartContainer);
 937     nsresult GetStartOffset(PRInt32 *aStartOffset);
 938     nsresult GetEndContainer(nsIDOMNode **aEndContainer);
 939     nsresult GetEndOffset(PRInt32 *aEndOffset);
 940     nsresult GetCollapsed(PRBool *aCollapsed);
 941     nsresult GetCommonAncestorContainer(nsIDOMNode **aCommonAncestorContainer);
 942     nsresult SetStart(nsIDOMNode *refNode, PRInt32 offset);
 943     nsresult SetEnd(nsIDOMNode *refNode, PRInt32 offset);
 944     nsresult SetStartBefore(nsIDOMNode *refNode);
 945     nsresult SetStartAfter(nsIDOMNode *refNode);
 946     nsresult SetEndBefore(nsIDOMNode *refNode);
 947     nsresult SetEndAfter(nsIDOMNode *refNode);
 948     nsresult Collapse(PRBool toStart);
 949     nsresult SelectNode(nsIDOMNode *refNode);
 950     nsresult SelectNodeContents(nsIDOMNode *refNode);
 951     nsresult CompareBoundaryPoints(PRUint16 how, nsIDOMRange *sourceRange, PRInt16 *_retval);
 952     nsresult DeleteContents();
 953     nsresult ExtractContents(nsIDOMDocumentFragment **_retval);
 954     nsresult CloneContents(nsIDOMDocumentFragment **_retval);
 955     nsresult InsertNode(nsIDOMNode *newNode);
 956     nsresult SurroundContents(nsIDOMNode *newParent);
 957     nsresult CloneRange(nsIDOMRange **_retval);
 958     nsresult ToString(nsAString *_retval);
 959     nsresult Detach();
 960 }
 961
 962 [
 963     object,
 964     uuid(a6cf90f2-15b3-11d2-932e-00805f8add32)
 965 ]
 966 interface nsIDOMNSRange : nsISupports
 967 {
 968     nsresult CreateContextualFragment([in] const nsAString *fragment, [out] nsIDOMDocumentFragment **_retval);
 969     nsresult IsPointInRange([in] nsIDOMNode *parent, [in] PRInt32 offset, [out] PRBool *_retval);
 970     nsresult ComparePoint([in] nsIDOMNode *parent, [in] PRInt32 offset, [out] PRInt16 *_retval);
 971     nsresult IntersectsNode([in] nsIDOMNode *n, [out] PRBool *_retval);
 972     nsresult CompareNode([in] nsIDOMNode *n, [out] PRUint16 *_retval);
 973     nsresult nSDetach();
 974 }
 975
 976
 977 [
 978     object,
 979     uuid(7b9badc6-c9bc-447a-8670-dbd195aed24b)
 980     /* FROZEN */
 981 ]
 982 interface nsIDOMDocumentRange : nsISupports
 983 {
 984     nsresult CreateRange(nsIDOMRange **_retval);
 985 }
 986
 987 [
 988     object,
 989     uuid(b2c7ed59-8634-4352-9e37-5484c8b6e4e1)
 990     /* FROZEN */
 991 ]
 992 interface nsISelection : nsISupports
 993 {
 994     nsresult GetAnchorNode(nsIDOMNode **aAnchorNode);
 995     nsresult GetAnchorOffset(PRInt32 *aAnchorOffset);
 996     nsresult GetFocusNode(nsIDOMNode **aFocusNode);
 997     nsresult GetFocusOffset(PRInt32 *aFocusOffset);
 998     nsresult GetIsCollapsed(PRBool *aIsCollapsed);
 999     nsresult GetRangeCount(PRInt32 *aRangeCount);
1000     nsresult GetRangeAt(PRInt32 index, nsIDOMRange **_retval);
1001     nsresult Collapse(nsIDOMNode *parentNode, PRInt32 offset);
1002     nsresult Extend(nsIDOMNode *parentNode, PRInt32 offset);
1003     nsresult CollapseToStart();
1004     nsresult CollapseToEnd();
1005     nsresult ContainsNode(nsIDOMNode *node, PRBool entirelyContained, PRBool *_retval);
1006     nsresult SelectAllChildren(nsIDOMNode *parentNode);
1007     nsresult AddRange(nsIDOMRange *range);
1008     nsresult RemoveRange(nsIDOMRange *range);
1009     nsresult RemoveAllRanges();
1010     nsresult DeleteFromDocument();
1011     nsresult SelectionLanguageChange(PRBool langRTL);
1012     nsresult ToString(PRUnichar **_retval);
1013 }
1014
1015 [
1016     object,
1017     uuid(a6cf906b-15b3-11d2-932e-00805f8add32)
1018     /* FROZEN */
1019 ]
1020 interface nsIDOMWindow : nsISupports
1021 {
1022     nsresult GetDocument(nsIDOMDocument **aDocument);
1023     nsresult GetParent(nsIDOMWindow **aParent);
1024     nsresult GetTop(nsIDOMWindow **aTop);
1025     nsresult GetScrollbars(nsIDOMBarProp **aScrollbars);
1026     nsresult GetFrames(nsIDOMWindowCollection **aFrames);
1027     nsresult GetName(nsAString *aName);
1028     nsresult SetName(const nsAString *aName);
1029     nsresult GetTextZoom(float *aTextZoom);
1030     nsresult SetTextZoom(float aTextZoom);
1031     nsresult GetScrollX(PRInt32 *aScrollX);
1032     nsresult GetScrollY(PRInt32 *aScrollY);
1033     nsresult ScrollTo(PRInt32 xScroll, PRInt32 yScroll);
1034     nsresult ScrollBy(PRInt32 xScrollDif, PRInt32 yScrollDif);
1035     nsresult GetSelection(nsISelection **_retval);
1036     nsresult ScrollByLines(PRInt32 numLines);
1037     nsresult ScrollByPages(PRInt32 numPages);
1038     nsresult SizeToContent();
1039 }
1040
1041 [
1042     object,
1043     uuid(a6cf908e-15b3-11d2-932e-00805f8add32)
1044     /* FROZEN */
1045 ]
1046 interface nsIDOMHTMLBodyElement : nsIDOMHTMLElement
1047 {
1048     nsresult GetALink(nsAString *aALink);
1049     nsresult SetALink(const nsAString *aALink);
1050     nsresult GetBackground(nsAString *aBackground);
1051     nsresult SetBackground(const nsAString *aBackground);
1052     nsresult GetBgColor(nsAString *aBgColor);
1053     nsresult SetBgColor(const nsAString *aBgColor);
1054     nsresult GetLink(nsAString *aLink);
1055     nsresult SetLink(const nsAString *aLink);
1056     nsresult GetText(nsAString *aText);
1057     nsresult SetText(const nsAString *aText);
1058     nsresult GetVLink(nsAString *aVLink);
1059     nsresult SetVLink(const nsAString *aVLink);
1060 }
1061
1062 [
1063     object,
1064     uuid(a6cf9093-15b3-11d2-932e-00805f8add32)
1065     /* FROZEN */
1066 ]
1067 interface nsIDOMHTMLInputElement : nsIDOMHTMLElement
1068 {
1069     nsresult GetDefaultValue(nsAString *aDefaultValue);
1070     nsresult SetDefaultValue(const nsAString *aDefaultValue);
1071     nsresult GetDefaultChecked(PRBool *aDefaultChecked);
1072     nsresult SetDefaultChecked(PRBool aDefaultChecked);
1073     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1074     nsresult GetAccept(nsAString *aAccept);
1075     nsresult SetAccept(const nsAString *aAccept);
1076     nsresult GetAccessKey(nsAString *aAccessKey);
1077     nsresult SetAccessKey(const nsAString *aAccessKey);
1078     nsresult GetAlign(nsAString *aAlign);
1079     nsresult SetAlign(const nsAString *aAlign);
1080     nsresult GetAlt(nsAString *aAlt);
1081     nsresult SetAlt(const nsAString *aAlt);
1082     nsresult GetChecked(PRBool *aChecked);
1083     nsresult SetChecked(PRBool aChecked);
1084     nsresult GetDisabled(PRBool *aDisabled);
1085     nsresult SetDisabled(PRBool aDisabled);
1086     nsresult GetMaxLength(PRInt32 *aMaxLength);
1087     nsresult SetMaxLength(PRInt32 aMaxLength);
1088     nsresult GetName(nsAString *aName);
1089     nsresult SetName(const nsAString *aName);
1090     nsresult GetReadOnly(PRBool *aReadOnly);
1091     nsresult SetReadOnly(PRBool aReadOnly);
1092     nsresult GetSize(PRUint32 *aSize);
1093     nsresult SetSize(PRUint32 aSize);
1094     nsresult GetSrc(nsAString *aSrc);
1095     nsresult SetSrc(const nsAString *aSrc);
1096     nsresult GetTabIndex(PRInt32 *aTabIndex);
1097     nsresult SetTabIndex(PRInt32 aTabIndex);
1098     nsresult GetType(nsAString *aType);
1099     nsresult SetType(const nsAString *aType);
1100     nsresult GetUseMap(nsAString *aUseMap);
1101     nsresult SetUseMap(const nsAString *aUseMap);
1102     nsresult GetValue(nsAString *aValue);
1103     nsresult SetValue(const nsAString *aValue);
1104     nsresult Blur();
1105     nsresult Focus();
1106     nsresult Select();
1107     nsresult Click();
1108 }
1109
1110 [
1111     object,
1112     uuid(a6cf9092-15b3-11d2-932e-00805f8add32)
1113     /* FROZEN */
1114 ]
1115 interface nsIDOMHTMLOptionElement : nsIDOMHTMLElement
1116 {
1117     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1118     nsresult GetDefaultSelected(PRBool *aDefaultSelected);
1119     nsresult SetDefaultSelected(PRBool aDefaultSelected);
1120     nsresult GetText(nsAString *aText);
1121     nsresult GetIndex(PRInt32 *aIndex);
1122     nsresult GetDisabled(PRBool *aDisabled);
1123     nsresult SetDisabled(PRBool aDisabled);
1124     nsresult GetLabel(nsAString *aLabel);
1125     nsresult SetLabel(const nsAString *aLabel);
1126     nsresult GetSelected(PRBool *aSelected);
1127     nsresult SetSelected(PRBool aSelected);
1128     nsresult GetValue(nsAString *aValue);
1129     nsresult SetValue(const nsAString *aValue);
1130 }
1131
1132 [
1133     object,
1134     uuid(a6cf9090-15b3-11d2-932e-00805f8add32)
1135     /* FROZEN */
1136 ]
1137 interface nsIDOMHTMLSelectElement : nsIDOMHTMLElement
1138 {
1139     nsresult GetType(nsAString *aType);
1140     nsresult GetSelectedIndex(PRInt32 *aSelectedIndex);
1141     nsresult SetSelectedIndex(PRInt32 aSelectedIndex);
1142     nsresult GetValue(nsAString *aValue);
1143     nsresult SetValue(const nsAString *aValue);
1144     nsresult GetLength(PRUint32 *aLength);
1145     nsresult SetLength(PRUint32 aLength);
1146     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1147     nsresult GetOptions(nsIDOMHTMLOptionsCollection **aOptions);
1148     nsresult GetDisabled(PRBool *aDisabled);
1149     nsresult SetDisabled(PRBool aDisabled);
1150     nsresult GetMultiple(PRBool *aMultiple);
1151     nsresult SetMultiple(PRBool aMultiple);
1152     nsresult GetName(nsAString *aName);
1153     nsresult SetName(const nsAString *aName);
1154     nsresult GetSize(PRInt32 *aSize);
1155     nsresult SetSize(PRInt32 aSize);
1156     nsresult GetTabIndex(PRInt32 *aTabIndex);
1157     nsresult SetTabIndex(PRInt32 aTabIndex);
1158     nsresult Add(nsIDOMHTMLElement *element, nsIDOMHTMLElement *before);
1159     nsresult Remove(PRInt32 index);
1160     nsresult Blur();
1161     nsresult Focus();
1162 }
1163
1164 [
1165     object,
1166     uuid(a6cf9094-15b3-11d2-932e-00805f8add32)
1167     /* FROZEN */
1168 ]
1169 interface nsIDOMHTMLTextAreaElement : nsIDOMHTMLElement
1170 {
1171     nsresult GetDefaultValue(nsAString *aDefaultValue);
1172     nsresult SetDefaultValue(const nsAString *aDefaultValue);
1173     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
1174     nsresult GetAccessKey(nsAString *aAccessKey);
1175     nsresult SetAccessKey(const nsAString *aAccessKey);
1176     nsresult GetCols(PRInt32 *aCols);
1177     nsresult SetCols(PRInt32 aCols);
1178     nsresult GetDisabled(PRBool *aDisabled);
1179     nsresult SetDisabled(PRBool aDisabled);
1180     nsresult GetName(nsAString *aName);
1181     nsresult SetName(const nsAString *aName);
1182     nsresult GetReadOnly(PRBool *aReadOnly);
1183     nsresult SetReadOnly(PRBool aReadOnly);
1184     nsresult GetRows(PRInt32 *aRows);
1185     nsresult SetRows(PRInt32 aRows);
1186     nsresult GetTabIndex(PRInt32 *aTabIndex);
1187     nsresult SetTabIndex(PRInt32 aTabIndex);
1188     nsresult GetType(nsAString *aType);
1189     nsresult GetValue(nsAString *aValue);
1190     nsresult SetValue(const nsAString *aValue);
1191     nsresult Blur();
1192     nsresult Focus();
1193     nsresult Select();
1194 }
1195
1196 [
1197     object,
1198     uuid(94928ab3-8b63-11d3-989d-001083010e9b)
1199     /* FROZEN */
1200 ]
1201 interface nsIURIContentListener : nsISupports
1202 {
1203     nsresult OnStartURIOpen(nsIURI *aURI, PRBool *_retval);
1204     nsresult DoContent(const char *aContentType, PRBool aIsContentPreferred, nsIRequest *aRequest,
1205         nsIStreamListener **aContentHandler, PRBool *_retval);
1206     nsresult IsPreferred(const char *aContentType, char **aDesiredContentType, PRBool *_retval);
1207     nsresult CanHandleContent(const char *aContentType, PRBool aIsContentPreferred,
1208         char **aDesiredContentType, PRBool *_retval);
1209     nsresult GetLoadCookie(nsISupports **aLoadCookie);
1210     nsresult SetLoadCookie(nsISupports *aLoadCookie);
1211     nsresult GetParentContentListener(nsIURIContentListener **aParentContentListener);
1212     nsresult SetParentContentListener(nsIURIContentListener *aParentContentListener);
1213 }
1214
1215 [
1216     object,
1217     uuid(44b78386-1dd2-11b2-9ad2-e4eee2ca1916)
1218     /* FROZEN */
1219 ]
1220 interface nsITooltipListener : nsISupports
1221 {
1222     nsresult OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, const PRUnichar *aTipText);
1223     nsresult OnHideTooltip();
1224 }
1225
1226 [
1227     object,
1228     uuid(69e5df00-7b8b-11d3-af61-00a024ffc08c)
1229     /* FROZEN */
1230 ]
1231 interface nsIWebBrowser : nsISupports
1232 {
1233     nsresult AddWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
1234     nsresult RemoveWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
1235     nsresult GetContainerWindow(nsIWebBrowserChrome **aContainerWindow);
1236     nsresult SetContainerWindow(nsIWebBrowserChrome *aContainerWindow);
1237     nsresult GetParentURIContentListener(nsIURIContentListener **aParentURIContentListener);
1238     nsresult SetParentURIContentListener(nsIURIContentListener *aParentURIContentListener);
1239     nsresult GetContentDOMWindow(nsIDOMWindow **aContentDOMWindow);
1240 }
1241
1242 cpp_quote("#define SETUP_IS_CHROME_WRAPPER 7");
1243
1244 [
1245     object,
1246     uuid(f15398a0-8018-11d3-af70-00a024ffc08c)
1247     /* FROZEN */
1248 ]
1249 interface nsIWebBrowserSetup : nsISupports
1250 {
1251     nsresult SetProperty(PRUint32 aId, PRUint32 aValue);
1252 }
1253
1254 typedef void* nativeWindow;
1255
1256 [
1257     object,
1258     uuid(046bc8a0-8015-11d3-af70-00a024ffc08c)
1259     /* NOT_FROZEN */
1260 ]
1261 interface nsIBaseWindow : nsISupports
1262 {
1263     nsresult InitWindow(nativeWindow parentNativeWindow, nsIWidget *parentWidget, PRInt32 x,
1264             PRInt32 y, PRInt32 cx, PRInt32 cy);
1265     nsresult Create();
1266     nsresult Destroy();
1267     nsresult SetPosition(PRInt32 x, PRInt32 y);
1268     nsresult GetPosition(PRInt32 *x, PRInt32 *y);
1269     nsresult SetSize(PRInt32 cx, PRInt32 cy, PRBool fRepaint);
1270     nsresult GetSize(PRInt32 *cx, PRInt32 *cy);
1271     nsresult SetPositionAndSize(PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy, PRBool fRepaint);
1272     nsresult GetPositionAndSize(PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy);
1273     nsresult Repaint(PRBool force);
1274     nsresult GetParentWidget(nsIWidget **aParentWidget);
1275     nsresult SetParentWidget(nsIWidget *aParentWidget);
1276     nsresult GetParentNativeWindow(nativeWindow *aParentNativeWindow);
1277     nsresult SetParentNativeWindow(nativeWindow aParentNativeWindow);
1278     nsresult GetVisibility(PRBool *aVisibility);
1279     nsresult SetVisibility(PRBool aVisibility);
1280     nsresult GetEnabled(PRBool *aEnabled);
1281     nsresult SetEnabled(PRBool aEnabled);
1282     nsresult GetBlurSuppression(PRBool *aBlurSuppression);
1283     nsresult SetBlurSuppression(PRBool aBlurSuppression);
1284     nsresult GetMainWidget(nsIWidget **aMainWidget);
1285     nsresult SetFocus();
1286     nsresult GetTitle(PRUnichar **aTitle);
1287     nsresult SetTitle(const PRUnichar *aTitle);
1288 }
1289
1290 cpp_quote("#define LOAD_FLAGS_NONE 0");
1291
1292 [
1293     object,
1294     uuid(f5d9e7b0-d930-11d3-b057-00a024ffc08c)
1295     /* NOT_FROZEN */
1296 ]
1297 interface nsIWebNavigation : nsISupports
1298 {
1299     nsresult GetCanGoBack(PRBool *aCanGoBack);
1300     nsresult GetCanGoForward(PRBool *aCanGoForward);
1301     nsresult GoBack();
1302     nsresult GoForward();
1303     nsresult GotoIndex(PRInt32 index);
1304     nsresult LoadURI(const PRUnichar *aURI, PRUint32 aLoadFlags, nsIURI *aReferrer,
1305             nsIInputStream *aPostData, nsIInputStream *aHeaders);
1306     nsresult Reload(PRUint32 aReloadFlags);
1307     nsresult Stop(PRUint32 aStopFlags);
1308     nsresult GetDocument(nsIDOMDocument **aDocument);
1309     nsresult GetCurrentURI(nsIURI **aCurrentURI);
1310     nsresult GetReferringURI(nsIURI **aReferringURI);
1311     nsresult GetSessionHistory(nsISHistory **aSessionHistory);
1312     nsresult SetSessionHistory(nsISHistory *aSessionHistory);
1313 }
1314
1315 [
1316     object,
1317     uuid(f1094df6-ce0e-42c9-9847-2f663172c38d)
1318     /* NOT_FROZEN */
1319 ]
1320 interface nsIPrintSettings : nsISupports
1321 {
1322     typedef struct {} nsMargin;
1323
1324     nsresult SetPrintOptions(PRInt32 aType, PRBool aTurnOnOff);
1325     nsresult GetPrintOptions(PRInt32 aType, PRBool *_retval);
1326     nsresult GetPrintOptionsBits(PRInt32 *_retval);
1327     nsresult GetPageSizeInTwips(PRInt32 *aWidth, PRInt32 *aHeight);
1328     nsresult Clone(nsIPrintSettings **_retval);
1329     nsresult Assign(nsIPrintSettings *aPS);
1330     nsresult GetPrintSession(nsIPrintSession **aPrintSession);
1331     nsresult SetPrintSession(nsIPrintSession *aPrintSession);
1332     nsresult GetStartPageRange(PRInt32 *aStartPageRange);
1333     nsresult SetStartPageRange(PRInt32 aStartPageRange);
1334     nsresult GetEndPageRange(PRInt32 *aEndPageRange);
1335     nsresult SetEndPageRange(PRInt32 aEndPageRange);
1336     nsresult GetMarginTop(double *aMarginTop);
1337     nsresult SetMarginTop(double aMarginTop);
1338     nsresult GetMarginLeft(double *aMarginLeft);
1339     nsresult SetMarginLeft(double aMarginLeft);
1340     nsresult GetMarginBottom(double *aMarginBottom);
1341     nsresult SetMarginBottom(double aMarginBottom);
1342     nsresult GetMarginRight(double *aMarginRight);
1343     nsresult SetMarginRight(double aMarginRight);
1344     nsresult GetScaling(double *aScaling);
1345     nsresult SetScaling(double aScaling);
1346     nsresult GetPrintBGColors(PRBool *aPrintBGColors);
1347     nsresult SetPrintBGColors(PRBool aPrintBGColors);
1348     nsresult GetPrintBGImages(PRBool *aPrintBGImages);
1349     nsresult SetPrintBGImages(PRBool aPrintBGImages);
1350     nsresult GetPrintRange(PRInt16 *aPrintRange);
1351     nsresult SetPrintRange(PRInt16 aPrintRange);
1352     nsresult GetTitle(PRUnichar **aTitle);
1353     nsresult SetTitle(const PRUnichar *aTitle);
1354     nsresult GetDocURL(PRUnichar **aDocURL);
1355     nsresult SetDocURL(const PRUnichar *aDocURL);
1356     nsresult GetHeaderStrLeft(PRUnichar **aHeaderStrLeft);
1357     nsresult SetHeaderStrLeft(const PRUnichar *aHeaderStrLeft);
1358     nsresult GetHeaderStrCenter(PRUnichar **aHeaderStrCenter);
1359     nsresult SetHeaderStrCenter(const PRUnichar *aHeaderStrCenter);
1360     nsresult GetHeaderStrRight(PRUnichar **aHeaderStrRight);
1361     nsresult SetHeaderStrRight(const PRUnichar *aHeaderStrRight);
1362     nsresult GetFooterStrLeft(PRUnichar **aFooterStrLeft);
1363     nsresult SetFooterStrLeft(const PRUnichar *aFooterStrLeft);
1364     nsresult GetFooterStrCenter(PRUnichar **aFooterStrCenter);
1365     nsresult SetFooterStrCenter(const PRUnichar *aFooterStrCenter);
1366     nsresult GetFooterStrRight(PRUnichar **aFooterStrRight);
1367     nsresult SetFooterStrRight(const PRUnichar *aFooterStrRight);
1368     nsresult GetHowToEnableFrameUI(PRInt16 *aHowToEnableFrameUI);
1369     nsresult SetHowToEnableFrameUI(PRInt16 aHowToEnableFrameUI);
1370     nsresult GetIsCancelled(PRBool *aIsCancelled);
1371     nsresult SetIsCancelled(PRBool aIsCancelled);
1372     nsresult GetPrintFrameTypeUsage(PRInt16 *aPrintFrameTypeUsage);
1373     nsresult SetPrintFrameTypeUsage(PRInt16 aPrintFrameTypeUsage);
1374     nsresult GetPrintFrameType(PRInt16 *aPrintFrameType);
1375     nsresult SetPrintFrameType(PRInt16 aPrintFrameType);
1376     nsresult GetPrintSilent(PRBool *aPrintSilent);
1377     nsresult SetPrintSilent(PRBool aPrintSilent);
1378     nsresult GetShrinkToFit(PRBool *aShrinkToFit);
1379     nsresult SetShrinkToFit(PRBool aShrinkToFit);
1380     nsresult GetShowPrintProgress(PRBool *aShowPrintProgress);
1381     nsresult SetShowPrintProgress(PRBool aShowPrintProgress);
1382     nsresult GetPaperName(PRUnichar **aPaperName);
1383     nsresult SetPaperName(const PRUnichar *aPaperName);
1384     nsresult GetPaperSizeType(PRInt16 *aPaperSizeType);
1385     nsresult SetPaperSizeType(PRInt16 aPaperSizeType);
1386     nsresult GetPaperData(PRInt16 *aPaperData);
1387     nsresult SetPaperData(PRInt16 aPaperData);
1388     nsresult GetPaperWidth(double *aPaperWidth);
1389     nsresult SetPaperWidth(double aPaperWidth);
1390     nsresult GetPaperHeight(double *aPaperHeight);
1391     nsresult SetPaperHeight(double aPaperHeight);
1392     nsresult GetPaperSizeUnit(PRInt16 *aPaperSizeUnit);
1393     nsresult SetPaperSizeUnit(PRInt16 aPaperSizeUnit);
1394     nsresult GetPlexName(PRUnichar **aPlexName);
1395     nsresult SetPlexName(const PRUnichar *aPlexName);
1396     nsresult GetColorspace(PRUnichar **aColorspace);
1397     nsresult SetColorspace(const PRUnichar *aColorspace);
1398     nsresult GetResolutionName(PRUnichar **aResolutionName);
1399     nsresult SetResolutionName(const PRUnichar aResolutionName);
1400     nsresult GetDownloadFonts(PRBool *aDownloadFonts);
1401     nsresult SetDownloadFonts(PRBool aDownloadFonts);
1402     nsresult GetPrintReversed(PRBool *aPrintReversed);
1403     nsresult SetPrintReversed(PRBool aPrintReversed);
1404     nsresult GetPrintInColor(PRBool *aPrintInColor);
1405     nsresult SetPrintInColor(PRBool aPrintInColor);
1406     nsresult GetPaperSize(PRInt32 *aPaperSize);
1407     nsresult SetPaperSize(PRInt32 aPaperSize);
1408     nsresult GetOrientation(PRInt32 *aOrientation);
1409     nsresult SetOrientation(PRInt32 aOrientation);
1410     nsresult GetPrintCommand(PRUnichar **aPrintCommand);
1411     nsresult SetPrintCommand(const PRUnichar *aPrintCommand);
1412     nsresult GetNumCopies(PRInt32 *aNumCopies);
1413     nsresult SetNumCopies(PRInt32 aNumCopies);
1414     nsresult GetPrinterName(PRUnichar **aPrinterName);
1415     nsresult SetPrinterName(const PRUnichar *aPrinterName);
1416     nsresult GetPrintToFile(PRBool *aPrintToFile);
1417     nsresult SetPrintToFile(PRBool aPrintToFile);
1418     nsresult GetToFileName(PRUnichar **aToFileName);
1419     nsresult SetToFileName(const PRUnichar *aToFileName);
1420     nsresult GetPrintPageDelay(PRInt32 *aPrintPageDelay);
1421     nsresult SetPrintPageDelay(PRInt32 aPrintPageDelay);
1422     nsresult GetIsInitializedFromPrinter(PRBool *aIsInitializedFromPrinter);
1423     nsresult SetIsInitializedFromPrinter(PRBool aIsInitializedFromPrinter);
1424     nsresult GetIsInitializedFromPrefs(PRBool *aIsInitializedFromPrefs);
1425     nsresult SetIsInitializedFromPrefs(PRBool aIsInitializedFromPrefs);
1426     nsresult SetMarginInTwips(nsMargin *aMargin);
1427     nsresult GetMarginInTwips(nsMargin *aMargin);
1428 }
1429
1430 [
1431     object,
1432     uuid(9a7ca4b0-fbba-11d4-a869-00105a183419)
1433     /* FROZEN */
1434 ]
1435 interface nsIWebBrowserPrint : nsISupports
1436 {
1437     nsresult GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings);
1438     nsresult GetCurrentPrintSettings(nsIPrintSettings **aCurrentPrintSettings);
1439     nsresult GetCurrentChildDOMWindow(nsIDOMWindow **aCurrentChildDOMWindow);
1440     nsresult GetDoingPrint(PRBool *aDoingPrint);
1441     nsresult GetDoingPrintPreview(PRBool *aDoingPrintPreview);
1442     nsresult GetIsFramesetDocument(PRBool *aIsFramesetDocument);
1443     nsresult GetIsFramesetFrameSelected(PRBool *aIsFramesetFrameSelected);
1444     nsresult GetIsIFrameSelected(PRBool *aIsIFrameSelected);
1445     nsresult GetIsRangeSelection(PRBool *aIsRangeSelection);
1446     nsresult GetPrintPreviewNumPages(PRInt32 *aPrintPreviewNumPages);
1447     nsresult Print(nsIPrintSettings *aThePrintSettings, nsIWebProgressListener *aWPListener);
1448     nsresult PrintPreview(nsIPrintSettings *aThePrintSettings, nsIDOMWindow *aChildDOMWin,
1449                           nsIWebProgressListener *aWPListener);
1450     nsresult PrintPreviewNavigate(PRInt16 aNavType, PRInt32 aPageNum);
1451     nsresult Cancel();
1452     nsresult EnumerateDocumentNames(PRUint32 *aCount, PRUnichar ***aResult);
1453     nsresult ExitPrintPreview();
1454 }
1455
1456 [
1457     object,
1458     uuid(919e792a-6490-40b8-bba5-f9e9ad5640c8)
1459     /* NOT_FROZEN */
1460 ]
1461 interface nsIScrollable : nsISupports
1462 {
1463     enum {
1464         ScrollOrientation_X = 1,
1465         ScrollOrientation_Y = 2
1466     };
1467
1468     enum {
1469         Scrollbar_Auto   = 1,
1470         Scrollbar_Never  = 2,
1471         Scrollbar_Always = 3
1472     };
1473
1474     nsresult GetCurScrollPos(PRInt32 scrollOrientation, PRInt32 *curPos);
1475     nsresult SetCurScrollPos(PRInt32 scrollOrientation, PRInt32 curPos);
1476     nsresult SetCurScrollPosEx(PRInt32 curHorizontalPos, PRInt32 curVerticalPos);
1477     nsresult GetScrollRange(PRInt32 scrollOrientation, PRInt32 *minPos, PRInt32 *maxPos);
1478     nsresult SetScrollRange(PRInt32 scrollOrientation, PRInt32 minPos, PRInt32 maxPos);
1479     nsresult SetScrollRangeEx(PRInt32 minHorizontalPos, PRInt32 maxHorizontalPos,
1480             PRInt32 minVerticalPos, PRInt32 maxVerticalPos);
1481     nsresult GetDefaultScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 *scrollbarPref);
1482     nsresult SetDefaultScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 scrollbarPref);
1483     nsresult GetScrollbarVisibility(PRBool *verticalVisible, PRBool *horizontalVisible);
1484 }
1485
1486 [
1487     object,
1488     uuid(c8c0a080-0868-11d3-915f-d9d889d48e3c)
1489     /* FROZEN */
1490 ]
1491 interface nsIFile : nsISupports
1492 {
1493     nsresult Append(const nsAString *node);
1494     nsresult AppendNative(const nsAString *node);
1495     nsresult Normalize();
1496     nsresult Create(PRUint32 type, PRUint32 permission);
1497     nsresult GetLeafName(nsAString *aLeafName);
1498     nsresult SetLeafName(const nsAString *aLeafName);
1499     nsresult GetNativeLeafName(nsAString *aLeafName);
1500     nsresult SetNativeLeafName(const nsAString *aLeafName);
1501     nsresult CopyTo(nsIFile *newParentDir, const nsAString *newName);
1502     nsresult CopyToNative(nsIFile *newParentDir, const nsAString *newName);
1503     nsresult CopyToFollowingLinks(nsIFile *newParentDir, const nsAString *newName);
1504     nsresult CopyToFollowingLinksNative(nsIFile *newParentDir, const nsAString *newName);
1505     nsresult MoveTo(nsIFile *newParentDir, const nsAString *newName);
1506     nsresult MoveToNative(nsIFile *newParentDir, const nsAString *newName);
1507     nsresult Remove(PRBool recursive);
1508     nsresult GetPermissions(PRUint32 *aPermissions);
1509     nsresult SetPermissions(PRUint32 pPermissions);
1510     nsresult GetPermissionsOfLink(PRUint32 *aPermissions);
1511     nsresult SetPermissionsOfLink(PRUint32 pPermissions);
1512     nsresult GetLastModifiedTime(PRInt64 *aLastModifiedTime);
1513     nsresult SetLastModifiedTime(PRInt64 aLastModifiedTime);
1514     nsresult GetFileSize(PRInt64 *aFileSize);
1515     nsresult SetFileSize(PRInt64 aFileSize);
1516     nsresult GetFileSizeOfLink(PRInt64 *aFileSizeOfLink);
1517     nsresult GetTarget(nsAString *aTarget);
1518     nsresult GetNativeTarget(nsACString *aNativeTarget);
1519     nsresult GetPath(nsAString *aPath);
1520     nsresult GetNativePath(nsACString *aNativePath);
1521     nsresult Exists(PRBool *_retval);
1522     nsresult IsWritable(PRBool *_retval);
1523     nsresult IsReadable(PRBool *_retval);
1524     nsresult IsExecutable(PRBool *_retval);
1525     nsresult IsHidden(PRBool *_retval);
1526     nsresult IsDirectory(PRBool *_retval);
1527     nsresult IsFile(PRBool *_retval);
1528     nsresult IsSymlink(PRBool *_retval);
1529     nsresult IsSpecial(PRBool *_retval);
1530     nsresult CreateUnique(PRUint32 type, PRUint32 permission);
1531     nsresult Clone(nsIFile **_retval);
1532     nsresult Equals(nsIFile *inFile, PRBool *_retval);
1533     nsresult Contains(nsIFile *inFile, PRBool recir, PRBool *_retval);
1534     nsresult GetParent(nsIFile **aParent);
1535     nsresult GetDirectoryEntries(nsISimpleEnumerator **aDirectoryEntries);
1536 }
1537
1538 [
1539     object,
1540     uuid(56c35506-f14b-11d3-99d3-ddbfac2ccf65)
1541     /* FROZEN */
1542 ]
1543 interface nsIPrefBranch : nsISupports
1544 {
1545     nsresult GetRoot(char **aRoot);
1546     nsresult GetPrefType(const char *aPrefName, PRInt32 *_retval);
1547     nsresult GetBoolPref(const char *aPrefName, PRBool *_retval);
1548     nsresult SetBoolPref(const char *aPrefName, PRInt32 aValue);
1549     nsresult GetCharPref(const char *aPrefName, char **_retval);
1550     nsresult SetCharPref(const char *aPrefName, const char *aValue);
1551     nsresult GetIntPref(const char *aPrefName, PRInt32 *_retval);
1552     nsresult SetIntPref(const char *aPrefName, PRInt32 aValue);
1553     nsresult GetComplexValue(const char *aPrefName, const nsIID *aType, void **aValue);
1554     nsresult SetComplexValue(const char *aPrefName, const nsIID *aType, nsISupports *aValue);
1555     nsresult ClearUserPref(const char *aPrefName);
1556     nsresult LockPref(const char *aPrefName);
1557     nsresult PrefHasUserValue(const char *aPrefName, PRBool *_retval);
1558     nsresult PrefIsLocked(const char *aPrefName, PRBool *_retval);
1559     nsresult UnlockPref(const char *aPrefName);
1560     nsresult DeleteBranch(const char *aStartingAt);
1561     nsresult GetChildList(const char *aStartingAt, PRUint32 *aCount, char ***aChildArray);
1562     nsresult ResetBranch(const char *aStartingAt);
1563 }
1564
1565 [
1566     object,
1567     uuid(15fd6940-8ea7-11d3-93ad-00104ba0fd40)
1568     /* FROZEN */
1569 ]
1570 interface nsIProtocolHandler : nsISupports
1571 {
1572     nsresult GetScheme(nsACString *aScheme);
1573     nsresult GetDefaultPort(PRInt32 *aDefaultPort);
1574     nsresult GetProtocolFlags(PRUint32 *aProtocolFlags);
1575     nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset,
1576                     nsIURI *aBaseURI, nsIURI **_retval);
1577     nsresult NewChannel(nsIURI *aURI, nsIChannel **_retval);
1578     nsresult AllowPort(PRInt32 port, const char *scheme, PRBool *_retval);
1579 }
1580
1581 [
1582     object,
1583     uuid(0e61f3b2-34d7-4c79-bfdc-4860bc7341b7)
1584     /* NOT_FROZEN */
1585 ]
1586 interface nsIExternalProtocolHandler : nsIProtocolHandler
1587 {
1588     nsresult ExternalAppExistsForScheme(const nsACString *scheme, PRBool *_retval);
1589 }
1590
1591 [
1592     object,
1593     uuid(bddeda3f-9020-4d12-8c70-984ee9f7935e)
1594     /* FROZEN */
1595 ]
1596 interface nsIIOService : nsISupports
1597 {
1598     nsresult GetProtocolHandler(const char *aScheme, nsIProtocolHandler **_retval);
1599     nsresult GetProtocolFlags(const char *aScheme, PRUint32 *_retval);
1600     nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
1601                     nsIURI **_retval);
1602     nsresult NewFileURI(nsIFile *aFile, nsIURI **_retval);
1603     nsresult NewChannelFromURI(nsIURI *aURI, nsIChannel **_retval);
1604     nsresult NewChannel(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
1605                         nsIChannel **_retval);
1606     nsresult GetOffline(PRBool *aOffline);
1607     nsresult SetOffline(PRBool aOffline);
1608     nsresult AllowPort(PRInt32 aPort, const char *aScheme, PRBool *_retval);
1609     nsresult ExtractScheme(const nsACString *urlString, nsACString * _retval);
1610 }
1611
1612 [
1613     object,
1614     uuid(9c5d3c58-1dd1-11b2-a1c9-f3699284657a)
1615     /* FROZEN */
1616 ]
1617 interface nsIWebBrowserFocus : nsISupports
1618 {
1619     nsresult Activate();
1620     nsresult Deactivate();
1621     nsresult SetFocusAtFirstElement();
1622     nsresult SetFocusAtLastElement();
1623     nsresult GetFocusedWindow(nsIDOMWindow **aFocusedWindow);
1624     nsresult SetFocusedWindow(nsIDOMWindow *aFocusedWindow);
1625     nsresult GetFocusedElement(nsIDOMElement **aFocusedElement);
1626     nsresult SetFocusedElement(nsIDOMElement *aFocusedElement);
1627 }
1628
1629 [
1630     object,
1631     uuid(ba434c60-9d52-11d3-afb0-00a024ffc08c)
1632     /* FROZEN */
1633 ]
1634 interface nsIWebBrowserChrome : nsISupports
1635 {
1636     nsresult SetStatus(PRUint32 statusType, const PRUnichar *status);
1637     nsresult GetWebBrowser(nsIWebBrowser **aWebBrowser);
1638     nsresult SetWebBrowser(nsIWebBrowser *aWebBrowser);
1639     nsresult GetChromeFlags(PRUint32 *aChromeFlags);
1640     nsresult SetChromeFlags(PRUint32 aChromeFlags);
1641     nsresult DestroyBrowserWindow();
1642     nsresult SizeBrowserTo(PRInt32 aCX, PRInt32 aCY);
1643     nsresult ShowAsModal();
1644     nsresult IsWindowModal(PRBool *_retval);
1645     nsresult ExitModalEventLoop(nsresult aStatus);
1646 }
1647
1648 [
1649     object,
1650     uuid(df31c120-ded6-11d1-bd85-00805f8ae3f4)
1651     /* FROZEN */
1652 ]
1653 interface nsIDOMEventListener : nsISupports
1654 {
1655     nsresult HandleEvent(nsIDOMEvent *event);
1656 }
1657
1658 [
1659     object,
1660     uuid(1c773b30-d1cf-11d2-bd95-00805f8ae3f4)
1661     /* FROZEN */
1662 ]
1663 interface nsIDOMEventTarget : nsISupports
1664 {
1665     nsresult AddEventListener(const nsAString *type, nsIDOMEventListener *listener, PRBool useCapture);
1666     nsresult RemoveEventListener(const nsAString *type, nsIDOMEventListener *listener, PRBool useCapture);
1667     nsresult DispatchEvent(nsIDOMEvent *evt, PRBool *_retval);
1668 }
1669
1670 [
1671     object,
1672     uuid(a66b7b80-ff46-bd97-0080-5f8ae38add32)
1673     /* FROZEN */
1674 ]
1675 interface nsIDOMEvent : nsISupports
1676 {
1677     nsresult GetType(nsAString *aType);
1678     nsresult GetTarget(nsIDOMEventTarget **aTarget);
1679     nsresult GetCurrentTarget(nsIDOMEventTarget **aCurrentTarget);
1680     nsresult GetEventPhase(PRUint16 *aEventPhase);
1681     nsresult GetBubbles(PRBool *aBubbles);
1682     nsresult GetCancelable(PRBool *aCancelable);
1683     nsresult GetTimeStamp(DOMTimeStamp *aTimeStamp);
1684     nsresult StopPropagation();
1685     nsresult PreventDefault();
1686     nsresult InitEvent(const nsAString *eventTypeArg, PRBool canBubbleArg, PRBool cancelableArg);
1687 }
1688
1689 cpp_quote("#define CONTEXT_NONE              0x00");
1690 cpp_quote("#define CONTEXT_LINK              0x01");
1691 cpp_quote("#define CONTEXT_IMAGE             0x02");
1692 cpp_quote("#define CONTEXT_DOCUMENT          0x04");
1693 cpp_quote("#define CONTEXT_TEXT              0x08");
1694 cpp_quote("#define CONTEXT_INPUT             0x10");
1695 cpp_quote("#define CONTEXT_BACKGROUND_IMAGE  0x20");
1696
1697 [
1698     object,
1699     uuid(3478b6b0-3875-11d4-94ef-0020183bf181)
1700     /* FROZEN */
1701 ]
1702 interface nsIContextMenuListener : nsISupports
1703 {
1704     nsresult OnShowContextMenu(PRUint32 aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode);
1705 }
1706
1707 [
1708     object,
1709     uuid(a6cf90c3-15b3-11d2-932e-00805f8add32)
1710     /* FROZEN */
1711 ]
1712 interface nsIDOMUIEvent : nsIDOMEvent
1713 {
1714     nsresult GetView(nsIDOMAbstractView **aView);
1715     nsresult GetDetail(PRInt32 *aDetail);
1716     nsresult InitUIEvent(const nsAString *typeArg, PRBool canBubbleArg, PRBool cancelableArg,
1717             nsIDOMAbstractView *viewArg, PRInt32 detailArg);
1718 }
1719
1720 [
1721     object,
1722     uuid(ff751edc-8b02-aae7-0010-8301838a3123)
1723     /* FROZEN */
1724 ]
1725 interface nsIDOMMouseEvent : nsIDOMUIEvent
1726 {
1727     nsresult GetScreenX(PRInt32 *aScreenX);
1728     nsresult GetScreenY(PRInt32 *aScreenY);
1729     nsresult GetClientX(PRInt32 *aClientX);
1730     nsresult GetClientY(PRInt32 *aClientY);
1731     nsresult GetCtrlKey(PRBool *aCtrlKey);
1732     nsresult GetShiftKey(PRBool *aShiftKey);
1733     nsresult GetAltKey(PRBool *aAltKey);
1734     nsresult GetMetaKey(PRBool *aMetaKey);
1735     nsresult GetButton(PRUint16 *aButton);
1736     nsresult GetRelatedTarget(nsIDOMEventTarget * *aRelatedTarget);
1737     nsresult InitMouseEvent(const nsAString *typeArg, PRBool canBubbleArg, PRBool cancelableArg,
1738             nsIDOMAbstractView *viewArg, PRInt32 detailArg, PRInt32 screenXArg, PRInt32 screenYArg,
1739             PRInt32 clientXArg, PRInt32 clientYArg, PRBool ctrlKeyArg, PRBool altKeyArg,
1740             PRBool shiftKeyArg, PRBool metaKeyArg, PRUint16 buttonArg,
1741             nsIDOMEventTarget *relatedTargetArg);
1742 }
1743
1744 [
1745     object,
1746     uuid(028e0e6e-8b01-11d3-aae7-0010838a3123)
1747     /* NOT_FROZEN */
1748 ]
1749 interface nsIDOMKeyEvent : nsIDOMUIEvent
1750 {
1751     nsresult GetCharCode(PRUint32 *aCharCode);
1752     nsresult GetKeyCode(PRUint32 *aKeyCode);
1753     nsresult GetAltKey(PRBool *aAltKey);
1754     nsresult GetCtrlKey(PRBool *aCtrlKey);
1755     nsresult GetShiftKey(PRBool *aShiftKey);
1756     nsresult GetMetaKey(PRBool *aMetaKey);
1757     nsresult InitKeyEvent(const nsAString *typeArg, PRBool canBubbleArg,
1758             PRBool cancelableArg, nsIDOMAbstractView *viewArg, PRBool ctrlKeyArg,
1759             PRBool altKeyArg, PRBool shiftKeyArg, PRBool metaKeyArg, PRUint32 keyCodeArg,
1760             PRUint32 charCodeArg);
1761 }
1762
1763 [
1764      object,
1765      uuid(3e5432cd-9568-4bd1-8cbe-d50aba110743)
1766      /* FROZEN */
1767 ]
1768 interface nsIEmbeddingSiteWindow : nsISupports
1769 {
1770     nsresult SetDimensions(PRUint32 flags, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy);
1771     nsresult GetDimensions(PRUint32 flags, PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy);
1772     nsresult SetFocus();
1773     nsresult GetVisibility(PRBool *aVisibility);
1774     nsresult SetVisibility(PRBool aVisibility);
1775     nsresult GetTitle(PRUnichar **aTitle);
1776     nsresult SetTitle(const PRUnichar *aTitle);
1777     nsresult GetSiteWindow(void **aSiteWindow);
1778 }
1779
1780 [
1781      object,
1782      uuid(2417cbfe-65ad-48a6-b4b6-eb84db174392)
1783      /* FROZEN */
1784 ]
1785 interface nsIComponentRegistrar : nsISupports
1786 {
1787     nsresult AutoRegister(nsIFile *aSpec);
1788     nsresult AutoUnregister(nsIFile *aSpec);
1789     nsresult RegisterFactory(const nsCID *aClass, const char *aClassName,
1790             const char *aContractID, nsIFactory *aFactory);
1791     nsresult UnregisterFactory(const nsCID *aClass, nsIFactory *aFactory);
1792     nsresult RegisterFactoryLocation(const nsCID *aClass, const char *aClassName,
1793             const char *aContractID, nsIFile *aFile, const char *aLoaderStr,
1794             const char *aType);
1795     nsresult UnregisterFactoryLocation(const nsCID *aClass, nsIFile *aFile);
1796     nsresult IsCIDRegistered(const nsCID *aClass, PRBool *_retval);
1797     nsresult IsContractIDRegistered(const char *aContractID, PRBool *_retval);
1798     nsresult EnumerateCIDs(nsISimpleEnumerator **_retval);
1799     nsresult EnumerateContractIDs(nsISimpleEnumerator **_retval);
1800     nsresult CIDToContractID(const nsCID *aClass, char **_retval);
1801     nsresult ContractIDToCID(const char *aContractID, nsCID **_retval);
1802 }
1803
1804 [
1805     object,
1806     uuid(1630c61a-325e-49ca-8759-a31b16c47aa5)
1807     /* FROZEN */
1808 ]
1809 interface nsIPromptService : nsISupports
1810 {
1811     nsresult Alert(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1812             const PRUnichar *aText);
1813     nsresult AlertCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1814             const PRUnichar *aText, const PRUnichar *aCheckMsg, PRBool *aCheckState);
1815     nsresult Confirm(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1816             const PRUnichar *aText, PRBool *_retval);
1817     nsresult ConfirmCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1818             const PRUnichar *aText, const PRUnichar *aCheckMsg, PRBool *aCheckState,
1819             PRBool *_retval);
1820     nsresult ConfirmEx(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1821             const PRUnichar *aText, PRUint32 aButtonFlags, const PRUnichar *aButton0Title,
1822             const PRUnichar *aButton1Title, const PRUnichar *aButton2Title,
1823             const PRUnichar *aCheckMsg, PRBool *aCheckState, PRInt32 *_retval);
1824     nsresult Prompt(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1825             const PRUnichar *aText, PRUnichar **aValue, const PRUnichar *aCheckMsg,
1826             PRBool *aCheckState, PRBool *_retval);
1827     nsresult PromptUsernameAndPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1828             const PRUnichar *aText, PRUnichar **aUsername, PRUnichar **aPassword,
1829             const PRUnichar *aCheckMsg, PRBool *aCheckState, PRBool *_retval);
1830     nsresult PromptPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1831             const PRUnichar *aText, PRUnichar **aPassword, const PRUnichar *aCheckMsg,
1832             PRBool *aCheckState, PRBool *_retval);
1833     nsresult Select(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1834             const PRUnichar *aText, PRUint32 aCount, const PRUnichar **aSelectList,
1835             PRInt32 *aOutSelection, PRBool *_retval);
1836 }
1837
1838 [
1839     object,
1840     uuid(b128a1e6-44f3-4331-8fbe-5af360ff21ee)
1841     /* FROZEN */
1842 ]
1843 interface nsITooltipTextProvider : nsISupports
1844 {
1845     nsresult GetNodeText(nsIDOMNode *aNode, PRUnichar **aText, PRBool *_retval);
1846 }
1847
1848 [
1849     object,
1850     uuid(02b0625a-e7f3-11d2-9f5a-006008a6efe9)
1851     /* FROZEN */
1852 ]
1853 interface nsIProfile : nsISupports
1854 {
1855     nsresult GetProfileCount(PRInt32 *aProfileCount);
1856     nsresult GetProfileList(PRUint32 *length, PRUnichar ***profileNames);
1857     nsresult ProfileExists(const PRUnichar *profileName, PRBool *_retval);
1858     nsresult GetCurrentProfile(PRUnichar * *aCurrentProfile);
1859     nsresult SetCurrentProfile(const PRUnichar * aCurrentProfile);
1860     nsresult ShutDownCurrentProfile(PRUint32 shutDownType);
1861     nsresult CreateNewProfile(const PRUnichar *profileName,
1862             const PRUnichar *nativeProfileDir, const PRUnichar *langcode,
1863             PRBool useExistingDir);
1864     nsresult RenameProfile(const PRUnichar *oldName, const PRUnichar *newName);
1865     nsresult DeleteProfile(const PRUnichar *name, PRBool canDeleteFiles);
1866     nsresult CloneProfile(const PRUnichar *profileName);
1867 }
1868
1869 [
1870     object,
1871     uuid(30465632-a777-44cc-90f9-8145475ef999)
1872     /* FROZEN */
1873 ]
1874 interface nsIWindowCreator : nsISupports
1875 {
1876     nsresult CreateChromeWindow(nsIWebBrowserChrome *parent, PRUint32 chromeFlags,
1877                                    nsIWebBrowserChrome **_retval);
1878 }
1879
1880 [
1881     object,
1882     uuid(f673ec81-a4b0-11d6-964b-eb5a2bf216fc)
1883     /* NOT_FROZEN */
1884 ]
1885 interface nsIWindowCreator2 : nsIWindowCreator
1886 {
1887     nsresult CreateChromeWindow2(nsIWebBrowserChrome *parent, PRUint32 chromeFlags,
1888                                  PRUint32 contextFlags, nsIURI *uri, PRBool *cancel,
1889                                  nsIWebBrowserChrome **_retval);
1890 }
1891
1892 [
1893     object,
1894     uuid(002286a8-494b-43b3-8ddd-49e3fc50622b)
1895     /* FROZEN */
1896 ]
1897 interface nsIWindowWatcher : nsISupports
1898 {
1899     nsresult OpenWindow(nsIDOMWindow *aParent, const char *aUrl, const char *aName,
1900                         const char *aFeatures, nsISupports *aArguments, nsIDOMWindow **_retval);
1901     nsresult RegisterNotification(nsIObserver *aObserver);
1902     nsresult UnregisterNotification(nsIObserver *aObserver);
1903     nsresult GetWindowEnumerator(nsISimpleEnumerator **_retval);
1904     nsresult GetNewPrompter(nsIDOMWindow *aParent, nsIPrompt **_retval);
1905     nsresult GetNewAuthPrompter(nsIDOMWindow *aParent, nsIAuthPrompt **_retval);
1906     nsresult SetWindowCreator(nsIWindowCreator *creator);
1907     nsresult GetChromeForWindow(nsIDOMWindow *aWindow, nsIWebBrowserChrome **_retval);
1908     nsresult GetWindowByName(const PRUnichar *aTargetName, nsIDOMWindow *aCurrentWindow,
1909                              nsIDOMWindow **_retval);
1910     nsresult GetActiveWindow(nsIDOMWindow **aActiveWindow);
1911     nsresult SetActiveWindow(nsIDOMWindow *aActiveWindow);
1912 }
1913
1914 [
1915     object,
1916     uuid(d39fd2b4-3978-45d2-a4be-ba448171b61b)
1917     /* NOT_FROZEN */
1918 ]
1919 interface nsIEditingSession : nsISupports
1920 {
1921     nsresult GetEditorStatus(PRUint32 *aEditorStatus);
1922     nsresult MakeWindowEditable(nsIDOMWindow *window, const char *aEditorType,
1923                                 PRBool doAfterUriLoad);
1924     nsresult WindowIsEditable(nsIDOMWindow *window, PRBool *_retval);
1925     nsresult GetEditorForWindow(nsIDOMWindow *window, nsIEditor **_retval);
1926     nsresult SetupEditorOnWindow(nsIDOMWindow *window);
1927     nsresult TearDownEditorOnWindow(nsIDOMWindow *window);
1928     nsresult SetEditorOnControllers(nsIDOMWindow *aWindow, nsIEditor *aEditor);
1929 }
1930
1931 [
1932     object,
1933     uuid(83f892cf-7ed3-490e-967a-62640f3158e1)
1934     /* NOT_FROZEN */
1935 ]
1936 interface nsICommandParams : nsISupports
1937 {
1938     nsresult GetValueType(const char *name, PRInt16 *_retval);
1939     nsresult GetBooleanValue(const char *name, PRBool *_retval);
1940     nsresult GetLongValue(const char *name, PRInt32 *_retval);
1941     nsresult GetDoubleValue(const char *name, double *_retval);
1942     nsresult GetStringValue(const char *name, nsAString *_retval);
1943     nsresult GetCStringValue(const char *name, char **_retval);
1944     nsresult GetISupportsValue(const char *name, nsISupports **_retval);
1945     nsresult SetBooleanValue(const char *name, PRBool value);
1946     nsresult SetLongValue(const char *name, PRInt32 value);
1947     nsresult SetDoubleValue(const char *name, double value);
1948     nsresult SetStringValue(const char *name, const nsAString *value);
1949     nsresult SetCStringValue(const char *name, const char *value);
1950     nsresult SetISupportsValue(const char *name, nsISupports *value);
1951     nsresult RemoveValue(const char *name);
1952     nsresult HasMoreElements(PRBool *_retval);
1953     nsresult First();
1954     nsresult GetNext(char **_retval);
1955 }
1956
1957 [
1958     object,
1959     uuid(080d2001-f91e-11d4-a73c-f9242928207c)
1960     /* NOT_FROZEN */
1961 ]
1962 interface nsICommandManager : nsISupports
1963 {
1964     nsresult AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve);
1965     nsresult RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved);
1966     nsresult IsCommandSupported(const char *aCommandName, nsIDOMWindow *aTargetWindow, PRBool *_retval);
1967     nsresult IsCommandEnabled(const char *aCommandName, nsIDOMWindow *aTargetWindow, PRBool *_retval);
1968     nsresult GetCommandState(const char *aCommandName, nsIDOMWindow *aTargetWindow,
1969             nsICommandParams *aCommandParams);
1970     nsresult DoCommand(const char *aCommandName, nsICommandParams *aCommandParams,
1971             nsIDOMWindow *aTargetWindow);
1972 }
1973
1974 [
1975     object,
1976     uuid(47b82b60-a36f-4167-8072-6f421151ed50)
1977     /* NOT_FROZEN */
1978 ]
1979 interface nsIControllerContext : nsISupports
1980 {
1981     nsresult Init(nsIControllerCommandTable *aCommandTable);
1982     nsresult SetCommandContext(nsISupports *aCommandContext);
1983 }
1984
1985 [
1986     object,
1987     uuid(d5b61b82-1da4-11d3-bf87-00105a1b0627)
1988     /* NOT_FROZEN */
1989 ]
1990 interface nsIController : nsISupports
1991 {
1992     nsresult IsCommandEnabled(const char *command, PRBool *_retval);
1993     nsresult SupportsCommand(const char *command, PRBool *_retval);
1994     nsresult DoCommand(const char *command);
1995     nsresult OnEvent(const char *eventName);
1996 }
1997
1998 [
1999     object,
2000     uuid(d650439a-ca29-410d-a906-b0557fb62fcd)
2001     /* NOT_FROZEN */
2002 ]
2003 interface nsIContentSerializer : nsISupports
2004 {
2005     nsresult Init(PRUint32 flags, PRUint32 aWrapColumn, const char* aCharSet, PRBool aIsCopying);
2006     nsresult AppendText(nsIDOMText *aText, PRInt32 aStartOffset, PRInt32 aEndOffset, nsAString *aStr);
2007     nsresult AppendCDATASection(nsIDOMCDATASection *aCDATASection, PRInt32 aStartOffset,
2008             PRInt32 aEndOffset, nsAString *aStr);
2009     nsresult AppendProcessingInstruction(nsIDOMProcessingInstruction* aPI, PRInt32 aStartOffset,
2010             PRInt32 aEndOffset, nsAString *aStr);
2011     nsresult AppendComment(nsIDOMComment *aComment, PRInt32 aStartOffset, PRInt32 aEndOffset,
2012             nsAString *aStr);
2013     nsresult AppendDoctype(nsIDOMDocumentType *aDoctype, nsAString *aStr);
2014     nsresult AppendElementStart(nsIDOMElement *aElement, PRBool aHasChildren, nsAString *aStr);
2015     nsresult AppendElementEnd(nsIDOMElement *aElement, nsAString *aStr);
2016     nsresult Flush(nsAString *aStr);
2017     nsresult AppendDocumentStart(nsIDOMDocument *aDocument, nsAString *aStr);
2018 }
2019
2020 [
2021     object,
2022     uuid(68b97c56-2289-48ac-a9e1-72c30fd3dba2)
2023 ]
2024 interface nsIScriptContainer : nsISupports
2025 {
2026     typedef void *JSObject;
2027
2028     nsresult GetContext(void **aContext);
2029     nsresult GetGlobalObject(void **aGlobalObject);
2030     nsresult CompileScript(const PRUnichar *aText, PRInt32 aTextLength, void *aScopeObject,
2031             nsIPrincipal *aPrincipal, const char *aURL, PRUint32 aLineNo, PRUint32 aVersion, void **_retval);
2032     nsresult ExecuteScript(void *aScriptObject, void *aScopeObject, nsAString *aRetVal, PRBool *aIsUndefined);
2033     nsresult CompileFunction(void *aTarget, const nsACString *aName, PRUint32 aArgCount,
2034             const char **aArgArray, const nsAString *aBody, const char *aURL, PRInt32 aLineNo,
2035             PRBool aShared, void* *_retval);
2036     nsresult CallFunction(nsISupports *aTarget, void *aScope, void *aHandler, nsIArray *argv,
2037             nsIVariant **_retval);
2038     nsresult BindEventHandler(nsISupports *aTarget, void *aScope, nsIAtom *aName, void *aHandler);
2039     nsresult HoldScriptObject(void *aObject);
2040     nsresult DropScriptObject(void *aObject);
2041 }
2042
2043 [
2044     object,
2045     uuid(D4882FFB-E927-408b-96BE-D4391B456FA9)
2046 ]
2047 interface nsIEditor  : nsISupports
2048 {
2049     typedef void *nsIPresShellPtr;
2050     typedef void *nsIContentPtr;
2051
2052     nsresult GetSelection([out] nsISelection *_retval);
2053     nsresult Init([in] nsIDOMDocument *doc, [in] nsIPresShellPtr shell, [in] nsIContentPtr aRoot, [in] nsISelectionController *aSelCon, [in] PRUint32 aFlags);
2054     nsresult SetAttributeOrEquivalent([in] nsIDOMElement *element, [in] const nsAString *sourceAttrName, [in] const nsAString *sourceAttrValue, [in] PRBool aSuppressTransaction);
2055     nsresult RemoveAttributeOrEquivalent([in] nsIDOMElement *element, [in] const nsAString *sourceAttrName, [in] PRBool aSuppressTransaction);
2056     nsresult PostCreate();
2057     nsresult PreDestroy();
2058     nsresult GetFlags([out] PRUint32 *_retval);
2059     nsresult SetFlags([in] PRUint32 val);
2060     nsresult GetContentsMIMEType([out] char **_retval);
2061     nsresult SetContentsMIMEType([in] const char *val);
2062     nsresult GetIsDocumentEditable([out] PRBool *_retval);
2063     nsresult GetDocument([out] nsIDOMDocument **_retval);
2064     nsresult GetRootElement([out] nsIDOMElement **_retval);
2065     nsresult GetSelectionController([out] nsISelectionController **_retval);
2066     nsresult DeleteSelection([in] PRInt16 action);
2067     nsresult GetDocumentIsEmpty([out] PRBool *_retval);
2068     nsresult GetDocumentModified([out] PRBool *_retval);
2069     nsresult GetDocumentCharacterSet([out] nsACString *_retval);
2070     nsresult SetDocumentCharacterSet([in] const nsACString *val);
2071     nsresult ResetModificationCount();
2072     nsresult GetModificationCount([out] PRInt32 *_retval);
2073     nsresult IncrementModificationCount([in] long aModCount);
2074     nsresult GetTransactionManager([out] nsITransactionManager **_retval);
2075     nsresult DoTransaction([in] nsITransaction *txn);
2076     nsresult EnableUndo([in] PRBool enable);
2077     nsresult Undo([in] PRUint32 count);
2078     nsresult CanUndo([out] PRBool *isEnabled, [out] PRBool *canUndo);
2079     nsresult Redo([in] PRUint32 count);
2080     nsresult CanRedo([out] PRBool *isEnabled, [out] PRBool *canRedo);
2081     nsresult BeginTransaction();
2082     nsresult EndTransaction();
2083     nsresult BeginPlaceHolderTransaction([in] nsIAtom *name);
2084     nsresult EndPlaceHolderTransaction();
2085     nsresult ShouldTxnSetSelection([out] PRBool *_retval);
2086     nsresult SetShouldTxnSetSelection([in] PRBool should);
2087     nsresult GetInlineSpellChecker([out] nsIInlineSpellChecker **_retval);
2088     nsresult Cut();
2089     nsresult CanCut([out] PRBool *_retval);
2090     nsresult Copy();
2091     nsresult CanCopy([out] PRBool *_retval);
2092     nsresult Paste([in] PRInt32 aSelectionType);
2093     nsresult CanPaste([in] PRInt32 aSelectionType, [out] PRBool *_retval);
2094     nsresult SelectAll();
2095     nsresult BeginningOfDocument();
2096     nsresult EndOfDocument();
2097     nsresult CanDrag([in] nsIDOMEvent *aEvent, [out] PRBool *_retval);
2098     nsresult DoDrag([in] nsIDOMEvent *aEvent);
2099     nsresult InsertFromDrop([in] nsIDOMEvent *aEvent);
2100     nsresult SetAttribute([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [in] const nsAString *attvalue);
2101     nsresult GetAttributeValue([in] nsIDOMElement *aElement, [in] const nsAString *attributestr, [out] nsAString *resultValue, PRBool *_retval);
2102     nsresult RemoveAttribute([in] nsIDOMElement *aElement, [in] const nsAString *aAttribute);
2103     nsresult CloneAttribute([in] const nsAString *aAttribute, [in] nsIDOMNode *aDestNode, [in] nsIDOMNode *aSourceNode);
2104     nsresult CloneAttributes([in] nsIDOMNode *destNode, [in] nsIDOMNode *sourceNode);
2105     nsresult CreateNode([in] const nsAString *tag, [in] nsIDOMNode parent, [in] PRInt32 position, [out] nsIDOMNode **_retval);
2106     nsresult InsertNode([in] nsIDOMNode *node, [in] nsIDOMNode *parent, [in] PRInt32 aPosition);
2107     nsresult SplitNode([in] nsIDOMNode *existingRightNode, [in] PRInt32 offset, [out] nsIDOMNode **newLeftNode);
2108     nsresult JoinNodes([in] nsIDOMNode *leftNode, [in] nsIDOMNode *rightNode, [in] nsIDOMNode *parent);
2109     nsresult DeleteNode([in] nsIDOMNode *child);
2110     nsresult MarkNodeDirty([in] nsIDOMNode *node);
2111     nsresult SwitchTextDirection();
2112     nsresult OutputToString([in] nsAString formatType, [in] PRUint32 flags, [out] nsAString *_retval);
2113     nsresult OutputToStream([in] nsIOutputStream *aStream, [in] nsAString *formatType, [in] nsACString *charsetOverride, [in] PRUint32 flags);
2114     nsresult AddEditorObserver([in] nsIEditorObserver *observer);
2115     nsresult RemoveEditorObserver([in] nsIEditorObserver *observer);
2116     nsresult AddEditActionListener([in] nsIEditActionListener *listener);
2117     nsresult RemoveEditActionListener([in] nsIEditActionListener *listener);
2118     nsresult AddDocumentStateListener([in] nsIDocumentStateListener *listener);
2119     nsresult RemoveDocumentStateListener([in] nsIDocumentStateListener *listener);
2120     nsresult DumpContentTree();
2121     nsresult DebugDumpContent();
2122     nsresult DebugUnitTests([out] PRInt32 *outNumTests, [out] PRInt32 *outNumTestsFailed);
2123 }
2124
2125 [
2126     object,
2127     uuid(afc36593-5787-4420-93d9-b2c0ccbf0cad)
2128 ]
2129 interface nsIHTMLEditor : nsISupports
2130 {
2131     nsresult AddDefaultProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
2132     nsresult RemoveDefaultProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
2133     nsresult RemoveAllDefaultProperties();
2134     nsresult SetCSSInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
2135     nsresult SetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue);
2136     nsresult GetInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue, [out] PRBool *aFirst, [out] PRBool *aAny, [out] PRBool *aAll);
2137     nsresult GetInlinePropertyWithAttrValue([in] nsIAtom *aProperty, [in] nsAString *aAttribute, [in] nsAString *aValue, [out] PRBool *aFirst, [out] PRBool *aAny, [out] PRBool *aAll, [out] nsAString *_retval);
2138     nsresult RemoveAllInlineProperties();
2139     nsresult RemoveInlineProperty([in] nsIAtom *aProperty, [in] nsAString *aAttribute);
2140     nsresult IncreaseFontSize();
2141     nsresult DecreaseFontSize();
2142     nsresult CanDrag([in] nsIDOMEvent *aEvent, [out] PRBool *_retval);
2143     nsresult DoDrag([in] nsIDOMEvent *aEvent);
2144     nsresult InsertFromDrop([in] nsIDOMEvent *aEvent);
2145     nsresult NodeIsBlock([in] nsIDOMNode *node, PRBool *_retval);
2146     nsresult InsertHTML([in] nsAString *aInputString);
2147     nsresult PasteNoFormatting([in] PRInt32 aSelectionType);
2148     nsresult RebuildDocumentFromSource([in] nsAString *aSourceString);
2149     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);
2150     nsresult InsertElementAtSelection([in] nsIDOMElement *aElement, [in] PRBool aDeleteSelection);
2151     nsresult SetDocumentTitle([in] nsAString *aTitle);
2152     nsresult UpdateBaseURL();
2153     nsresult SelectElement([in] nsIDOMElement *aElement);
2154     nsresult SetCaretAfterElement([in] nsIDOMElement *aElement);
2155     nsresult SetParagraphFormat([in] nsAString *aParagraphFormat);
2156     nsresult GetParagraphState([out] PRBool *aMixed, [out] nsAString *_retval);
2157     nsresult GetFontFaceState([out] PRBool *aMixed, [out] nsAString *_retval);
2158     nsresult GetFontColorState([out] PRBool *aMixed, [out] nsAString *_retval);
2159     nsresult GetBackgroundColorState([out] PRBool *aMixed, [out] nsAString *_retval);
2160     nsresult GetHighlightColorState([out] PRBool *aMixed, [out] nsAString *_retval);
2161     nsresult GetListState([out] PRBool *aMixed, [out] PRBool *aOL, [out] PRBool *aUL, [out] PRBool *aDL);
2162     nsresult GetListItemState([out] PRBool *aMixed, [out] PRBool *aLI, [out] PRBool *aDT, [out] PRBool *aDD);
2163     nsresult GetAlignment([out] PRBool *aMixed, [out] PRInt16 *aAlign);
2164     nsresult GetIndentState([out] PRBool *aCanIndent, [out] PRBool *aCanOutdent);
2165     nsresult MakeOrChangeList([in] nsAString *aListType, [in] PRBool entireList, [in] nsAString *aBulletType);
2166     nsresult RemoveList([in] nsAString *aListType);
2167     nsresult Indent([in] nsAString *aIndent);
2168     nsresult Align([in] nsAString *aAlign);
2169     nsresult GetElementOrParentByTagName([in] nsAString *aTagName, [in] nsIDOMNode *aNode, [out] nsIDOMElement **_retval);
2170     nsresult GetSelectedElement([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
2171     nsresult GetHeadContentsAsHTML([out] nsAString *_retval);
2172     nsresult ReplaceHeadContentsWithHTML([in] nsAString *aSourceToInsert);
2173     nsresult CreateElementWithDefaults([in] nsAString *aTagName, [out] nsIDOMElement **_retval);
2174     nsresult InsertLinkAroundSelection([in] nsIDOMElement *aAnchorElement);
2175     nsresult SetBackgroundColor([in] nsAString *aColor);
2176     nsresult SetBodyAttribute([in] nsAString *aAttr, [in] nsAString *aValue);
2177     nsresult IgnoreSpuriousDragEvent([in] PRBool aIgnoreSpuriousDragEvent);
2178     nsresult GetLinkedObjects([out] nsISupportsArray **_retval);
2179     nsresult GetIsCSSEnabled([out] PRBool *_retval);
2180     nsresult SetIsCSSEnabled([in] PRBool prb);
2181     nsresult AddInsertionListener([in] nsIContentFilter *inFilter);
2182     nsresult RemoveInsertionListener([in] nsIContentFilter *inFilter);
2183     nsresult CreateAnonymousElement([in] nsAString *aTag, [in] nsIDOMNode *aParentNode, [in] nsAString *aAnonClass, [in] PRBool aIsCreatedHidden, [out] nsIDOMElement **_retval);
2184     nsresult GetSelectionContainer([out] nsIDOMElement **_retval);
2185     nsresult CheckSelectionStateForAnonymousButtons([in] nsISelection *aSelection);
2186     nsresult IsAnonymousElement([in] nsIDOMElement *aElement, [out] PRBool *_retval);
2187     nsresult GetReturnInParagraphCreatesNewParagraph([out] PRBool *_retval);
2188     nsresult SetReturnInParagraphCreatesNewParagraph([in] PRBool prb);
2189 }
2190
2191 /*
2192  * NOTE:
2193  * This is a private Wine interface that is implemented by our implementation
2194  * of nsIURI to store its owner.
2195  */
2196 [
2197     object,
2198     uuid(5088272e-900b-11da-c687-000fea57f21a)
2199     /* INTERNAL */
2200 ]
2201 interface nsIWineURI : nsIURI
2202 {
2203     typedef struct NSContainer NSContainer;
2204
2205     nsresult GetNSContainer(NSContainer **aNSContainer);
2206     nsresult SetNSContainer(NSContainer *aNSContainer);
2207     nsresult GetIsDocumentURI(PRBool *aIsDocumentURI);
2208     nsresult SetIsDocumentURI(PRBool aIsDocumentURI);
2209     nsresult GetWineURL(LPCWSTR *aURL);
2210     nsresult SetWineURL(LPCWSTR aURL);
2211 }