git.oblomov.eu Git - wine/blob - dlls/mshtml/nsiface.idl

   1 /*
   2  * Copyright 2005-2006 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 import "wtypes.idl";
  27
  28 typedef HRESULT nsresult;
  29 typedef ULONG nsrefcnt;
  30
  31 typedef IID nsIID;
  32 typedef nsIID nsCID;
  33 typedef REFIID nsIIDRef;
  34 typedef nsIIDRef nsCIDRef;
  35
  36 typedef void** nsQIResult;
  37 typedef WCHAR PRUnichar;
  38 typedef ULONG PRUint32;
  39 typedef LONG PRInt32;
  40 typedef WORD PRUint16;
  41 typedef INT16 PRInt16;
  42 typedef BYTE PRUint8;
  43 typedef BOOL PRBool;
  44 typedef LARGE_INTEGER PRInt64;
  45 typedef ULARGE_INTEGER PRUint64;
  46 typedef PRUint64 DOMTimeStamp;
  47 typedef PRUint32 nsLoadFlags;
  48
  49 typedef struct {
  50     void *v;
  51     void *d1;
  52     PRUint32 d2;
  53     void *d3;
  54 } nsCStringContainer;
  55
  56 typedef struct {
  57     void *v;
  58     void *d1;
  59     PRUint32 d2;
  60     void *d3;
  61 } nsStringContainer;
  62
  63 typedef nsCStringContainer nsACString;
  64 typedef nsStringContainer nsAString;
  65
  66 interface nsIWebBrowserChrome;
  67 interface nsILoadGroup;
  68 interface nsIDOMNode;
  69 interface nsIDOMDocument;
  70 interface nsIDOMEvent;
  71
  72 interface IMoniker;
  73
  74 [
  75     object,
  76     uuid(00000000-0000-0000-c000-000000000046)
  77 ]
  78 interface nsISupports
  79 {
  80     nsresult QueryInterface(nsIIDRef riid, nsQIResult result);
  81     nsrefcnt AddRef();
  82     nsrefcnt Release();
  83 }
  84
  85 /* Currently we don't need a full declaration of these interfaces */
  86 typedef nsISupports nsISHistory;
  87 typedef nsISupports nsISimpleEnumerator;
  88 typedef nsISupports nsIWidget;
  89 typedef nsISupports nsIDOMAbstractView;
  90 typedef nsISupports nsIHttpHeaderVisitor;
  91 typedef nsISupports nsIDOMBarProp;
  92 typedef nsISupports nsIDOMWindowCollection;
  93 typedef nsISupports nsIPrompt;
  94 typedef nsISupports nsIAuthPrompt;
  95 typedef nsISupports nsIDOMNamedNodeMap;
  96 typedef nsISupports nsIDOMAttr;
  97 typedef nsISupports nsIDOMDocumentType;
  98 typedef nsISupports nsIDOMDOMImplementation;
  99 typedef nsISupports nsIDOMComment;
 100 typedef nsISupports nsIDOMCDATASection;
 101 typedef nsISupports nsIDOMProcessingInstruction;
 102 typedef nsISupports nsIDOMEntityReference;
 103 typedef nsISupports nsIDOMHTMLFormElement;
 104 typedef nsISupports nsIDOMHTMLOptionsCollection;
 105 typedef nsISupports nsIDOMHTMLCollection;
 106 typedef nsISupports nsIEditor;
 107 typedef nsISupports nsIWebProgressListener;
 108 typedef nsISupports nsIDOMCSSValue;
 109 typedef nsISupports nsIDOMCSSRule;
 110 typedef nsISupports nsIPrintSession;
 111
 112 [
 113     object,
 114     uuid(8bb35ed9-e332-462d-9155-4a002ab5c958)
 115     /* FROZEN */
 116 ]
 117 interface nsIServiceManager : nsISupports
 118 {
 119     nsresult GetService(nsCIDRef aClass, nsIIDRef aIID, void **result);
 120     nsresult GetServiceByContactID(const char *aContactID, nsIIDRef aIID, void **result);
 121     nsresult IsServiceInstantiated(nsCIDRef aClass, nsIIDRef aIID, BOOL *_retval);
 122     nsresult IsServiceInstantiatedByContractID(const char *aContractID, nsIIDRef aIID, BOOL *_retval);
 123 }
 124
 125 [
 126     object,
 127     uuid(00000001-0000-0000-c000-000000000046)
 128     /* FROZEN */
 129 ]
 130 interface nsIFactory : nsISupports
 131 {
 132     nsresult CreateInstance(nsISupports *aOuter, const nsIID *iid, void **result);
 133     nsresult LockFactory(PRBool lock);
 134 }
 135
 136 [
 137     object,
 138     uuid(db242e01-e4d9-11d2-9dde-000064657374)
 139     /* FROZEN */
 140 ]
 141 interface nsIObserver : nsISupports
 142 {
 143     nsresult Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData);
 144 }
 145
 146 [
 147     object,
 148     uuid(a88e5a60-205a-4bb1-94e1-2628daf51eae)
 149     /* FROZEN */
 150 ]
 151 interface nsIComponentManager : nsISupports
 152 {
 153     nsresult GetClassObject(nsCIDRef aClass, nsIIDRef aIID, nsQIResult result);
 154     nsresult GetClassObjectByContractID(const char *aContractID, nsIIDRef aIID, nsQIResult result);
 155     nsresult CreateInstance(nsCIDRef aClass, nsISupports *aDelegate, nsIIDRef aIID,
 156             nsQIResult result);
 157     nsresult CreateInstanceByContractID(const char *aContractID, nsISupports *aDelegate,
 158             nsIIDRef aIID, nsQIResult result);
 159 }
 160
 161 [
 162     object,
 163     uuid(59e7e77a-38e4-11d4-8cf5-0060b0fc14a3)
 164     /* FROZEN */
 165 ]
 166 interface nsIMemory : nsISupports
 167 {
 168     void *Alloc(/*size_t*/ int size);
 169     void *Realloc(void *_ptr, /*size_t*/ int newSize);
 170     void Free(void *_ptr);
 171     nsresult HeapMinimize(PRBool immediate);
 172     nsresult IsLowMemory(PRBool *_retval);
 173 }
 174
 175 [
 176     object,
 177     uuid(9188bc85-f92e-11d2-81ef-0060083a0bcf)
 178     /* FROZEN */
 179 ]
 180 interface nsIWeakReference : nsISupports
 181 {
 182     nsresult QueryReferent(const nsIID *riid, void **result);
 183 }
 184
 185 [
 186     object,
 187     uuid(9188bc86-f92e-11d2-81ef-0060083a0bcf)
 188     /* FROZEN */
 189 ]
 190 interface nsISupportsWeakReference : nsISupports
 191 {
 192     nsresult GetWeakReference(nsIWeakReference **_retval);
 193 }
 194
 195 [
 196     object,
 197     uuid(033a1470-8b2a-11d3-af88-00a024ffc08c)
 198     /* FROZEN */
 199 ]
 200 interface nsIInterfaceRequestor : nsISupports
 201 {
 202     nsresult GetInterface(const nsIID *riid, void **result);
 203 }
 204
 205 [
 206     object,
 207     uuid(fa9c7f6c-61b3-11d4-9877-00c04fa0cf4a)
 208     /* FROZEN */
 209 ]
 210 interface nsIInputStream : nsISupports
 211 {
 212     nsresult Close();
 213     nsresult Available(PRUint32 *_retval);
 214     nsresult Read(char *aBuf, PRUint32 aCount, PRUint32 *_retval);
 215     nsresult ReadSegments(nsresult (*aWriter)(nsIInputStream *aInStream,
 216             void *aClosure, const char *aFromSegment, PRUint32 aToOffset,
 217             PRUint32 aCount, PRUint32 *aWriteCount),
 218             void *aClosure, PRUint32 aCount, PRUint32 *_retval);
 219     nsresult IsNonBlocking(PRBool *_retval);
 220 }
 221
 222 [
 223     object,
 224     uuid(450cd2d4-f0fd-424d-b365-b1251f80fd53)
 225     /* NOT_FROZEN */
 226 ]
 227 interface nsIStringInputStream : nsIInputStream
 228 {
 229     nsresult SetData(const char *data, PRInt32 dataLen);
 230     nsresult AdoptData(char *data, PRInt32 dataLen);
 231     nsresult ShareData(const char *data, PRInt32 dataLen);
 232 }
 233
 234 [
 235     object,
 236     uuid(07a22cc0-0ce5-11d3-9331-00104ba0fd40)
 237     /* FROZEN */
 238 ]
 239 interface nsIURI : nsISupports
 240 {
 241     nsresult GetSpec(nsACString *aSpec);
 242     nsresult SetSpec(const nsACString *aSpec);
 243     nsresult GetPrePath(nsACString *aPrePath);
 244     nsresult GetScheme(nsACString *aScheme);
 245     nsresult SetScheme(const nsACString *aScheme);
 246     nsresult GetUserPass(nsACString *aUserPass);
 247     nsresult SetUserPass(const nsACString *aUserPass);
 248     nsresult GetUsername(nsACString *aUsername);
 249     nsresult SetUsername(const nsACString *aUsername);
 250     nsresult GetPassword(nsACString *aPassword);
 251     nsresult SetPassword(const nsACString *aPassword);
 252     nsresult GetHostPort(nsACString *aHostPort);
 253     nsresult SetHostPort(const nsACString *aHostPort);
 254     nsresult GetHost(nsACString *aHost);
 255     nsresult SetHost(const nsACString *aHost);
 256     nsresult GetPort(PRInt32 *aPort);
 257     nsresult SetPort(PRInt32 aPort);
 258     nsresult GetPath(nsACString *aPath);
 259     nsresult SetPath(const nsACString *aPath);
 260     nsresult Equals(nsIURI *other, PRBool *_retval);
 261     nsresult SchemeIs(const char *scheme, PRBool *_retval);
 262     nsresult Clone(nsIURI **_retval);
 263     nsresult Resolve(const nsACString *relativePath, nsACString *_retval);
 264     nsresult GetAsciiSpec(nsACString *aAsciiSpec);
 265     nsresult GetAsciiHost(nsACString *aAsciiHost);
 266     nsresult GetOriginCharset(nsACString *aOriginCharset);
 267 }
 268
 269 [
 270     object,
 271     uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe)
 272     /* FROZEN */
 273 ]
 274 interface nsIRequest : nsISupports
 275 {
 276     nsresult GetName(nsACString *aName);
 277     nsresult IsPending(PRBool *_retval);
 278     nsresult GetStatus(nsresult *aStatus);
 279     nsresult Cancel(nsresult aStatus);
 280     nsresult Suspend();
 281     nsresult Resume();
 282     nsresult GetLoadGroup(nsILoadGroup **aLoadGroup);
 283     nsresult SetLoadGroup(nsILoadGroup *aLoadGroup);
 284     nsresult GetLoadFlags(nsLoadFlags *aLoadFlags);
 285     nsresult SetLoadFlags(nsLoadFlags aLoadFlags);
 286 }
 287
 288 [
 289     object,
 290     uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40)
 291     /* FROZEN */
 292 ]
 293 interface nsIRequestObserver : nsISupports
 294 {
 295     nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext);
 296     nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode);
 297 }
 298
 299 [
 300     object,
 301     uuid(1a637020-1482-11d3-9333-00104ba0fd40)
 302     /* FROZEN */
 303 ]
 304 interface nsIStreamListener : nsIRequestObserver
 305 {
 306     nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
 307                              nsIInputStream *aInputStream, PRUint32 aOffset, PRUint32 aCount);
 308 }
 309
 310 [
 311     object,
 312     uuid(3de0a31c-feaf-400f-9f1e-4ef71f8b20cc)
 313     /* FROZEN */
 314 ]
 315 interface nsILoadGroup : nsIRequest
 316 {
 317     nsresult GetGroupObserver(nsIRequestObserver **aGroupObserver);
 318     nsresult SetGroupObserver(nsIRequestObserver *aGroupObserver);
 319     nsresult GetDefaultLoadRequest(nsIRequest **aDefaultLoadRequest);
 320     nsresult SetDefaultLoadRequest(nsIRequest *aDefaultLoadRequest);
 321     nsresult AddRequest(nsIRequest *aRequest, nsISupports *aContext);
 322     nsresult RemoveRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatus);
 323     nsresult GetRequests(nsISimpleEnumerator **aRequests);
 324     nsresult GetActiveCount(PRUint32 *aActiveCount);
 325     nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
 326     nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
 327 }
 328
 329 [
 330     object,
 331     uuid(c63a055a-a676-4e71-bf3c-6cfa11082018)
 332     /* FROZEN */
 333 ]
 334 interface nsIChannel : nsIRequest
 335 {
 336     nsresult GetOriginalURI(nsIURI **aOriginalURI);
 337     nsresult SetOriginalURI(nsIURI *aOriginalURI);
 338     nsresult GetURI(nsIURI **aURI);
 339     nsresult GetOwner(nsISupports **aOwner);
 340     nsresult SetOwner(nsISupports *aOwner);
 341     nsresult GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
 342     nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
 343     nsresult GetSecurityInfo(nsISupports **aSecurityInfo);
 344     nsresult GetContentType(nsACString *aContentType);
 345     nsresult SetContentType(const nsACString *aContentType);
 346     nsresult GetContentCharset(nsACString *aContentCharset);
 347     nsresult SetContentCharset(const nsACString *aContentCharset);
 348     nsresult GetContentLength(PRInt32 *aContentLength);
 349     nsresult SetContentLength(PRInt32 aContentLength);
 350     nsresult Open(nsIInputStream **_retval);
 351     nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext);
 352 }
 353
 354 [
 355     object,
 356     uuid(9277fe09-f0cc-4cd9-bbce-581dd94b0260)
 357     /* FROZEN */
 358 ]
 359 interface nsIHttpChannel : nsIChannel
 360 {
 361     nsresult GetRequestMethod(nsACString *aRequestMethod);
 362     nsresult SetRequestMethod(const nsACString *aRequestMethod);
 363     nsresult GetReferrer(nsIURI **aReferrer);
 364     nsresult SetReferrer(nsIURI *aReferrer);
 365     nsresult GetRequestHeader(const nsACString *aHeader, nsACString *_retval);
 366     nsresult SetRequestHeader(const nsACString *aHeader, const nsACString *aValue, PRBool aMerge);
 367     nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor);
 368     nsresult GetAllowPipelining(PRBool *aAllowPipelining);
 369     nsresult SetAllowPipelining(PRBool aAllowPipelining);
 370     nsresult GetRedirectionLimit(PRUint32 *aRedirectionLimit);
 371     nsresult SetRedirectionLimit(PRUint32 aRedirectionLimit);
 372     nsresult GetResponseStatus(PRUint32 *aResponseStatus);
 373     nsresult GetResponseStatusText(nsACString *aResponseStatusText);
 374     nsresult GetRequestSucceeded(PRBool *aRequestSucceeded);
 375     nsresult GetResponseHeader(const nsACString *header, nsACString *_retval);
 376     nsresult SetResponseHeader(const nsACString *header, const nsACString *value, PRBool merge);
 377     nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor);
 378     nsresult IsNoStoreResponse(PRBool *_retval);
 379     nsresult IsNoCacheResponse(PRBool *_retval);
 380 }
 381
 382 [
 383     object,
 384     uuid(ddf633d8-e9a4-439d-ad88-de636fd9bb75)
 385     /* FROZEN */
 386 ]
 387 interface nsIUploadChannel : nsISupports
 388 {
 389     nsresult SetUploadStream(nsIInputStream *aStream, const nsACString *aContentType,
 390                              PRInt32 aContentLength);
 391     nsresult GetUploadStream(nsIInputStream **aUploadStream);
 392 }
 393
 394 [
 395     object,
 396     uuid(a6cf90be-15b3-11d2-932e-00805f8add32)
 397     /* FROZEN */
 398 ]
 399 interface nsIDOMCSSStyleDeclaration : nsISupports
 400 {
 401     nsresult GetCssText(nsAString *aCssText);
 402     nsresult SetCssText(const nsAString *aCssText);
 403     nsresult GetPropertyValue(const nsAString *propertyName, nsAString *_retval);
 404     nsresult GetPropertyCSSValue(const nsAString *propertyName, nsIDOMCSSValue **_retval);
 405     nsresult RemoveProperty(const nsAString *propertyName, nsAString *_retval);
 406     nsresult GetPropertyPriority(const nsAString *propertyName, nsAString *_retval);
 407     nsresult SetProperty(const nsAString *propertyName, const nsAString *value,
 408                          const nsAString *priority);
 409     nsresult GetLength(PRUint32 *aLength);
 410     nsresult Item(PRUint32 index, nsAString *_retval);
 411     nsresult GetParentRule(nsIDOMCSSRule **aParentRule);
 412 }
 413
 414 [
 415     object,
 416     uuid(a6cf907d-15b3-11d2-932e-00805f8add32)
 417     /* FROZEN */
 418 ]
 419 interface nsIDOMNodeList : nsISupports
 420 {
 421     nsresult Item(PRUint32 index, nsIDOMNode **_retval);
 422     nsresult GetLength(PRUint32 *aLength);
 423 }
 424
 425 [
 426     object,
 427     uuid(a6cf907c-15b3-11d2-932e-00805f8add32)
 428     /* FROZEN */
 429 ]
 430 interface nsIDOMNode : nsISupports
 431 {
 432     enum NSNODETYPE {
 433         ELEMENT_NODE = 1,
 434         ATTRIBUTE_NODE = 2,
 435         TEXT_NODE = 3,
 436         CDATA_SELECTION_NODE = 4,
 437         ENTITY_REFERENCE_NODE = 5,
 438         ENTITY_NODE = 6,
 439         PROCESSING_INSTRUCTION_NODE = 7,
 440         COMMENT_NODE = 8,
 441         DOCUMENT_NODE = 9,
 442         DOCUMENT_TYPE_NODE = 10,
 443         DOCUMENT_FRAGMENT_NODE = 11,
 444         NOTATION_NODE = 12
 445     };
 446
 447     nsresult GetNodeName(nsAString *aNodeName);
 448     nsresult GetNodeValue(nsAString *aNodeValue);
 449     nsresult SetNodeValue(const nsAString *aNodeValue);
 450     nsresult GetNodeType(PRUint16 *aNodeType);
 451     nsresult GetParentNode(nsIDOMNode **aParentNode);
 452     nsresult GetChildNodes(nsIDOMNodeList **aChildNodes);
 453     nsresult GetFirstChild(nsIDOMNode **aFirstChild);
 454     nsresult GetLastChild(nsIDOMNode **aLastChild);
 455     nsresult GetPreviousSibling(nsIDOMNode **aPreviousSibling);
 456     nsresult GetNextSibling(nsIDOMNode **aNextSibling);
 457     nsresult GetAttributes(nsIDOMNamedNodeMap **aAttributes);
 458     nsresult GetOwnerDocument(nsIDOMDocument **aOwnerDocument);
 459     nsresult InsertBefore(nsIDOMNode *newChild, nsIDOMNode *refChild, nsIDOMNode **_retval);
 460     nsresult ReplaceChild(nsIDOMNode *newChild, nsIDOMNode *oldChild, nsIDOMNode **_retval);
 461     nsresult RemoveChild(nsIDOMNode *oldChild, nsIDOMNode **_retval);
 462     nsresult AppendChild(nsIDOMNode *newChild, nsIDOMNode **_retval);
 463     nsresult HasChildNodes(PRBool *_retval);
 464     nsresult CloneNode(PRBool deep, nsIDOMNode **_retval);
 465     nsresult Normalize();
 466     nsresult IsSupported(const nsAString *feature, const nsAString *version, PRBool *_retval);
 467     nsresult GetNamespaceURI(nsAString *aNamespaceURI);
 468     nsresult GetPrefix(nsAString *aPrefix);
 469     nsresult SetPrefix(const nsAString *aPrefix);
 470     nsresult GetLocalName(nsAString *aLocalName);
 471     nsresult HasAttributes(PRBool *_retval);
 472 }
 473
 474 [
 475     object,
 476     uuid(a6cf9078-15b3-11d2-932e-00805f8add32)
 477     /* FROZEN */
 478 ]
 479 interface nsIDOMElement : nsIDOMNode
 480 {
 481     nsresult GetTagName(nsAString *aTagName);
 482     nsresult GetAttribute(const nsAString *name, nsAString *_retval);
 483     nsresult SetAttribute(const nsAString *name, const nsAString *value);
 484     nsresult RemoveAttribute(const nsAString *name);
 485     nsresult GetAttributeNode(const nsAString *name, nsIDOMAttr **_retval);
 486     nsresult SetAttributeNode(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
 487     nsresult RemoveAttributeNode(nsIDOMAttr *oldAttr, nsIDOMAttr **_retval);
 488     nsresult GetElementsByTagName(const nsAString *name, nsIDOMNodeList **_retval);
 489     nsresult GetAttributeNS(const nsAString *namespaceURI, const nsAString *localName,
 490                             nsAString *_retval);
 491     nsresult SetAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 492                             const nsAString *value);
 493     nsresult RemoveAttributeNS(const nsAString *namespaceURI, const nsAString *localName);
 494     nsresult GetAttributeNodeNS(const nsAString *namespaceURI, const nsAString *localName,
 495                                 nsIDOMAttr **_retval);
 496     nsresult SetAttributeNodeNS(nsIDOMAttr *newAttr, nsIDOMAttr **_retval);
 497     nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName,
 498                                     nsIDOMNodeList **_retval);
 499     nsresult HasAttribute(const nsAString *name, PRBool *_retval);
 500     nsresult HasAttributeNS(const nsAString *namespaceURI, const nsAString *localName,
 501                             PRBool *_retval);
 502 }
 503
 504 [
 505     object,
 506     uuid(99715845-95fc-4a56-aa53-214b65c26e22)
 507     /* FROZEN */
 508 ]
 509 interface nsIDOMElementCSSInlineStyle : nsISupports
 510 {
 511     nsresult GetStyle(nsIDOMCSSStyleDeclaration **aStyle);
 512 }
 513
 514 cpp_quote("#undef GetClassName");
 515
 516 [
 517     object,
 518     uuid(a6cf9085-15b3-11d2-932e-00805f8add32)
 519     /* FROZEN */
 520 ]
 521 interface nsIDOMHTMLElement : nsIDOMElement
 522 {
 523     nsresult GetId(nsAString *aId);
 524     nsresult SetId(const nsAString *aId);
 525     nsresult GetTitle(nsAString *aTitle);
 526     nsresult SetTitle(const nsAString *aTitle);
 527     nsresult GetLang(nsAString *aLang);
 528     nsresult SetLang(const nsAString *aLang);
 529     nsresult GetDir(nsAString *aDir);
 530     nsresult SetDir(const nsAString *aDir);
 531     nsresult GetClassName(nsAString *aClassName);
 532     nsresult SetClassName(const nsAString *aClassName);
 533 }
 534
 535 [
 536     object,
 537     uuid(da83b2ec-8264-4410-8496-ada3acd2ae42)
 538     /* NOT_FROZEN */
 539 ]
 540 interface nsIDOMNSHTMLElement : nsISupports
 541 {
 542     nsresult GetOffsetTop(PRInt32 *aOffsetTop);
 543     nsresult GetOffsetLeft(PRInt32 *aOffsetLeft);
 544     nsresult GetOffsetWidth(PRInt32 *aOffsetWidth);
 545     nsresult GetOffsetHeight(PRInt32 *aOffsetHeight);
 546     nsresult GetOffsetParent(nsIDOMElement **aOffsetParent);
 547     nsresult GetInnerHTML(nsAString *aInnerHTML);
 548     nsresult SetInnerHTML(const nsAString *aInnerHTML);
 549     nsresult GetScrollTop(PRInt32 *aScrollTop);
 550     nsresult SetScrollTop(PRInt32 aScrollTop);
 551     nsresult GetScrollLeft(PRInt32 *aScrollLeft);
 552     nsresult SetScrollLeft(PRInt32 aScrollLeft);
 553     nsresult GetScrollHeight(PRInt32 *aScrollHeight);
 554     nsresult GetScrollWidth(PRInt32 *aScrollWidth);
 555     nsresult GetClientHeight(PRInt32 *aClientHeight);
 556     nsresult GetClientWidth(PRInt32 *aClientWidth);
 557     nsresult ScrollIntoView(PRBool top);
 558 }
 559
 560 [
 561     object,
 562     uuid(a6cf9072-15b3-11d2-932e-00805f8add32)
 563     /* FROZEN */
 564 ]
 565 interface nsIDOMCharacterData : nsIDOMNode
 566 {
 567     nsresult GetData(nsAString *aData);
 568     nsresult SetData(const nsAString *aData);
 569     nsresult GetLength(PRUint32 *aLength);
 570     nsresult SubstringData(PRUint32 offset, PRUint32 count, nsAString *_retval);
 571     nsresult AppendData(const nsAString *arg);
 572     nsresult InsertData(PRUint32 offset, const nsAString *arg);
 573     nsresult DeleteData(PRUint32 offset, PRUint32 count);
 574     nsresult ReplaceData(PRUint32 offset, PRUint32 count, const nsAString *arg);
 575 }
 576
 577 [
 578     object,
 579     uuid(a6cf9082-15b3-11d2-932e-00805f8add32)
 580     /* FROZEN */
 581 ]
 582 interface nsIDOMText : nsIDOMCharacterData
 583 {
 584     nsresult SplitText(PRUint32 offset, nsIDOMText **_retval);
 585 }
 586
 587 [
 588     object,
 589     uuid(a6cf9076-15b3-11d2-932e-00805f8add32)
 590     /* NOT_FROZEN */
 591 ]
 592 interface nsIDOMDocumentFragment : nsIDOMNode
 593 {
 594 }
 595
 596 [
 597     object,
 598     uuid(a6cf9075-15b3-11d2-932e-00805f8add32)
 599     /* FROZEN */
 600 ]
 601 interface nsIDOMDocument : nsIDOMNode
 602 {
 603     nsresult GetDoctype(nsIDOMDocumentType **aDoctype);
 604     nsresult GetImplementation(nsIDOMDOMImplementation **aImplementation);
 605     nsresult GetDocumentElement(nsIDOMElement **aDocumentElement);
 606     nsresult CreateElement(const nsAString *tagName, nsIDOMElement **_retval);
 607     nsresult CreateDocumentFragment(nsIDOMDocumentFragment **_retval);
 608     nsresult CreateTextNode(const nsAString *data, nsIDOMText **_retval);
 609     nsresult CreateComment(const nsAString *data, nsIDOMComment **_retval);
 610     nsresult CreateCDATASection(const nsAString *data, nsIDOMCDATASection **_retval);
 611     nsresult CreateProcessingInstruction(const nsAString *target, const nsAString *data,
 612                                          nsIDOMProcessingInstruction **_retval);
 613     nsresult CreateAttribute(const nsAString *name, nsIDOMAttr **_retval);
 614     nsresult CreateEntityReference(const nsAString *name, nsIDOMEntityReference **_retval);
 615     nsresult GetElementsByTagName(const nsAString *tagname, nsIDOMNodeList **_retval);
 616     nsresult ImportNode(nsIDOMNode *importedNode, PRBool deep, nsIDOMNode **_retval);
 617     nsresult CreateElementNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 618                              nsIDOMElement **_retval);
 619     nsresult CreateAttributeNS(const nsAString *namespaceURI, const nsAString *qualifiedName,
 620                                nsIDOMAttr **_retval);
 621     nsresult GetElementsByTagNameNS(const nsAString *namespaceURI, const nsAString *localName,
 622                                     nsIDOMNodeList **_retval);
 623     nsresult GetElementById(const nsAString *elementId, nsIDOMElement **_retval);
 624 }
 625
 626 [
 627     object,
 628     uuid(a6cf9084-15b3-11d2-932e-00805f8add32)
 629     /* FROZEN */
 630 ]
 631 interface nsIDOMHTMLDocument : nsIDOMDocument
 632 {
 633     nsresult GetTitle(nsAString *aTitle);
 634     nsresult SetTitle(const nsAString *aTitle);
 635     nsresult GetReferrer(nsAString *aReferrer);
 636     nsresult GetDomain(nsAString *aDomain);
 637     nsresult GetURL(nsAString *aURL);
 638     nsresult GetBody(nsIDOMHTMLElement **aBody);
 639     nsresult SetBody(nsIDOMHTMLElement *aBody);
 640     nsresult GetImages(nsIDOMHTMLCollection **aImages);
 641     nsresult GetApplets(nsIDOMHTMLCollection **aApplets);
 642     nsresult GetLinks(nsIDOMHTMLCollection **aLinks);
 643     nsresult GetForms(nsIDOMHTMLCollection **aForms);
 644     nsresult GetAnchors(nsIDOMHTMLCollection **aAnchors);
 645     nsresult GetCookie(nsAString *aCookie);
 646     nsresult SetCookie(const nsAString *aCookie);
 647     nsresult Open();
 648     nsresult Close();
 649     nsresult Write(const nsAString *text);
 650     nsresult Writeln(const nsAString *text);
 651     nsresult GetElementsByName(const nsAString *elementName, nsIDOMNodeList **_retval);
 652 }
 653
 654 [
 655     object,
 656     uuid(a6cf90ce-15b3-11d2-932e-00805f8add32)
 657     /* FROZEN */
 658 ]
 659 interface nsIDOMRange : nsISupports
 660 {
 661     nsresult GetStartContainer(nsIDOMNode **aStartContainer);
 662     nsresult GetStartOffset(PRInt32 *aStartOffset);
 663     nsresult GetEndContainer(nsIDOMNode **aEndContainer);
 664     nsresult GetEndOffset(PRInt32 *aEndOffset);
 665     nsresult GetCollapsed(PRBool *aCollapsed);
 666     nsresult GetCommonAncestorContainer(nsIDOMNode **aCommonAncestorContainer);
 667     nsresult SetStart(nsIDOMNode *refNode, PRInt32 offset);
 668     nsresult SetEnd(nsIDOMNode *refNode, PRInt32 offset);
 669     nsresult SetStartBefore(nsIDOMNode *refNode);
 670     nsresult SetStartAfter(nsIDOMNode *refNode);
 671     nsresult SetEndBefore(nsIDOMNode *refNode);
 672     nsresult SetEndAfter(nsIDOMNode *refNode);
 673     nsresult Collapse(PRBool toStart);
 674     nsresult SelectNode(nsIDOMNode *refNode);
 675     nsresult SelectNodeContents(nsIDOMNode *refNode);
 676     nsresult CompareBoundaryPoints(PRUint16 how, nsIDOMRange *sourceRange, PRInt16 *_retval);
 677     nsresult DeleteContents();
 678     nsresult ExtractContents(nsIDOMDocumentFragment **_retval);
 679     nsresult CloneContents(nsIDOMDocumentFragment **_retval);
 680     nsresult InsertNode(nsIDOMNode *newNode);
 681     nsresult SurroundContents(nsIDOMNode *newParent);
 682     nsresult CloneRange(nsIDOMRange **_retval);
 683     nsresult ToString(nsAString *_retval);
 684     nsresult Detach();
 685 }
 686
 687 [
 688     object,
 689     uuid(7b9badc6-c9bc-447a-8670-dbd195aed24b)
 690     /* FROZEN */
 691 ]
 692 interface nsIDOMDocumentRange : nsISupports
 693 {
 694     nsresult CreateRange(nsIDOMRange **_retval);
 695 }
 696
 697 [
 698     object,
 699     uuid(b2c7ed59-8634-4352-9e37-5484c8b6e4e1)
 700     /* FROZEN */
 701 ]
 702 interface nsISelection : nsISupports
 703 {
 704     nsresult GetAnchorNode(nsIDOMNode **aAnchorNode);
 705     nsresult GetAnchorOffset(PRInt32 *aAnchorOffset);
 706     nsresult GetFocusNode(nsIDOMNode **aFocusNode);
 707     nsresult GetFocusOffset(PRInt32 *aFocusOffset);
 708     nsresult GetIsCollapsed(PRBool *aIsCollapsed);
 709     nsresult GetRangeCount(PRInt32 *aRangeCount);
 710     nsresult GetRangeAt(PRInt32 index, nsIDOMRange **_retval);
 711     nsresult Collapse(nsIDOMNode *parentNode, PRInt32 offset);
 712     nsresult Extend(nsIDOMNode *parentNode, PRInt32 offset);
 713     nsresult CollapseToStart();
 714     nsresult CollapseToEnd();
 715     nsresult ContainsNode(nsIDOMNode *node, PRBool entirelyContained, PRBool *_retval);
 716     nsresult SelectAllChildren(nsIDOMNode *parentNode);
 717     nsresult AddRange(nsIDOMRange *range);
 718     nsresult RemoveRange(nsIDOMRange *range);
 719     nsresult RemoveAllRanges();
 720     nsresult DeleteFromDocument();
 721     nsresult SelectionLanguageChange(PRBool langRTL);
 722     nsresult ToString(PRUnichar **_retval);
 723 }
 724
 725 [
 726     object,
 727     uuid(a6cf906b-15b3-11d2-932e-00805f8add32)
 728     /* FROZEN */
 729 ]
 730 interface nsIDOMWindow : nsISupports
 731 {
 732     nsresult GetDocument(nsIDOMDocument **aDocument);
 733     nsresult GetParent(nsIDOMWindow **aParent);
 734     nsresult GetTop(nsIDOMWindow **aTop);
 735     nsresult GetScrollbars(nsIDOMBarProp **aScrollbars);
 736     nsresult GetFrames(nsIDOMWindowCollection **aFrames);
 737     nsresult GetName(nsAString *aName);
 738     nsresult SetName(const nsAString *aName);
 739     nsresult GetTextZoom(float *aTextZoom);
 740     nsresult SetTextZoom(float aTextZoom);
 741     nsresult GetScrollX(PRInt32 *aScrollX);
 742     nsresult GetScrollY(PRInt32 *aScrollY);
 743     nsresult ScrollTo(PRInt32 xScroll, PRInt32 yScroll);
 744     nsresult ScrollBy(PRInt32 xScrollDif, PRInt32 yScrollDif);
 745     nsresult GetSelection(nsISelection **_retval);
 746     nsresult ScrollByLines(PRInt32 numLines);
 747     nsresult ScrollByPages(PRInt32 numPages);
 748     nsresult SizeToContent();
 749 }
 750
 751 [
 752     object,
 753     uuid(a6cf908e-15b3-11d2-932e-00805f8add32)
 754     /* FROZEN */
 755 ]
 756 interface nsIDOMHTMLBodyElement : nsIDOMHTMLElement
 757 {
 758     nsresult GetALink(nsAString *aALink);
 759     nsresult SetALink(const nsAString *aALink);
 760     nsresult GetBackground(nsAString *aBackground);
 761     nsresult SetBackground(const nsAString *aBackground);
 762     nsresult GetBgColor(nsAString *aBgColor);
 763     nsresult SetBgColor(const nsAString *aBgColor);
 764     nsresult GetLink(nsAString *aLink);
 765     nsresult SetLink(const nsAString *aLink);
 766     nsresult GetText(nsAString *aText);
 767     nsresult SetText(const nsAString *aText);
 768     nsresult GetVLink(nsAString *aVLink);
 769     nsresult SetVLink(const nsAString *aVLink);
 770 }
 771
 772 [
 773     object,
 774     uuid(a6cf9093-15b3-11d2-932e-00805f8add32)
 775     /* FROZEN */
 776 ]
 777 interface nsIDOMHTMLInputElement : nsIDOMHTMLElement
 778 {
 779     nsresult GetDefaultValue(nsAString *aDefaultValue);
 780     nsresult SetDefaultValue(const nsAString *aDefaultValue);
 781     nsresult GetDefaultChecked(PRBool *aDefaultChecked);
 782     nsresult SetDefaultChecked(PRBool aDefaultChecked);
 783     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
 784     nsresult GetAccept(nsAString *aAccept);
 785     nsresult SetAccept(const nsAString *aAccept);
 786     nsresult GetAccessKey(nsAString *aAccessKey);
 787     nsresult SetAccessKey(const nsAString *aAccessKey);
 788     nsresult GetAlign(nsAString *aAlign);
 789     nsresult SetAlign(const nsAString *aAlign);
 790     nsresult GetAlt(nsAString *aAlt);
 791     nsresult SetAlt(const nsAString *aAlt);
 792     nsresult GetChecked(PRBool *aChecked);
 793     nsresult SetChecked(PRBool aChecked);
 794     nsresult GetDisabled(PRBool *aDisabled);
 795     nsresult SetDisabled(PRBool aDisabled);
 796     nsresult GetMaxLength(PRInt32 *aMaxLength);
 797     nsresult SetMaxLength(PRInt32 aMaxLength);
 798     nsresult GetName(nsAString *aName);
 799     nsresult SetName(const nsAString *aName);
 800     nsresult GetReadOnly(PRBool *aReadOnly);
 801     nsresult SetReadOnly(PRBool aReadOnly);
 802     nsresult GetSize(PRUint32 *aSize);
 803     nsresult SetSize(PRUint32 aSize);
 804     nsresult GetSrc(nsAString *aSrc);
 805     nsresult SetSrc(const nsAString *aSrc);
 806     nsresult GetTabIndex(PRInt32 *aTabIndex);
 807     nsresult SetTabIndex(PRInt32 aTabIndex);
 808     nsresult GetType(nsAString *aType);
 809     nsresult SetType(const nsAString *aType);
 810     nsresult GetUseMap(nsAString *aUseMap);
 811     nsresult SetUseMap(const nsAString *aUseMap);
 812     nsresult GetValue(nsAString *aValue);
 813     nsresult SetValue(const nsAString *aValue);
 814     nsresult Blur();
 815     nsresult Focus();
 816     nsresult Select();
 817     nsresult Click();
 818 }
 819
 820 [
 821     object,
 822     uuid(a6cf9090-15b3-11d2-932e-00805f8add32)
 823     /* FROZEN */
 824 ]
 825 interface nsIDOMHTMLSelectElement : nsIDOMHTMLElement
 826 {
 827     nsresult GetType(nsAString *aType);
 828     nsresult GetSelectedIndex(PRInt32 *aSelectedIndex);
 829     nsresult SetSelectedIndex(PRInt32 aSelectedIndex);
 830     nsresult GetValue(nsAString *aValue);
 831     nsresult SetValue(const nsAString *aValue);
 832     nsresult GetLength(PRUint32 *aLength);
 833     nsresult SetLength(PRUint32 aLength);
 834     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
 835     nsresult GetOptions(nsIDOMHTMLOptionsCollection **aOptions);
 836     nsresult GetDisabled(PRBool *aDisabled);
 837     nsresult SetDisabled(PRBool aDisabled);
 838     nsresult GetMultiple(PRBool *aMultiple);
 839     nsresult SetMultiple(PRBool aMultiple);
 840     nsresult GetName(nsAString *aName);
 841     nsresult SetName(const nsAString *aName);
 842     nsresult GetSize(PRInt32 *aSize);
 843     nsresult SetSize(PRInt32 aSize);
 844     nsresult GetTabIndex(PRInt32 *aTabIndex);
 845     nsresult SetTabIndex(PRInt32 aTabIndex);
 846     nsresult Add(nsIDOMHTMLElement *element, nsIDOMHTMLElement *before);
 847     nsresult Remove(PRInt32 index);
 848     nsresult Blur();
 849     nsresult Focus();
 850 }
 851
 852 [
 853     object,
 854     uuid(a6cf9094-15b3-11d2-932e-00805f8add32)
 855     /* FROZEN */
 856 ]
 857 interface nsIDOMHTMLTextAreaElement : nsIDOMHTMLElement
 858 {
 859     nsresult GetDefaultValue(nsAString *aDefaultValue);
 860     nsresult SetDefaultValue(const nsAString *aDefaultValue);
 861     nsresult GetForm(nsIDOMHTMLFormElement **aForm);
 862     nsresult GetAccessKey(nsAString *aAccessKey);
 863     nsresult SetAccessKey(const nsAString *aAccessKey);
 864     nsresult GetCols(PRInt32 *aCols);
 865     nsresult SetCols(PRInt32 aCols);
 866     nsresult GetDisabled(PRBool *aDisabled);
 867     nsresult SetDisabled(PRBool aDisabled);
 868     nsresult GetName(nsAString *aName);
 869     nsresult SetName(const nsAString *aName);
 870     nsresult GetReadOnly(PRBool *aReadOnly);
 871     nsresult SetReadOnly(PRBool aReadOnly);
 872     nsresult GetRows(PRInt32 *aRows);
 873     nsresult SetRows(PRInt32 aRows);
 874     nsresult GetTabIndex(PRInt32 *aTabIndex);
 875     nsresult SetTabIndex(PRInt32 aTabIndex);
 876     nsresult GetType(nsAString *aType);
 877     nsresult GetValue(nsAString *aValue);
 878     nsresult SetValue(const nsAString *aValue);
 879     nsresult Blur();
 880     nsresult Focus();
 881     nsresult Select();
 882 }
 883
 884 [
 885     object,
 886     uuid(94928ab3-8b63-11d3-989d-001083010e9b)
 887     /* FROZEN */
 888 ]
 889 interface nsIURIContentListener : nsISupports
 890 {
 891     nsresult OnStartURIOpen(nsIURI *aURI, PRBool *_retval);
 892     nsresult DoContent(const char *aContentType, PRBool aIsContentPreferred, nsIRequest *aRequest,
 893         nsIStreamListener **aContentHandler, PRBool *_retval);
 894     nsresult IsPreferred(const char *aContentType, char **aDesiredContentType, PRBool *_retval);
 895     nsresult CanHandleContent(const char *aContentType, PRBool aIsContentPreferred,
 896         char **aDesiredContentType, PRBool *_retval);
 897     nsresult GetLoadCookie(nsISupports **aLoadCookie);
 898     nsresult SetLoadCookie(nsISupports *aLoadCookie);
 899     nsresult GetParentContentListener(nsIURIContentListener **aParentContentListener);
 900     nsresult SetParentContentListener(nsIURIContentListener *aParentContentListener);
 901 }
 902
 903 [
 904     object,
 905     uuid(44b78386-1dd2-11b2-9ad2-e4eee2ca1916)
 906     /* FROZEN */
 907 ]
 908 interface nsITooltipListener : nsISupports
 909 {
 910     nsresult OnShowTooltip(PRInt32 aXCoords, PRInt32 aYCoords, const PRUnichar *aTipText);
 911     nsresult OnHideTooltip();
 912 }
 913
 914 [
 915     object,
 916     uuid(69e5df00-7b8b-11d3-af61-00a024ffc08c)
 917     /* FROZEN */
 918 ]
 919 interface nsIWebBrowser : nsISupports
 920 {
 921     nsresult AddWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
 922     nsresult RemoveWebBrowserListener(nsIWeakReference *aListener, const nsIID *aIID);
 923     nsresult GetContainerWindow(nsIWebBrowserChrome **aContainerWindow);
 924     nsresult SetContainerWindow(nsIWebBrowserChrome *aContainerWindow);
 925     nsresult GetParentURIContentListener(nsIURIContentListener **aParentURIContentListener);
 926     nsresult SetParentURIContentListener(nsIURIContentListener *aParentURIContentListener);
 927     nsresult GetContentDOMWindow(nsIDOMWindow **aContentDOMWindow);
 928 }
 929
 930 cpp_quote("#define SETUP_IS_CHROME_WRAPPER 7");
 931
 932 [
 933     object,
 934     uuid(f15398a0-8018-11d3-af70-00a024ffc08c)
 935     /* FROZEN */
 936 ]
 937 interface nsIWebBrowserSetup : nsISupports
 938 {
 939     nsresult SetProperty(PRUint32 aId, PRUint32 aValue);
 940 }
 941
 942 typedef void* nativeWindow;
 943
 944 [
 945     object,
 946     uuid(046bc8a0-8015-11d3-af70-00a024ffc08c)
 947     /* NOT_FROZEN */
 948 ]
 949 interface nsIBaseWindow : nsISupports
 950 {
 951     nsresult InitWindow(nativeWindow parentNativeWindow, nsIWidget *parentWidget, PRInt32 x,
 952             PRInt32 y, PRInt32 cx, PRInt32 cy);
 953     nsresult Create();
 954     nsresult Destroy();
 955     nsresult SetPosition(PRInt32 x, PRInt32 y);
 956     nsresult GetPosition(PRInt32 *x, PRInt32 *y);
 957     nsresult SetSize(PRInt32 cx, PRInt32 cy, PRBool fRepaint);
 958     nsresult GetSize(PRInt32 *cx, PRInt32 *cy);
 959     nsresult SetPositionAndSize(PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy, PRBool fRepaint);
 960     nsresult GetPositionAndSize(PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy);
 961     nsresult Repaint(PRBool force);
 962     nsresult GetParentWidget(nsIWidget **aParentWidget);
 963     nsresult SetParentWidget(nsIWidget *aParentWidget);
 964     nsresult GetParentNativeWindow(nativeWindow *aParentNativeWindow);
 965     nsresult SetParentNativeWindow(nativeWindow aParentNativeWindow);
 966     nsresult GetVisibility(PRBool *aVisibility);
 967     nsresult SetVisibility(PRBool aVisibility);
 968     nsresult GetEnabled(PRBool *aEnabled);
 969     nsresult SetEnabled(PRBool aEnabled);
 970     nsresult GetBlurSuppression(PRBool *aBlurSuppression);
 971     nsresult SetBlurSuppression(PRBool aBlurSuppression);
 972     nsresult GetMainWidget(nsIWidget **aMainWidget);
 973     nsresult SetFocus();
 974     nsresult GetTitle(PRUnichar **aTitle);
 975     nsresult SetTitle(const PRUnichar *aTitle);
 976 }
 977
 978 cpp_quote("#define LOAD_FLAGS_NONE 0");
 979
 980 [
 981     object,
 982     uuid(f5d9e7b0-d930-11d3-b057-00a024ffc08c)
 983     /* NOT_FROZEN */
 984 ]
 985 interface nsIWebNavigation : nsISupports
 986 {
 987     nsresult GetCanGoBack(PRBool *aCanGoBack);
 988     nsresult GetCanGoForward(PRBool *aCanGoForward);
 989     nsresult GoBack();
 990     nsresult GoForward();
 991     nsresult GotoIndex(PRInt32 index);
 992     nsresult LoadURI(const PRUnichar *aURI, PRUint32 aLoadFlags, nsIURI *aReferrer,
 993             nsIInputStream *aPostData, nsIInputStream *aHeaders);
 994     nsresult Reload(PRUint32 aReloadFlags);
 995     nsresult Stop(PRUint32 aStopFlags);
 996     nsresult GetDocument(nsIDOMDocument **aDocument);
 997     nsresult GetCurrentURI(nsIURI **aCurrentURI);
 998     nsresult GetReferringURI(nsIURI **aReferringURI);
 999     nsresult GetSessionHistory(nsISHistory **aSessionHistory);
1000     nsresult SetSessionHistory(nsISHistory *aSessionHistory);
1001 }
1002
1003 [
1004     object,
1005     uuid(f1094df6-ce0e-42c9-9847-2f663172c38d)
1006     /* NOT_FROZEN */
1007 ]
1008 interface nsIPrintSettings : nsISupports
1009 {
1010     typedef struct {} nsMargin;
1011
1012     nsresult SetPrintOptions(PRInt32 aType, PRBool aTurnOnOff);
1013     nsresult GetPrintOptions(PRInt32 aType, PRBool *_retval);
1014     nsresult GetPrintOptionsBits(PRInt32 *_retval);
1015     nsresult GetPageSizeInTwips(PRInt32 *aWidth, PRInt32 *aHeight);
1016     nsresult Clone(nsIPrintSettings **_retval);
1017     nsresult Assign(nsIPrintSettings *aPS);
1018     nsresult GetPrintSession(nsIPrintSession **aPrintSession);
1019     nsresult SetPrintSession(nsIPrintSession *aPrintSession);
1020     nsresult GetStartPageRange(PRInt32 *aStartPageRange);
1021     nsresult SetStartPageRange(PRInt32 aStartPageRange);
1022     nsresult GetEndPageRange(PRInt32 *aEndPageRange);
1023     nsresult SetEndPageRange(PRInt32 aEndPageRange);
1024     nsresult GetMarginTop(double *aMarginTop);
1025     nsresult SetMarginTop(double aMarginTop);
1026     nsresult GetMarginLeft(double *aMarginLeft);
1027     nsresult SetMarginLeft(double aMarginLeft);
1028     nsresult GetMarginBottom(double *aMarginBottom);
1029     nsresult SetMarginBottom(double aMarginBottom);
1030     nsresult GetMarginRight(double *aMarginRight);
1031     nsresult SetMarginRight(double aMarginRight);
1032     nsresult GetScaling(double *aScaling);
1033     nsresult SetScaling(double aScaling);
1034     nsresult GetPrintBGColors(PRBool *aPrintBGColors);
1035     nsresult SetPrintBGColors(PRBool aPrintBGColors);
1036     nsresult GetPrintBGImages(PRBool *aPrintBGImages);
1037     nsresult SetPrintBGImages(PRBool aPrintBGImages);
1038     nsresult GetPrintRange(PRInt16 *aPrintRange);
1039     nsresult SetPrintRange(PRInt16 aPrintRange);
1040     nsresult GetTitle(PRUnichar **aTitle);
1041     nsresult SetTitle(const PRUnichar *aTitle);
1042     nsresult GetDocURL(PRUnichar **aDocURL);
1043     nsresult SetDocURL(const PRUnichar *aDocURL);
1044     nsresult GetHeaderStrLeft(PRUnichar **aHeaderStrLeft);
1045     nsresult SetHeaderStrLeft(const PRUnichar *aHeaderStrLeft);
1046     nsresult GetHeaderStrCenter(PRUnichar **aHeaderStrCenter);
1047     nsresult SetHeaderStrCenter(const PRUnichar *aHeaderStrCenter);
1048     nsresult GetHeaderStrRight(PRUnichar **aHeaderStrRight);
1049     nsresult SetHeaderStrRight(const PRUnichar *aHeaderStrRight);
1050     nsresult GetFooterStrLeft(PRUnichar **aFooterStrLeft);
1051     nsresult SetFooterStrLeft(const PRUnichar *aFooterStrLeft);
1052     nsresult GetFooterStrCenter(PRUnichar **aFooterStrCenter);
1053     nsresult SetFooterStrCenter(const PRUnichar *aFooterStrCenter);
1054     nsresult GetFooterStrRight(PRUnichar **aFooterStrRight);
1055     nsresult SetFooterStrRight(const PRUnichar *aFooterStrRight);
1056     nsresult GetHowToEnableFrameUI(PRInt16 *aHowToEnableFrameUI);
1057     nsresult SetHowToEnableFrameUI(PRInt16 aHowToEnableFrameUI);
1058     nsresult GetIsCancelled(PRBool *aIsCancelled);
1059     nsresult SetIsCancelled(PRBool aIsCancelled);
1060     nsresult GetPrintFrameTypeUsage(PRInt16 *aPrintFrameTypeUsage);
1061     nsresult SetPrintFrameTypeUsage(PRInt16 aPrintFrameTypeUsage);
1062     nsresult GetPrintFrameType(PRInt16 *aPrintFrameType);
1063     nsresult SetPrintFrameType(PRInt16 aPrintFrameType);
1064     nsresult GetPrintSilent(PRBool *aPrintSilent);
1065     nsresult SetPrintSilent(PRBool aPrintSilent);
1066     nsresult GetShrinkToFit(PRBool *aShrinkToFit);
1067     nsresult SetShrinkToFit(PRBool aShrinkToFit);
1068     nsresult GetShowPrintProgress(PRBool *aShowPrintProgress);
1069     nsresult SetShowPrintProgress(PRBool aShowPrintProgress);
1070     nsresult GetPaperName(PRUnichar **aPaperName);
1071     nsresult SetPaperName(const PRUnichar *aPaperName);
1072     nsresult GetPaperSizeType(PRInt16 *aPaperSizeType);
1073     nsresult SetPaperSizeType(PRInt16 aPaperSizeType);
1074     nsresult GetPaperData(PRInt16 *aPaperData);
1075     nsresult SetPaperData(PRInt16 aPaperData);
1076     nsresult GetPaperWidth(double *aPaperWidth);
1077     nsresult SetPaperWidth(double aPaperWidth);
1078     nsresult GetPaperHeight(double *aPaperHeight);
1079     nsresult SetPaperHeight(double aPaperHeight);
1080     nsresult GetPaperSizeUnit(PRInt16 *aPaperSizeUnit);
1081     nsresult SetPaperSizeUnit(PRInt16 aPaperSizeUnit);
1082     nsresult GetPlexName(PRUnichar **aPlexName);
1083     nsresult SetPlexName(const PRUnichar *aPlexName);
1084     nsresult GetColorspace(PRUnichar **aColorspace);
1085     nsresult SetColorspace(const PRUnichar *aColorspace);
1086     nsresult GetResolutionName(PRUnichar **aResolutionName);
1087     nsresult SetResolutionName(const PRUnichar aResolutionName);
1088     nsresult GetDownloadFonts(PRBool *aDownloadFonts);
1089     nsresult SetDownloadFonts(PRBool aDownloadFonts);
1090     nsresult GetPrintReversed(PRBool *aPrintReversed);
1091     nsresult SetPrintReversed(PRBool aPrintReversed);
1092     nsresult GetPrintInColor(PRBool *aPrintInColor);
1093     nsresult SetPrintInColor(PRBool aPrintInColor);
1094     nsresult GetPaperSize(PRInt32 *aPaperSize);
1095     nsresult SetPaperSize(PRInt32 aPaperSize);
1096     nsresult GetOrientation(PRInt32 *aOrientation);
1097     nsresult SetOrientation(PRInt32 aOrientation);
1098     nsresult GetPrintCommand(PRUnichar **aPrintCommand);
1099     nsresult SetPrintCommand(const PRUnichar *aPrintCommand);
1100     nsresult GetNumCopies(PRInt32 *aNumCopies);
1101     nsresult SetNumCopies(PRInt32 aNumCopies);
1102     nsresult GetPrinterName(PRUnichar **aPrinterName);
1103     nsresult SetPrinterName(const PRUnichar *aPrinterName);
1104     nsresult GetPrintToFile(PRBool *aPrintToFile);
1105     nsresult SetPrintToFile(PRBool aPrintToFile);
1106     nsresult GetToFileName(PRUnichar **aToFileName);
1107     nsresult SetToFileName(const PRUnichar *aToFileName);
1108     nsresult GetPrintPageDelay(PRInt32 *aPrintPageDelay);
1109     nsresult SetPrintPageDelay(PRInt32 aPrintPageDelay);
1110     nsresult GetIsInitializedFromPrinter(PRBool *aIsInitializedFromPrinter);
1111     nsresult SetIsInitializedFromPrinter(PRBool aIsInitializedFromPrinter);
1112     nsresult GetIsInitializedFromPrefs(PRBool *aIsInitializedFromPrefs);
1113     nsresult SetIsInitializedFromPrefs(PRBool aIsInitializedFromPrefs);
1114     nsresult SetMarginInTwips(nsMargin *aMargin);
1115     nsresult GetMarginInTwips(nsMargin *aMargin);
1116 }
1117
1118 [
1119     object,
1120     uuid(9a7ca4b0-fbba-11d4-a869-00105a183419)
1121     /* FROZEN */
1122 ]
1123 interface nsIWebBrowserPrint : nsISupports
1124 {
1125     nsresult GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings);
1126     nsresult GetCurrentPrintSettings(nsIPrintSettings **aCurrentPrintSettings);
1127     nsresult GetCurrentChildDOMWindow(nsIDOMWindow **aCurrentChildDOMWindow);
1128     nsresult GetDoingPrint(PRBool *aDoingPrint);
1129     nsresult GetDoingPrintPreview(PRBool *aDoingPrintPreview);
1130     nsresult GetIsFramesetDocument(PRBool *aIsFramesetDocument);
1131     nsresult GetIsFramesetFrameSelected(PRBool *aIsFramesetFrameSelected);
1132     nsresult GetIsIFrameSelected(PRBool *aIsIFrameSelected);
1133     nsresult GetIsRangeSelection(PRBool *aIsRangeSelection);
1134     nsresult GetPrintPreviewNumPages(PRInt32 *aPrintPreviewNumPages);
1135     nsresult Print(nsIPrintSettings *aThePrintSettings, nsIWebProgressListener *aWPListener);
1136     nsresult PrintPreview(nsIPrintSettings *aThePrintSettings, nsIDOMWindow *aChildDOMWin,
1137                           nsIWebProgressListener *aWPListener);
1138     nsresult PrintPreviewNavigate(PRInt16 aNavType, PRInt32 aPageNum);
1139     nsresult Cancel();
1140     nsresult EnumerateDocumentNames(PRUint32 *aCount, PRUnichar ***aResult);
1141     nsresult ExitPrintPreview();
1142 }
1143
1144 [
1145     object,
1146     uuid(c8c0a080-0868-11d3-915f-d9d889d48e3c)
1147     /* FROZEN */
1148 ]
1149 interface nsIFile : nsISupports
1150 {
1151     nsresult Append(const nsAString *node);
1152     nsresult AppendNative(const nsAString *node);
1153     nsresult Normalize();
1154     nsresult Create(PRUint32 type, PRUint32 permission);
1155     nsresult GetLeafName(nsAString *aLeafName);
1156     nsresult SetLeafName(const nsAString *aLeafName);
1157     nsresult GetNativeLeafName(nsAString *aLeafName);
1158     nsresult SetNativeLeafName(const nsAString *aLeafName);
1159     nsresult CopyTo(nsIFile *newParentDir, const nsAString *newName);
1160     nsresult CopyToNative(nsIFile *newParentDir, const nsAString *newName);
1161     nsresult CopyToFollowingLinks(nsIFile *newParentDir, const nsAString *newName);
1162     nsresult CopyToFollowingLinksNative(nsIFile *newParentDir, const nsAString *newName);
1163     nsresult MoveTo(nsIFile *newParentDir, const nsAString *newName);
1164     nsresult MoveToNative(nsIFile *newParentDir, const nsAString *newName);
1165     nsresult Remove(PRBool recursive);
1166     nsresult GetPermissions(PRUint32 *aPermissions);
1167     nsresult SetPermissions(PRUint32 pPermissions);
1168     nsresult GetPermissionsOfLink(PRUint32 *aPermissions);
1169     nsresult SetPermissionsOfLink(PRUint32 pPermissions);
1170     nsresult GetLastModifiedTime(PRInt64 *aLastModifiedTime);
1171     nsresult SetLastModifiedTime(PRInt64 aLastModifiedTime);
1172     nsresult GetFileSize(PRInt64 *aFileSize);
1173     nsresult SetFileSize(PRInt64 aFileSize);
1174     nsresult GetFileSizeOfLink(PRInt64 *aFileSizeOfLink);
1175     nsresult GetTarget(nsAString *aTarget);
1176     nsresult GetNativeTarget(nsACString *aNativeTarget);
1177     nsresult GetPath(nsAString *aPath);
1178     nsresult GetNativePath(nsACString *aNativePath);
1179     nsresult Exists(PRBool *_retval);
1180     nsresult IsWritable(PRBool *_retval);
1181     nsresult IsReadable(PRBool *_retval);
1182     nsresult IsExecutable(PRBool *_retval);
1183     nsresult IsHidden(PRBool *_retval);
1184     nsresult IsDirectory(PRBool *_retval);
1185     nsresult IsFile(PRBool *_retval);
1186     nsresult IsSymlink(PRBool *_retval);
1187     nsresult IsSpecial(PRBool *_retval);
1188     nsresult CreateUnique(PRUint32 type, PRUint32 permission);
1189     nsresult Clone(nsIFile **_retval);
1190     nsresult Equals(nsIFile *inFile, PRBool *_retval);
1191     nsresult Contains(nsIFile *inFile, PRBool recir, PRBool *_retval);
1192     nsresult GetParent(nsIFile **aParent);
1193     nsresult GetDirectoryEntries(nsISimpleEnumerator **aDirectoryEntries);
1194 }
1195
1196 [
1197     object,
1198     uuid(15fd6940-8ea7-11d3-93ad-00104ba0fd40)
1199     /* FROZEN */
1200 ]
1201 interface nsIProtocolHandler : nsISupports
1202 {
1203     nsresult GetScheme(nsACString *aScheme);
1204     nsresult GetDefaultPort(PRInt32 *aDefaultPort);
1205     nsresult GetProtocolFlags(PRUint32 *aProtocolFlags);
1206     nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset,
1207                     nsIURI *aBaseURI, nsIURI **_retval);
1208     nsresult NewChannel(nsIURI *aURI, nsIChannel **_retval);
1209     nsresult AllowPort(PRInt32 port, const char *scheme, PRBool *_retval);
1210 }
1211
1212 [
1213     object,
1214     uuid(0e61f3b2-34d7-4c79-bfdc-4860bc7341b7)
1215     /* NOT_FROZEN */
1216 ]
1217 interface nsIExternalProtocolHandler : nsIProtocolHandler
1218 {
1219     nsresult ExternalAppExistsForScheme(const nsACString *scheme, PRBool *_retval);
1220 }
1221
1222 [
1223     object,
1224     uuid(bddeda3f-9020-4d12-8c70-984ee9f7935e)
1225     /* FROZEN */
1226 ]
1227 interface nsIIOService : nsISupports
1228 {
1229     nsresult GetProtocolHandler(const char *aScheme, nsIProtocolHandler **_retval);
1230     nsresult GetProtocolFlags(const char *aScheme, PRUint32 *_retval);
1231     nsresult NewURI(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
1232                     nsIURI **_retval);
1233     nsresult NewFileURI(nsIFile *aFile, nsIURI **_retval);
1234     nsresult NewChannelFromURI(nsIURI *aURI, nsIChannel **_retval);
1235     nsresult NewChannel(const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI,
1236                         nsIChannel **_retval);
1237     nsresult GetOffline(PRBool *aOffline);
1238     nsresult SetOffline(PRBool aOffline);
1239     nsresult AllowPort(PRInt32 aPort, const char *aScheme, PRBool *_retval);
1240     nsresult ExtractScheme(const nsACString *urlString, nsACString * _retval);
1241 }
1242
1243 [
1244     object,
1245     uuid(9c5d3c58-1dd1-11b2-a1c9-f3699284657a)
1246     /* FROZEN */
1247 ]
1248 interface nsIWebBrowserFocus : nsISupports
1249 {
1250     nsresult Activate();
1251     nsresult Deactivate();
1252     nsresult SetFocusAtFirstElement();
1253     nsresult SetFocusAtLastElement();
1254     nsresult GetFocusedWindow(nsIDOMWindow **aFocusedWindow);
1255     nsresult SetFocusedWindow(nsIDOMWindow *aFocusedWindow);
1256     nsresult GetFocusedElement(nsIDOMElement **aFocusedElement);
1257     nsresult SetFocusedElement(nsIDOMElement *aFocusedElement);
1258 }
1259
1260 [
1261     object,
1262     uuid(ba434c60-9d52-11d3-afb0-00a024ffc08c)
1263     /* FROZEN */
1264 ]
1265 interface nsIWebBrowserChrome : nsISupports
1266 {
1267     nsresult SetStatus(PRUint32 statusType, const PRUnichar *status);
1268     nsresult GetWebBrowser(nsIWebBrowser **aWebBrowser);
1269     nsresult SetWebBrowser(nsIWebBrowser *aWebBrowser);
1270     nsresult GetChromeFlags(PRUint32 *aChromeFlags);
1271     nsresult SetChromeFlags(PRUint32 aChromeFlags);
1272     nsresult DestroyBrowserWindow();
1273     nsresult SizeBrowserTo(PRInt32 aCX, PRInt32 aCY);
1274     nsresult ShowAsModal();
1275     nsresult IsWindowModal(PRBool *_retval);
1276     nsresult ExitModalEventLoop(nsresult aStatus);
1277 }
1278
1279 [
1280     object,
1281     uuid(df31c120-ded6-11d1-bd85-00805f8ae3f4)
1282     /* FROZEN */
1283 ]
1284 interface nsIDOMEventListener : nsISupports
1285 {
1286     nsresult HandleEvent(nsIDOMEvent *event);
1287 }
1288
1289 [
1290     object,
1291     uuid(1c773b30-d1cf-11d2-bd95-00805f8ae3f4)
1292     /* FROZEN */
1293 ]
1294 interface nsIDOMEventTarget : nsISupports
1295 {
1296     nsresult AddEventListener(const nsAString *type, nsIDOMEventListener *listener, PRBool useCapture);
1297     nsresult RemoveEventListener(const nsAString *type, nsIDOMEventListener *listener, PRBool useCapture);
1298     nsresult DispatchEvent(nsIDOMEvent *evt, PRBool *_retval);
1299 }
1300
1301 [
1302     object,
1303     uuid(a66b7b80-ff46-bd97-0080-5f8ae38add32)
1304     /* FROZEN */
1305 ]
1306 interface nsIDOMEvent : nsISupports
1307 {
1308     nsresult GetType(nsAString *aType);
1309     nsresult GetTarget(nsIDOMEventTarget **aTarget);
1310     nsresult GetCurrentTarget(nsIDOMEventTarget **aCurrentTarget);
1311     nsresult GetEventPhase(PRUint16 *aEventPhase);
1312     nsresult GetBubbles(PRBool *aBubbles);
1313     nsresult GetCancelable(PRBool *aCancelable);
1314     nsresult GetTimeStamp(DOMTimeStamp *aTimeStamp);
1315     nsresult StopPropagation();
1316     nsresult PreventDefault();
1317     nsresult InitEvent(const nsAString *eventTypeArg, PRBool canBubbleArg, PRBool cancelableArg);
1318 }
1319
1320 cpp_quote("#define CONTEXT_NONE              0x00");
1321 cpp_quote("#define CONTEXT_LINK              0x01");
1322 cpp_quote("#define CONTEXT_IMAGE             0x02");
1323 cpp_quote("#define CONTEXT_DOCUMENT          0x04");
1324 cpp_quote("#define CONTEXT_TEXT              0x08");
1325 cpp_quote("#define CONTEXT_INPUT             0x10");
1326 cpp_quote("#define CONTEXT_BACKGROUND_IMAGE  0x20");
1327
1328 [
1329     object,
1330     uuid(3478b6b0-3875-11d4-94ef-0020183bf181)
1331     /* FROZEN */
1332 ]
1333 interface nsIContextMenuListener : nsISupports
1334 {
1335     nsresult OnShowContextMenu(PRUint32 aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode);
1336 }
1337
1338 [
1339     object,
1340     uuid(a6cf90c3-15b3-11d2-932e-00805f8add32)
1341     /* FROZEN */
1342 ]
1343 interface nsIDOMUIEvent : nsIDOMEvent
1344 {
1345     nsresult GetView(nsIDOMAbstractView **aView);
1346     nsresult GetDetail(PRInt32 *aDetail);
1347     nsresult InitUIEvent(const nsAString *typeArg, PRBool canBubbleArg, PRBool cancelableArg,
1348             nsIDOMAbstractView *viewArg, PRInt32 detailArg);
1349 }
1350
1351 [
1352     object,
1353     uuid(ff751edc-8b02-aae7-0010-8301838a3123)
1354     /* FROZEN */
1355 ]
1356 interface nsIDOMMouseEvent : nsIDOMUIEvent
1357 {
1358     nsresult GetScreenX(PRInt32 *aScreenX);
1359     nsresult GetScreenY(PRInt32 *aScreenY);
1360     nsresult GetClientX(PRInt32 *aClientX);
1361     nsresult GetClientY(PRInt32 *aClientY);
1362     nsresult GetCtrlKey(PRBool *aCtrlKey);
1363     nsresult GetShiftKey(PRBool *aShiftKey);
1364     nsresult GetAltKey(PRBool *aAltKey);
1365     nsresult GetMetaKey(PRBool *aMetaKey);
1366     nsresult GetButton(PRUint16 *aButton);
1367     nsresult GetRelatedTarget(nsIDOMEventTarget * *aRelatedTarget);
1368     nsresult InitMouseEvent(const nsAString *typeArg, PRBool canBubbleArg, PRBool cancelableArg,
1369             nsIDOMAbstractView *viewArg, PRInt32 detailArg, PRInt32 screenXArg, PRInt32 screenYArg,
1370             PRInt32 clientXArg, PRInt32 clientYArg, PRBool ctrlKeyArg, PRBool altKeyArg,
1371             PRBool shiftKeyArg, PRBool metaKeyArg, PRUint16 buttonArg,
1372             nsIDOMEventTarget *relatedTargetArg);
1373 }
1374
1375 [
1376     object,
1377     uuid(028e0e6e-8b01-11d3-aae7-0010838a3123)
1378     /* NOT_FROZEN */
1379 ]
1380 interface nsIDOMKeyEvent : nsIDOMUIEvent
1381 {
1382     nsresult GetCharCode(PRUint32 *aCharCode);
1383     nsresult GetKeyCode(PRUint32 *aKeyCode);
1384     nsresult GetAltKey(PRBool *aAltKey);
1385     nsresult GetCtrlKey(PRBool *aCtrlKey);
1386     nsresult GetShiftKey(PRBool *aShiftKey);
1387     nsresult GetMetaKey(PRBool *aMetaKey);
1388     nsresult InitKeyEvent(const nsAString *typeArg, PRBool canBubbleArg,
1389             PRBool cancelableArg, nsIDOMAbstractView *viewArg, PRBool ctrlKeyArg,
1390             PRBool altKeyArg, PRBool shiftKeyArg, PRBool metaKeyArg, PRUint32 keyCodeArg,
1391             PRUint32 charCodeArg);
1392 }
1393
1394 [
1395      object,
1396      uuid(3e5432cd-9568-4bd1-8cbe-d50aba110743)
1397      /* FROZEN */
1398 ]
1399 interface nsIEmbeddingSiteWindow : nsISupports
1400 {
1401     nsresult SetDimensions(PRUint32 flags, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy);
1402     nsresult GetDimensions(PRUint32 flags, PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy);
1403     nsresult SetFocus();
1404     nsresult GetVisibility(PRBool *aVisibility);
1405     nsresult SetVisibility(PRBool aVisibility);
1406     nsresult GetTitle(PRUnichar **aTitle);
1407     nsresult SetTitle(const PRUnichar *aTitle);
1408     nsresult GetSiteWindow(void **aSiteWindow);
1409 }
1410
1411 [
1412      object,
1413      uuid(2417cbfe-65ad-48a6-b4b6-eb84db174392)
1414      /* FROZEN */
1415 ]
1416 interface nsIComponentRegistrar : nsISupports
1417 {
1418     nsresult AutoRegister(nsIFile *aSpec);
1419     nsresult AutoUnregister(nsIFile *aSpec);
1420     nsresult RegisterFactory(const nsCID *aClass, const char *aClassName,
1421             const char *aContractID, nsIFactory *aFactory);
1422     nsresult UnregisterFactory(const nsCID *aClass, nsIFactory *aFactory);
1423     nsresult RegisterFactoryLocation(const nsCID *aClass, const char *aClassName,
1424             const char *aContractID, nsIFile *aFile, const char *aLoaderStr,
1425             const char *aType);
1426     nsresult UnregisterFactoryLocation(const nsCID *aClass, nsIFile *aFile);
1427     nsresult IsCIDRegistered(const nsCID *aClass, PRBool *_retval);
1428     nsresult IsContractIDRegistered(const char *aContractID, PRBool *_retval);
1429     nsresult EnumerateCIDs(nsISimpleEnumerator **_retval);
1430     nsresult EnumerateContractIDs(nsISimpleEnumerator **_retval);
1431     nsresult CIDToContractID(const nsCID *aClass, char **_retval);
1432     nsresult ContractIDToCID(const char *aContractID, nsCID **_retval);
1433 }
1434
1435 [
1436     object,
1437     uuid(1630c61a-325e-49ca-8759-a31b16c47aa5)
1438     /* FROZEN */
1439 ]
1440 interface nsIPromptService : nsISupports
1441 {
1442     nsresult Alert(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1443             const PRUnichar *aText);
1444     nsresult AlertCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1445             const PRUnichar *aText, const PRUnichar *aCheckMsg, PRBool *aCheckState);
1446     nsresult Confirm(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1447             const PRUnichar *aText, PRBool *_retval);
1448     nsresult ConfirmCheck(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1449             const PRUnichar *aText, const PRUnichar *aCheckMsg, PRBool *aCheckState,
1450             PRBool *_retval);
1451     nsresult ConfirmEx(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1452             const PRUnichar *aText, PRUint32 aButtonFlags, const PRUnichar *aButton0Title,
1453             const PRUnichar *aButton1Title, const PRUnichar *aButton2Title,
1454             const PRUnichar *aCheckMsg, PRBool *aCheckState, PRInt32 *_retval);
1455     nsresult Prompt(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1456             const PRUnichar *aText, PRUnichar **aValue, const PRUnichar *aCheckMsg,
1457             PRBool *aCheckState, PRBool *_retval);
1458     nsresult PromptUsernameAndPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1459             const PRUnichar *aText, PRUnichar **aUsername, PRUnichar **aPassword,
1460             const PRUnichar *aCheckMsg, PRBool *aCheckState, PRBool *_retval);
1461     nsresult PromptPassword(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1462             const PRUnichar *aText, PRUnichar **aPassword, const PRUnichar *aCheckMsg,
1463             PRBool *aCheckState, PRBool *_retval);
1464     nsresult Select(nsIDOMWindow *aParent, const PRUnichar *aDialogTitle,
1465             const PRUnichar *aText, PRUint32 aCount, const PRUnichar **aSelectList,
1466             PRInt32 *aOutSelection, PRBool *_retval);
1467 }
1468
1469 [
1470     object,
1471     uuid(b128a1e6-44f3-4331-8fbe-5af360ff21ee)
1472     /* FROZEN */
1473 ]
1474 interface nsITooltipTextProvider : nsISupports
1475 {
1476     nsresult GetNodeText(nsIDOMNode *aNode, PRUnichar **aText, PRBool *_retval);
1477 }
1478
1479 [
1480     object,
1481     uuid(02b0625a-e7f3-11d2-9f5a-006008a6efe9)
1482     /* FROZEN */
1483 ]
1484 interface nsIProfile : nsISupports
1485 {
1486     nsresult GetProfileCount(PRInt32 *aProfileCount);
1487     nsresult GetProfileList(PRUint32 *length, PRUnichar ***profileNames);
1488     nsresult ProfileExists(const PRUnichar *profileName, PRBool *_retval);
1489     nsresult GetCurrentProfile(PRUnichar * *aCurrentProfile);
1490     nsresult SetCurrentProfile(const PRUnichar * aCurrentProfile);
1491     nsresult ShutDownCurrentProfile(PRUint32 shutDownType);
1492     nsresult CreateNewProfile(const PRUnichar *profileName,
1493             const PRUnichar *nativeProfileDir, const PRUnichar *langcode,
1494             PRBool useExistingDir);
1495     nsresult RenameProfile(const PRUnichar *oldName, const PRUnichar *newName);
1496     nsresult DeleteProfile(const PRUnichar *name, PRBool canDeleteFiles);
1497     nsresult CloneProfile(const PRUnichar *profileName);
1498 }
1499
1500 [
1501     object,
1502     uuid(30465632-a777-44cc-90f9-8145475ef999)
1503     /* FROZEN */
1504 ]
1505 interface nsIWindowCreator : nsISupports
1506 {
1507     nsresult CreateChromeWindow(nsIWebBrowserChrome *parent, PRUint32 chromeFlags,
1508                                    nsIWebBrowserChrome **_retval);
1509 }
1510
1511 [
1512     object,
1513     uuid(f673ec81-a4b0-11d6-964b-eb5a2bf216fc)
1514     /* NOT_FROZEN */
1515 ]
1516 interface nsIWindowCreator2 : nsIWindowCreator
1517 {
1518     nsresult CreateChromeWindow2(nsIWebBrowserChrome *parent, PRUint32 chromeFlags,
1519                                  PRUint32 contextFlags, nsIURI *uri, PRBool *cancel,
1520                                  nsIWebBrowserChrome **_retval);
1521 }
1522
1523 [
1524     object,
1525     uuid(002286a8-494b-43b3-8ddd-49e3fc50622b)
1526     /* FROZEN */
1527 ]
1528 interface nsIWindowWatcher : nsISupports
1529 {
1530     nsresult OpenWindow(nsIDOMWindow *aParent, const char *aUrl, const char *aName,
1531                         const char *aFeatures, nsISupports *aArguments, nsIDOMWindow **_retval);
1532     nsresult RegisterNotification(nsIObserver *aObserver);
1533     nsresult UnregisterNotification(nsIObserver *aObserver);
1534     nsresult GetWindowEnumerator(nsISimpleEnumerator **_retval);
1535     nsresult GetNewPrompter(nsIDOMWindow *aParent, nsIPrompt **_retval);
1536     nsresult GetNewAuthPrompter(nsIDOMWindow *aParent, nsIAuthPrompt **_retval);
1537     nsresult SetWindowCreator(nsIWindowCreator *creator);
1538     nsresult GetChromeForWindow(nsIDOMWindow *aWindow, nsIWebBrowserChrome **_retval);
1539     nsresult GetWindowByName(const PRUnichar *aTargetName, nsIDOMWindow *aCurrentWindow,
1540                              nsIDOMWindow **_retval);
1541     nsresult GetActiveWindow(nsIDOMWindow **aActiveWindow);
1542     nsresult SetActiveWindow(nsIDOMWindow *aActiveWindow);
1543 }
1544
1545 [
1546     object,
1547     uuid(d39fd2b4-3978-45d2-a4be-ba448171b61b)
1548     /* NOT_FROZEN */
1549 ]
1550 interface nsIEditingSession : nsISupports
1551 {
1552     nsresult GetEditorStatus(PRUint32 *aEditorStatus);
1553     nsresult MakeWindowEditable(nsIDOMWindow *window, const char *aEditorType,
1554                                 PRBool doAfterUriLoad);
1555     nsresult WindowIsEditable(nsIDOMWindow *window, PRBool *_retval);
1556     nsresult GetEditorForWindow(nsIDOMWindow *window, nsIEditor **_retval);
1557     nsresult SetupEditorOnWindow(nsIDOMWindow *window);
1558     nsresult TearDownEditorOnWindow(nsIDOMWindow *window);
1559     nsresult SetEditorOnControllers(nsIDOMWindow *aWindow, nsIEditor *aEditor);
1560 }
1561
1562 [
1563     object,
1564     uuid(83f892cf-7ed3-490e-967a-62640f3158e1)
1565     /* NOT_FROZEN */
1566 ]
1567 interface nsICommandParams : nsISupports
1568 {
1569     nsresult GetValueType(const char *name, PRInt16 *_retval);
1570     nsresult GetBooleanValue(const char *name, PRBool *_retval);
1571     nsresult GetLongValue(const char *name, PRInt32 *_retval);
1572     nsresult GetDoubleValue(const char *name, double *_retval);
1573     nsresult GetStringValue(const char *name, nsAString *_retval);
1574     nsresult GetCStringValue(const char *name, char **_retval);
1575     nsresult GetISupportsValue(const char *name, nsISupports **_retval);
1576     nsresult SetBooleanValue(const char *name, PRBool value);
1577     nsresult SetLongValue(const char *name, PRInt32 value);
1578     nsresult SetDoubleValue(const char *name, double value);
1579     nsresult SetStringValue(const char *name, const nsAString *value);
1580     nsresult SetCStringValue(const char *name, const char *value);
1581     nsresult SetISupportsValue(const char *name, nsISupports *value);
1582     nsresult RemoveValue(const char *name);
1583     nsresult HasMoreElements(PRBool *_retval);
1584     nsresult First();
1585     nsresult GetNext(char **_retval);
1586 }
1587
1588 [
1589     object,
1590     uuid(080d2001-f91e-11d4-a73c-f9242928207c)
1591     /* NOT_FROZEN */
1592 ]
1593 interface nsICommandManager : nsISupports
1594 {
1595     nsresult AddCommandObserver(nsIObserver *aCommandObserver, const char *aCommandToObserve);
1596     nsresult RemoveCommandObserver(nsIObserver *aCommandObserver, const char *aCommandObserved);
1597     nsresult IsCommandSupported(const char *aCommandName, nsIDOMWindow *aTargetWindow, PRBool *_retval);
1598     nsresult IsCommandEnabled(const char *aCommandName, nsIDOMWindow *aTargetWindow, PRBool *_retval);
1599     nsresult GetCommandState(const char *aCommandName, nsIDOMWindow *aTargetWindow,
1600             nsICommandParams *aCommandParams);
1601     nsresult DoCommand(const char *aCommandName, nsICommandParams *aCommandParams,
1602             nsIDOMWindow *aTargetWindow);
1603 }
1604
1605 [
1606     object,
1607     uuid(d650439a-ca29-410d-a906-b0557fb62fcd)
1608     /* NOT_FROZEN */
1609 ]
1610 interface nsIContentSerializer : nsISupports
1611 {
1612     nsresult Init(PRUint32 flags, PRUint32 aWrapColumn, const char* aCharSet, PRBool aIsCopying);
1613     nsresult AppendText(nsIDOMText *aText, PRInt32 aStartOffset, PRInt32 aEndOffset, nsAString *aStr);
1614     nsresult AppendCDATASection(nsIDOMCDATASection *aCDATASection, PRInt32 aStartOffset,
1615             PRInt32 aEndOffset, nsAString *aStr);
1616     nsresult AppendProcessingInstruction(nsIDOMProcessingInstruction* aPI, PRInt32 aStartOffset,
1617             PRInt32 aEndOffset, nsAString *aStr);
1618     nsresult AppendComment(nsIDOMComment *aComment, PRInt32 aStartOffset, PRInt32 aEndOffset,
1619             nsAString *aStr);
1620     nsresult AppendDoctype(nsIDOMDocumentType *aDoctype, nsAString *aStr);
1621     nsresult AppendElementStart(nsIDOMElement *aElement, PRBool aHasChildren, nsAString *aStr);
1622     nsresult AppendElementEnd(nsIDOMElement *aElement, nsAString *aStr);
1623     nsresult Flush(nsAString *aStr);
1624     nsresult AppendDocumentStart(nsIDOMDocument *aDocument, nsAString *aStr);
1625 }
1626
1627 /*
1628  * NOTE:
1629  * This is a private Wine interface that is implemented by our implementation
1630  * of nsIURI to store its owner.
1631  */
1632 [
1633     object,
1634     uuid(5088272e-900b-11da-c687-000fea57f21a)
1635     /* INTERNAL */
1636 ]
1637 interface nsIWineURI : nsIURI
1638 {
1639     typedef struct NSContainer NSContainer;
1640
1641     nsresult GetNSContainer(NSContainer **aNSContainer);
1642     nsresult SetNSContainer(NSContainer *aNSContainer);
1643     nsresult GetIsDocumentURI(PRBool *aIsDocumentURI);
1644     nsresult SetIsDocumentURI(PRBool aIsDocumentURI);
1645     nsresult GetWineURL(LPCWSTR *aURL);
1646     nsresult SetWineURL(LPCWSTR aURL);
1647 }