- Don't need scripting language version in ExecuteScript.

- Check for JS_ValueToString failure (out-of-memory).
- Clean up arbitrary false returns in nsIJSScriptObject method implementations.
- Use nsCOMPtr if possible


git-svn-id: svn://10.0.0.236/branches/XULDOMJS_19991106_BRANCH@53603 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/content/xul/content/public/nsIXULPopupListener.h

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsIXULPopupListener_h__
+#define nsIXULPopupListener_h__
+
+// {2C453161-0942-11d3-BF87-00105A1B0627}
+#define NS_IXULPOPUPLISTENER_IID \
+{ 0x2c453161, 0x942, 0x11d3, { 0xbf, 0x87, 0x0, 0x10, 0x5a, 0x1b, 0x6, 0x27 } }
+
+class nsIDOMElement;
+
+typedef enum {
+    eXULPopupType_popup,
+    eXULPopupType_context,
+    eXULPopupType_tooltip,
+    eXULPopupType_blur
+} XULPopupType;
+
+class nsIXULPopupListener: public nsISupports {
+public:
+    static const nsIID& GetIID() { static nsIID iid = NS_IXULPOPUPLISTENER_IID; return iid; }
+
+    NS_IMETHOD Init(nsIDOMElement* anElement, const XULPopupType& aPopupType) = 0;
+};
+
+extern nsresult
+NS_NewXULPopupListener(nsIXULPopupListener** result);
+
+#endif // nsIXULPopupListener_h__

mozilla/content/xul/content/src/nsIRDFNodeList.h

@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsIRDFNodeList_h__
+#define nsIRDFNodeList_h__
+
+#include "nsISupports.h"
+
+// {661D1971-5CD2-11d3-BE36-00104BDE6048}
+#define NS_IRDFNODELIST_IID \
+{ 0x661d1971, 0x5cd2, 0x11d3, { 0xbe, 0x36, 0x0, 0x10, 0x4b, 0xde, 0x60, 0x48 } }
+
+class nsIRDFNodeList : public nsISupports
+{
+public:
+    static const nsIID& GetIID() { static nsIID iid = NS_IRDFNODELIST_IID; return iid; }
+
+    NS_IMETHOD AppendNode(nsIDOMNode* aNode) = 0;
+    NS_IMETHOD RemoveNode(nsIDOMNode* aNode) = 0;
+};
+
+
+#endif // nsIRDFNodeList_h__
+

mozilla/content/xul/content/src/nsIXULTreeContent.h

@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+  A private interface to the tree element
+
+*/
+
+#ifndef nsIXULTreeContent_h__
+#define nsIXULTreeContent_h__
+
+#include "nsISupports.h"
+
+// {661D1970-5CD2-11d3-BE36-00104BDE6048}
+#define NS_IXULTREECONTENT_IID \
+{ 0x661d1970, 0x5cd2, 0x11d3, { 0xbe, 0x36, 0x0, 0x10, 0x4b, 0xde, 0x60, 0x48 } }
+
+
+class nsIXULTreeContent : public nsISupports
+{
+public:
+    static const nsIID& GetIID() { static nsIID iid = NS_IXULTREECONTENT_IID; return iid; }
+
+    NS_IMETHOD FireOnSelectHandler() = 0;
+};
+
+#endif // nsIXULTreeContent_h__

mozilla/content/xul/content/src/nsRDFDOMNodeList.cpp

@@ -0,0 +1,241 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+    Helper class to implement the nsIDOMNodeList interface.
+
+    XXX It's probably wrong in some sense, as it uses the "naked"
+    content interface to look for kids. (I assume in general this is
+    bad because there may be pseudo-elements created for presentation
+    that aren't visible to the DOM.)
+
+*/
+
+#include "nsDOMCID.h"
+#include "nsIDOMNode.h"
+#include "nsIDOMScriptObjectFactory.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsIServiceManager.h"
+#include "nsISupportsArray.h"
+#include "nsRDFDOMNodeList.h"
+
+////////////////////////////////////////////////////////////////////////
+// GUID definitions
+
+static NS_DEFINE_IID(kIDOMNodeIID,                NS_IDOMNODE_IID);
+static NS_DEFINE_IID(kIDOMNodeListIID,            NS_IDOMNODELIST_IID);
+static NS_DEFINE_IID(kIDOMScriptObjectFactoryIID, NS_IDOM_SCRIPT_OBJECT_FACTORY_IID);
+
+static NS_DEFINE_CID(kDOMScriptObjectFactoryCID,  NS_DOM_SCRIPT_OBJECT_FACTORY_CID);
+
+////////////////////////////////////////////////////////////////////////
+// ctors & dtors
+
+
+nsRDFDOMNodeList::nsRDFDOMNodeList(void)
+    : //mInner(nsnull), Not being used?
+      mElements(nsnull),
+      mScriptObject(nsnull)
+{
+    NS_INIT_REFCNT();
+}
+
+nsRDFDOMNodeList::~nsRDFDOMNodeList(void)
+{
+#ifdef DEBUG_REFS
+    --gInstanceCount;
+    fprintf(stdout, "%d - RDF: nsRDFDOMNodeList\n", gInstanceCount);
+#endif
+
+    NS_IF_RELEASE(mElements);
+    //delete mInner; Not being used?
+}
+
+nsresult
+nsRDFDOMNodeList::Create(nsRDFDOMNodeList** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    nsRDFDOMNodeList* list = new nsRDFDOMNodeList();
+    if (! list)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    nsresult rv;
+    if (NS_FAILED(rv = list->Init())) {
+        delete list;
+        return rv;
+    }
+
+    NS_ADDREF(list);
+    *aResult = list;
+    return NS_OK;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// nsISupports interface
+
+NS_IMPL_ADDREF(nsRDFDOMNodeList);
+NS_IMPL_RELEASE(nsRDFDOMNodeList);
+
+nsresult
+nsRDFDOMNodeList::QueryInterface(REFNSIID aIID, void** aResult)
+{
+static NS_DEFINE_IID(kISupportsIID,          NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kIScriptObjectOwnerIID, NS_ISCRIPTOBJECTOWNER_IID);
+
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    if (aIID.Equals(nsCOMTypeInfo<nsIDOMNodeList>::GetIID()) ||
+        aIID.Equals(kISupportsIID)) {
+        *aResult = NS_STATIC_CAST(nsIDOMNodeList*, this);
+    }
+    else if (aIID.Equals(nsCOMTypeInfo<nsIRDFNodeList>::GetIID())) {
+        *aResult = NS_STATIC_CAST(nsIRDFNodeList*, this);
+    }
+    else if (aIID.Equals(kIScriptObjectOwnerIID)) {
+        *aResult = NS_STATIC_CAST(nsIScriptObjectOwner*, this);
+    }
+    else {
+        *aResult = nsnull;
+        return NS_NOINTERFACE;
+    }
+
+    NS_ADDREF(this);
+    return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+// nsIDOMNodeList interface
+
+NS_IMETHODIMP
+nsRDFDOMNodeList::GetLength(PRUint32* aLength)
+{
+    NS_ASSERTION(aLength != nsnull, "null ptr");
+    if (! aLength)
+        return NS_ERROR_NULL_POINTER;
+
+    PRUint32 cnt;
+    nsresult rv = mElements->Count(&cnt);
+    if (NS_FAILED(rv)) return rv;
+    *aLength = cnt;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsRDFDOMNodeList::Item(PRUint32 aIndex, nsIDOMNode** aReturn)
+{
+    NS_PRECONDITION(aReturn != nsnull, "null ptr");
+    if (! aReturn)
+        return NS_ERROR_NULL_POINTER;
+
+    PRUint32 cnt;
+    nsresult rv = mElements->Count(&cnt);
+    if (NS_FAILED(rv)) return rv;
+    NS_PRECONDITION(aIndex < cnt, "invalid arg");
+    if (aIndex >= (PRUint32) cnt)
+        return NS_ERROR_INVALID_ARG;
+
+    // Cast is okay because we're in a closed system.
+    *aReturn = (nsIDOMNode*) mElements->ElementAt(aIndex);
+    return NS_OK;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// nsIScriptObjectOwner interface
+
+NS_IMETHODIMP
+nsRDFDOMNodeList::GetScriptObject(nsIScriptContext *aContext, void** aScriptObject)
+{
+    nsresult rv = NS_OK;
+    nsIScriptGlobalObject* global = aContext->GetGlobalObject();
+
+    if (nsnull == mScriptObject) {
+        nsIDOMScriptObjectFactory *factory;
+    
+        if (NS_SUCCEEDED(rv = nsServiceManager::GetService(kDOMScriptObjectFactoryCID,
+                                                           kIDOMScriptObjectFactoryIID,
+                                                           (nsISupports **)&factory))) {
+            rv = factory->NewScriptNodeList(aContext, 
+                                            (nsISupports*)(nsIDOMNodeList*)this, 
+                                            global, 
+                                            (void**)&mScriptObject);
+
+            nsServiceManager::ReleaseService(kDOMScriptObjectFactoryCID, factory);
+        }
+    }
+    *aScriptObject = mScriptObject;
+
+    NS_RELEASE(global);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsRDFDOMNodeList::SetScriptObject(void* aScriptObject)
+{
+    mScriptObject = aScriptObject;
+    return NS_OK;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation methods
+
+nsresult
+nsRDFDOMNodeList::Init(void)
+{
+    nsresult rv;
+    if (NS_FAILED(rv = NS_NewISupportsArray(&mElements))) {
+        NS_ERROR("unable to create elements array");
+        return rv;
+    }
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsRDFDOMNodeList::AppendNode(nsIDOMNode* aNode)
+{
+    NS_PRECONDITION(aNode != nsnull, "null ptr");
+    if (! aNode)
+        return NS_ERROR_NULL_POINTER;
+
+    return mElements->AppendElement(aNode);
+}
+
+NS_IMETHODIMP
+nsRDFDOMNodeList::RemoveNode(nsIDOMNode* aNode)
+{
+    NS_PRECONDITION(aNode != nsnull, "null ptr");
+    if (! aNode)
+        return NS_ERROR_NULL_POINTER;
+
+    return mElements->RemoveElement(aNode);
+}

mozilla/content/xul/content/src/nsRDFDOMNodeList.h

@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsRDFDOMNodeList_h__
+#define nsRDFDOMNodeList_h__
+
+#include "nsIDOMNodeList.h"
+#include "nsIRDFNodeList.h"
+#include "nsIScriptObjectOwner.h"
+class nsIDOMNode;
+class nsISupportsArray;
+
+class nsRDFDOMNodeList : public nsIDOMNodeList,
+                         public nsIRDFNodeList,
+                         public nsIScriptObjectOwner
+{
+private:
+    //nsISupports* mInner; Not being used?
+    nsISupportsArray* mElements;
+    void* mScriptObject;
+
+    nsRDFDOMNodeList(void);
+    nsresult Init(void);
+
+public:
+    static nsresult Create(nsRDFDOMNodeList** aResult);
+    virtual ~nsRDFDOMNodeList(void);
+
+    // nsISupports interface
+    NS_DECL_ISUPPORTS
+
+    // nsIDOMNodeList interface
+    NS_DECL_IDOMNODELIST
+
+    // nsIScriptObjectOwner interface
+    NS_IMETHOD GetScriptObject(nsIScriptContext *aContext, void** aScriptObject);
+    NS_IMETHOD SetScriptObject(void* aScriptObject);
+
+    // Implementation methods
+    NS_IMETHOD AppendNode(nsIDOMNode* aNode);
+    NS_IMETHOD RemoveNode(nsIDOMNode* aNode);
+};
+
+#endif // nsRDFDOMNodeList_h__
+

mozilla/content/xul/content/src/nsXULAttributes.cpp

@@ -0,0 +1,705 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+/*
+
+  A helper class used to implement attributes.
+
+*/
+
+
+/*
+ * Notes
+ *
+ * A lot of these methods delegate back to the original content node
+ * that created them. This is so that we can lazily produce attribute
+ * values from the RDF graph as they're asked for.
+ *
+ */
+
+#include "nsCOMPtr.h"
+#include "nsDOMCID.h"
+#include "nsIContent.h"
+#include "nsICSSParser.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMScriptObjectFactory.h"
+#include "nsINameSpaceManager.h"
+#include "nsIServiceManager.h"
+#include "nsIURL.h"
+#include "nsXULAttributes.h"
+#include "nsLayoutCID.h"
+
+static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
+static NS_DEFINE_CID(kDOMScriptObjectFactoryCID, NS_DOM_SCRIPT_OBJECT_FACTORY_CID);
+static NS_DEFINE_CID(kCSSParserCID, NS_CSSPARSER_CID);
+static NS_DEFINE_CID(kICSSParserIID, NS_ICSS_PARSER_IID);
+
+
+//----------------------------------------------------------------------
+//
+// nsClassList
+//
+
+PRBool
+nsClassList::HasClass(nsClassList* aList, nsIAtom* aClass)
+{
+    const nsClassList* classList = aList;
+    while (nsnull != classList) {
+        if (classList->mAtom.get() == aClass) {
+            return PR_TRUE;
+        }
+        classList = classList->mNext;
+    }
+    return PR_FALSE;
+}
+
+
+nsresult
+nsClassList::GetClasses(nsClassList* aList, nsVoidArray& aArray)
+{
+    aArray.Clear();
+    const nsClassList* classList = aList;
+    while (nsnull != classList) {
+        aArray.AppendElement(classList->mAtom); // NOTE atom is not addrefed
+        classList = classList->mNext;
+    }
+    return NS_OK;
+}
+
+
+
+nsresult
+nsClassList::ParseClasses(nsClassList** aList, const nsString& aClassString)
+{
+    static const PRUnichar kNullCh = PRUnichar('\0');
+
+    if (*aList != nsnull) {
+        delete *aList;
+        *aList = nsnull;
+    }
+
+    if (aClassString.Length() > 0) {
+        nsAutoString classStr(aClassString);  // copy to work buffer
+        classStr.Append(kNullCh);  // put an extra null at the end
+
+        PRUnichar* start = (PRUnichar*)(const PRUnichar*)classStr.GetUnicode();
+        PRUnichar* end   = start;
+
+        while (kNullCh != *start) {
+            while ((kNullCh != *start) && nsString::IsSpace(*start)) {  // skip leading space
+                start++;
+            }
+            end = start;
+
+            while ((kNullCh != *end) && (PR_FALSE == nsString::IsSpace(*end))) { // look for space or end
+                end++;
+            }
+            *end = kNullCh; // end string here
+
+            if (start < end) {
+                *aList = new nsClassList(NS_NewAtom(start));
+                aList = &((*aList)->mNext);
+            }
+
+            start = ++end;
+        }
+    }
+    return NS_OK;
+}
+
+
+
+//----------------------------------------------------------------------
+//
+// nsXULAttribute
+//
+
+
+nsXULAttribute::nsXULAttribute(nsIContent* aContent,
+                               PRInt32 aNameSpaceID,
+                               nsIAtom* aName,
+                               const nsString& aValue)
+    : mNameSpaceID(aNameSpaceID),
+      mName(aName),
+      mValue(aValue),
+      mContent(aContent),
+      mScriptObject(nsnull)
+{
+    NS_INIT_REFCNT();
+    NS_IF_ADDREF(aName);
+}
+
+nsXULAttribute::~nsXULAttribute()
+{
+    NS_IF_RELEASE(mName);
+}
+
+nsresult
+nsXULAttribute::Create(nsIContent* aContent,
+                       PRInt32 aNameSpaceID,
+                       nsIAtom* aName,
+                       const nsString& aValue,
+                       nsXULAttribute** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    if (! (*aResult = new nsXULAttribute(aContent, aNameSpaceID, aName, aValue)))
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aResult);
+    return NS_OK;
+}
+
+// nsISupports interface
+NS_IMPL_ADDREF(nsXULAttribute);
+NS_IMPL_RELEASE(nsXULAttribute);
+
+NS_IMETHODIMP
+nsXULAttribute::QueryInterface(REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    if (aIID.Equals(nsIDOMAttr::GetIID()) ||
+        aIID.Equals(nsIDOMNode::GetIID()) ||
+        aIID.Equals(kISupportsIID)) {
+        *aResult = NS_STATIC_CAST(nsIDOMAttr*, this);
+        NS_ADDREF(this);
+        return NS_OK;
+    }
+    else if (aIID.Equals(nsIScriptObjectOwner::GetIID())) {
+        *aResult = NS_STATIC_CAST(nsIScriptObjectOwner*, this);
+        NS_ADDREF(this);
+        return NS_OK;
+    }
+    else {
+        *aResult = nsnull;
+        return NS_NOINTERFACE;
+    }
+}
+
+// nsIDOMNode interface
+
+NS_IMETHODIMP
+nsXULAttribute::GetNodeName(nsString& aNodeName)
+{
+    const PRUnichar *unicodeString;
+    mName->GetUnicode(&unicodeString);
+
+    aNodeName.SetString(unicodeString);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetNodeValue(nsString& aNodeValue)
+{
+    aNodeValue=mValue;
+    return NS_OK;
+}
+NS_IMETHODIMP
+nsXULAttribute::SetNodeValue(const nsString& aNodeValue)
+{
+    return SetValue(aNodeValue);
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetNodeType(PRUint16* aNodeType)
+{
+    *aNodeType = (PRUint16)nsIDOMNode::ATTRIBUTE_NODE;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetParentNode(nsIDOMNode** aParentNode)
+{
+    *aParentNode = nsnull;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetChildNodes(nsIDOMNodeList** aChildNodes)
+{
+    NS_NOTYETIMPLEMENTED("write me");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetFirstChild(nsIDOMNode** aFirstChild)
+{
+    NS_NOTYETIMPLEMENTED("write me");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetLastChild(nsIDOMNode** aLastChild)
+{
+    NS_NOTYETIMPLEMENTED("write me");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetPreviousSibling(nsIDOMNode** aPreviousSibling)
+{
+    *aPreviousSibling = nsnull;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetNextSibling(nsIDOMNode** aNextSibling)
+{
+    *aNextSibling = nsnull;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetAttributes(nsIDOMNamedNodeMap** aAttributes)
+{
+    *aAttributes = nsnull;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetOwnerDocument(nsIDOMDocument** aOwnerDocument)
+{
+    NS_NOTYETIMPLEMENTED("write me");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aReturn)
+{
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aReturn)
+{
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn)
+{
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aReturn)
+{
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::HasChildNodes(PRBool* aReturn)
+{
+    NS_NOTYETIMPLEMENTED("write me");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::CloneNode(PRBool aDeep, nsIDOMNode** aReturn)
+{
+    NS_NOTYETIMPLEMENTED("write me");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+// nsIDOMAttr interface
+
+NS_IMETHODIMP
+nsXULAttribute::GetName(nsString& aName)
+{
+    const PRUnichar *unicodeString;
+    mName->GetUnicode(&unicodeString);
+    aName.SetString(unicodeString);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetSpecified(PRBool* aSpecified)
+{
+    // XXX this'll break when we make Clone() work
+    *aSpecified = PR_TRUE;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::GetValue(nsString& aValue)
+{
+    aValue=mValue;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttribute::SetValue(const nsString& aValue)
+{
+    // We call back to the content node's SetValue() method so we can
+    // share all of the work that it does.
+    nsCOMPtr<nsIDOMElement> element( do_QueryInterface(mContent) );
+    if (element) {
+        nsAutoString qualifiedName;
+        GetQualifiedName(qualifiedName);
+        return element->SetAttribute(qualifiedName, aValue);
+    }
+    else {
+        return NS_ERROR_FAILURE;
+    }
+}
+
+
+// nsIScriptObjectOwner interface
+
+NS_IMETHODIMP
+nsXULAttribute::GetScriptObject(nsIScriptContext* aContext, void** aScriptObject)
+{
+    nsresult rv = NS_OK;
+    if (! mScriptObject) {
+        nsIDOMScriptObjectFactory *factory;
+    
+        rv = nsServiceManager::GetService(kDOMScriptObjectFactoryCID,
+                                          nsIDOMScriptObjectFactory::GetIID(),
+                                          (nsISupports **)&factory);
+
+        if (NS_FAILED(rv))
+            return rv;
+
+        rv = factory->NewScriptAttr(aContext, 
+                                    (nsISupports*)(nsIDOMAttr*) this,
+                                    (nsISupports*) mContent,
+                                    (void**) &mScriptObject);
+
+        nsServiceManager::ReleaseService(kDOMScriptObjectFactoryCID, factory);
+    }
+
+    *aScriptObject = mScriptObject;
+    return rv;
+}
+
+
+NS_IMETHODIMP
+nsXULAttribute::SetScriptObject(void *aScriptObject)
+{
+    mScriptObject = aScriptObject;
+    return NS_OK;
+}
+
+
+// Implementation methods
+
+void
+nsXULAttribute::GetQualifiedName(nsString& aQualifiedName)
+{
+    aQualifiedName.Truncate();
+    if ((mNameSpaceID != kNameSpaceID_None) &&
+        (mNameSpaceID != kNameSpaceID_Unknown)) {
+        nsresult rv;
+
+        nsIAtom* prefix;
+        rv = mContent->GetNameSpacePrefixFromId(mNameSpaceID, prefix);
+
+        if (NS_SUCCEEDED(rv) && (prefix != nsnull)) {
+            const PRUnichar *unicodeString;
+            prefix->GetUnicode(&unicodeString);
+            aQualifiedName.Append(unicodeString);
+            aQualifiedName.Append(':');
+            NS_RELEASE(prefix);
+        }
+    }
+    const PRUnichar *unicodeString;
+    mName->GetUnicode(&unicodeString);
+    aQualifiedName.Append(unicodeString);
+}
+
+
+//----------------------------------------------------------------------
+//
+// nsXULAttributes
+//
+
+nsXULAttributes::nsXULAttributes(nsIContent* aContent)
+    : mContent(aContent),
+      mClassList(nsnull),
+      mStyleRule(nsnull),
+      mScriptObject(nsnull)
+{
+    NS_INIT_REFCNT();
+}
+
+
+nsXULAttributes::~nsXULAttributes()
+{
+    PRInt32 count = mAttributes.Count();
+    for (PRInt32 indx = 0; indx < count; indx++) {
+        nsXULAttribute* attr = NS_REINTERPRET_CAST(nsXULAttribute*, mAttributes.ElementAt(indx));
+        NS_RELEASE(attr);
+    }
+    delete mClassList;
+}
+
+
+nsresult
+nsXULAttributes::Create(nsIContent* aContent, nsXULAttributes** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    if (! (*aResult = new nsXULAttributes(aContent)))
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aResult);
+    return NS_OK;
+}
+
+
+// nsISupports interface
+
+NS_IMPL_ADDREF(nsXULAttributes);
+NS_IMPL_RELEASE(nsXULAttributes);
+
+NS_IMETHODIMP
+nsXULAttributes::QueryInterface(REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    if (aIID.Equals(nsIDOMNamedNodeMap::GetIID()) ||
+        aIID.Equals(kISupportsIID)) {
+        *aResult = NS_STATIC_CAST(nsIDOMNamedNodeMap*, this);
+        NS_ADDREF(this);
+        return NS_OK;
+    }
+    else if (aIID.Equals(nsIScriptObjectOwner::GetIID())) {
+        *aResult = NS_STATIC_CAST(nsIScriptObjectOwner*, this);
+        NS_ADDREF(this);
+        return NS_OK;
+    }
+    else {
+        *aResult = nsnull;
+        return NS_NOINTERFACE;
+    }
+}
+
+
+// nsIDOMNamedNodeMap interface
+
+NS_IMETHODIMP
+nsXULAttributes::GetLength(PRUint32* aLength)
+{
+    NS_PRECONDITION(aLength != nsnull, "null ptr");
+    if (! aLength)
+        return NS_ERROR_NULL_POINTER;
+
+    *aLength = mAttributes.Count();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttributes::GetNamedItem(const nsString& aName, nsIDOMNode** aReturn)
+{
+    NS_PRECONDITION(aReturn != nsnull, "null ptr");
+    if (! aReturn)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    *aReturn = nsnull;
+
+    PRInt32 nameSpaceID;
+    nsIAtom* name;
+
+    if (NS_FAILED(rv = mContent->ParseAttributeString(aName, name, nameSpaceID)))
+        return rv;
+
+    if (kNameSpaceID_Unknown == nameSpaceID) {
+      nameSpaceID = kNameSpaceID_None;  // ignore unknown prefix XXX is this correct?
+    }
+    // XXX doing this instead of calling mContent->GetAttribute() will
+    // make it a lot harder to lazily instantiate properties from the
+    // graph. The problem is, how else do we get the named item?
+    for (PRInt32 i = mAttributes.Count() - 1; i >= 0; --i) {
+        nsXULAttribute* attr = (nsXULAttribute*) mAttributes[i];
+        if (((nameSpaceID == attr->GetNameSpaceID()) ||
+             (nameSpaceID == kNameSpaceID_Unknown) ||
+             (nameSpaceID == kNameSpaceID_None)) &&
+            (name == attr->GetName())) {
+            NS_ADDREF(attr);
+            *aReturn = attr;
+            break;
+        }
+    }
+
+    NS_RELEASE(name);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULAttributes::SetNamedItem(nsIDOMNode* aArg, nsIDOMNode** aReturn)
+{
+    NS_NOTYETIMPLEMENTED("write me");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsXULAttributes::RemoveNamedItem(const nsString& aName, nsIDOMNode** aReturn)
+{
+    nsCOMPtr<nsIDOMElement> element( do_QueryInterface(mContent) );
+    if (element) {
+        return element->RemoveAttribute(aName);
+        *aReturn = nsnull; // XXX should be the element we just removed
+        return NS_OK;
+    }
+    else {
+        return NS_ERROR_FAILURE;
+    }
+}
+
+NS_IMETHODIMP
+nsXULAttributes::Item(PRUint32 aIndex, nsIDOMNode** aReturn)
+{
+    *aReturn = (nsXULAttribute*) mAttributes[aIndex];
+    NS_IF_ADDREF(*aReturn);
+    return NS_OK;
+}
+
+
+
+
+// nsIScriptObjectOwner interface
+
+NS_IMETHODIMP
+nsXULAttributes::GetScriptObject(nsIScriptContext* aContext, void** aScriptObject)
+{
+    nsresult rv = NS_OK;
+    if (! mScriptObject) {
+        nsIDOMScriptObjectFactory *factory;
+    
+        rv = nsServiceManager::GetService(kDOMScriptObjectFactoryCID,
+                                          nsIDOMScriptObjectFactory::GetIID(),
+                                          (nsISupports **)&factory);
+
+        if (NS_FAILED(rv))
+            return rv;
+
+        rv = factory->NewScriptNamedNodeMap(aContext, 
+                                            (nsISupports*)(nsIDOMNamedNodeMap*) this, 
+                                            (nsISupports*) mContent,
+                                            (void**) &mScriptObject);
+
+        nsServiceManager::ReleaseService(kDOMScriptObjectFactoryCID, factory);
+    }
+
+    *aScriptObject = mScriptObject;
+    return rv;
+}
+
+NS_IMETHODIMP
+nsXULAttributes::SetScriptObject(void *aScriptObject)
+{
+    mScriptObject = aScriptObject;
+    return NS_OK;
+}
+
+// Implementation methods
+
+nsresult 
+nsXULAttributes::GetClasses(nsVoidArray& aArray) const
+{
+    return nsClassList::GetClasses(mClassList, aArray);
+}
+
+nsresult 
+nsXULAttributes::HasClass(nsIAtom* aClass) const
+{
+    return nsClassList::HasClass(mClassList, aClass) ? NS_OK : NS_COMFALSE;
+}
+
+nsresult nsXULAttributes::SetClassList(nsClassList* aClassList)
+{
+    delete mClassList;
+    if (aClassList) {
+        mClassList = new nsClassList(*aClassList);
+    }
+    else {
+        mClassList = nsnull;
+    }
+    return NS_OK;
+}
+
+nsresult nsXULAttributes::UpdateClassList(const nsString& aValue)
+{
+    return nsClassList::ParseClasses(&mClassList, aValue);
+}
+
+nsresult nsXULAttributes::UpdateStyleRule(nsIURI* aDocURL, const nsString& aValue)
+{
+    if (aValue == "")
+    {
+      // XXX: Removing the rule. Is this sufficient?
+      mStyleRule = nsnull;
+      return NS_OK;
+    }
+
+    nsCOMPtr<nsICSSParser> css;
+    nsresult result = nsComponentManager::CreateInstance(kCSSParserCID,
+                                                         nsnull,
+                                                         kICSSParserIID,
+                                                         getter_AddRefs(css));
+    if (NS_OK != result) {
+      return result;
+    }
+
+    nsCOMPtr<nsIStyleRule> rule;
+    result = css->ParseDeclarations(aValue, aDocURL, *getter_AddRefs(rule));
+    
+    if ((NS_OK == result) && rule) {
+      mStyleRule = rule;
+    }
+
+    return NS_OK;
+}
+
+
+nsresult nsXULAttributes::SetInlineStyleRule(nsIStyleRule* aRule)
+{
+    mStyleRule = aRule;
+    return NS_OK;
+}
+
+nsresult nsXULAttributes::GetInlineStyleRule(nsIStyleRule*& aRule)
+{
+  nsresult result = NS_ERROR_NULL_POINTER;
+  if (mStyleRule != nsnull)
+  {
+    aRule = mStyleRule;
+    NS_ADDREF(aRule);
+    result = NS_OK;
+  }
+
+  return result;
+}
+

mozilla/content/xul/content/src/nsXULAttributes.h

@@ -0,0 +1,194 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+/*
+
+  A set of helper classes used to implement attributes.
+
+*/
+
+#ifndef nsXULAttributes_h__
+#define nsXULAttributes_h__
+
+#include "nsIDOMAttr.h"
+#include "nsIDOMNamedNodeMap.h"
+#include "nsIScriptObjectOwner.h"
+#include "nsIStyleRule.h"
+#include "nsString.h"
+#include "nsIAtom.h"
+#include "nsVoidArray.h"
+
+class nsIURI;
+
+//----------------------------------------------------------------------
+
+class nsClassList {
+public:
+    nsClassList(nsIAtom* aAtom)
+        : mAtom(aAtom), mNext(nsnull)
+    {
+        MOZ_COUNT_CTOR(nsClassList);
+    }
+
+
+    nsClassList(const nsClassList& aCopy)
+        : mAtom(aCopy.mAtom), mNext(nsnull)
+    {
+        MOZ_COUNT_CTOR(nsClassList);
+        if (aCopy.mNext) mNext = new nsClassList(*(aCopy.mNext));
+    }
+
+    nsClassList& operator=(const nsClassList& aClassList)
+    {
+        if (this != &aClassList) {
+            delete mNext;
+            mNext = nsnull;
+            mAtom = aClassList.mAtom;
+
+            if (aClassList.mNext) {
+                mNext = new nsClassList(*(aClassList.mNext));
+            }
+        }
+        return *this;
+    }
+
+    ~nsClassList(void)
+    {
+        MOZ_COUNT_DTOR(nsClassList);
+        delete mNext;
+    }
+
+    nsCOMPtr<nsIAtom> mAtom;
+    nsClassList*      mNext;
+
+    static PRBool
+    HasClass(nsClassList* aList, nsIAtom* aClass);
+
+    static nsresult
+    GetClasses(nsClassList* aList, nsVoidArray& aArray);
+
+    static nsresult
+    ParseClasses(nsClassList** aList, const nsString& aValue);
+};
+
+////////////////////////////////////////////////////////////////////////
+
+class nsXULAttribute : public nsIDOMAttr,
+                       public nsIScriptObjectOwner
+{
+protected:
+    nsXULAttribute(nsIContent* aContent,
+                   PRInt32 aNameSpaceID,
+                   nsIAtom* aName,
+                   const nsString& aValue);
+
+    virtual ~nsXULAttribute();
+
+public:
+    static nsresult
+    Create(nsIContent* aContent,
+           PRInt32 aNameSpaceID,
+           nsIAtom* aName,
+           const nsString& aValue,
+           nsXULAttribute** aResult);
+
+    // nsISupports interface
+    NS_DECL_ISUPPORTS
+
+    // nsIDOMNode interface
+    NS_DECL_IDOMNODE
+
+    // nsIDOMAttr interface
+    NS_DECL_IDOMATTR
+
+    // nsIScriptObjectOwner interface
+    NS_IMETHOD GetScriptObject(nsIScriptContext* aContext, void** aScriptObject);
+    NS_IMETHOD SetScriptObject(void *aScriptObject);
+
+    // Implementation methods
+    void GetQualifiedName(nsString& aAttributeName);
+
+    PRInt32 GetNameSpaceID() const { return mNameSpaceID; }
+    nsIAtom* GetName() const { return mName; }
+    void SetValueInternal(const nsString& aValue) { mValue = aValue; }
+
+protected:
+    PRInt32     mNameSpaceID;
+    nsIAtom*    mName;
+    nsString    mValue;
+    nsIContent* mContent;
+    void*       mScriptObject;
+};
+
+
+////////////////////////////////////////////////////////////////////////
+
+class nsXULAttributes : public nsIDOMNamedNodeMap,
+                        public nsIScriptObjectOwner
+{
+public:
+    static nsresult
+    Create(nsIContent* aElement, nsXULAttributes** aResult);
+
+    // nsISupports interface
+    NS_DECL_ISUPPORTS
+
+    // nsIDOMNamedNodeMap interface
+    NS_DECL_IDOMNAMEDNODEMAP
+
+    // nsIScriptObjectOwner interface
+    NS_IMETHOD GetScriptObject(nsIScriptContext* aContext, void** aScriptObject);
+    NS_IMETHOD SetScriptObject(void *aScriptObject);
+
+    // Implementation methods
+    // VoidArray Helpers
+    PRInt32 Count() { return mAttributes.Count(); };
+    nsXULAttribute* ElementAt(PRInt32 i) { return (nsXULAttribute*)mAttributes.ElementAt(i); };
+    void AppendElement(nsXULAttribute* aElement) { mAttributes.AppendElement((void*)aElement); };
+    void RemoveElementAt(PRInt32 aIndex) { mAttributes.RemoveElementAt(aIndex); };
+
+    // Style Helpers
+    nsresult GetClasses(nsVoidArray& aArray) const;
+    nsresult HasClass(nsIAtom* aClass) const;
+
+    nsresult SetClassList(nsClassList* aClassList);
+    nsresult UpdateClassList(const nsString& aValue);
+    nsresult UpdateStyleRule(nsIURI* aDocURL, const nsString& aValue);
+
+    nsresult SetInlineStyleRule(nsIStyleRule* aRule);
+    nsresult GetInlineStyleRule(nsIStyleRule*& aRule);
+
+protected:
+    nsXULAttributes(nsIContent* aContent);
+    virtual ~nsXULAttributes();
+
+    nsIContent*            mContent;
+    nsClassList*           mClassList;
+    nsCOMPtr<nsIStyleRule> mStyleRule;
+    nsVoidArray            mAttributes;
+    void*                  mScriptObject;
+};
+
+
+#endif // nsXULAttributes_h__
+

mozilla/content/xul/content/src/nsXULElement.h

@@ -0,0 +1,509 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+  The base XUL element class and associates.
+
+*/
+
+#ifndef nsXULElement_h__
+#define nsXULElement_h__
+
+// XXX because nsIEventListenerManager has broken includes
+#include "nslayout.h" 
+#include "nsIDOMEvent.h"
+
+#include "nsForwardReference.h"
+#include "nsHTMLValue.h"
+#include "nsIAtom.h"
+#include "nsIControllers.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMEventReceiver.h"
+#include "nsIDOMXULElement.h"
+#include "nsIDOMXULTreeElement.h"
+#include "nsIEventListenerManager.h"
+#include "nsIFocusableContent.h"
+#include "nsIJSScriptObject.h"
+#include "nsINameSpace.h"
+#include "nsINameSpaceManager.h"
+#include "nsIRDFCompositeDataSource.h"
+#include "nsIRDFResource.h"
+#include "nsIScriptObjectOwner.h"
+#include "nsIStyleRule.h"
+#include "nsIStyledContent.h"
+#include "nsIURI.h"
+#include "nsIXMLContent.h"
+#include "nsIXULContent.h"
+#include "nsXULAttributes.h"
+
+class nsIDocument;
+class nsIRDFService;
+class nsISupportsArray;
+class nsIXULContentUtils;
+class nsIXULPrototypeDocument;
+class nsRDFDOMNodeList;
+class nsString;
+class nsVoidArray;
+class nsXULAttributes;
+
+////////////////////////////////////////////////////////////////////////
+
+/**
+
+  A prototype attribute for an nsXULPrototypeElement.
+
+ */
+
+class nsXULPrototypeAttribute
+{
+public:
+    nsXULPrototypeAttribute() : mNameSpaceID(kNameSpaceID_Unknown) {}
+
+    PRInt32           mNameSpaceID;
+    nsCOMPtr<nsIAtom> mName;
+    nsString          mValue;
+};
+
+
+/**
+
+  A prototype content model element that holds the "primordial" values
+  that have been parsed from the original XUL document. A
+  'lightweight' nsXULElement may delegate its representation to this
+  structure, which is shared.
+
+ */
+
+class nsXULPrototypeElement;
+
+class nsXULPrototypeNode
+{
+public:
+    enum Type { eType_Element, eType_Script, eType_Text };
+
+    Type                     mType;
+    PRInt32                  mLineNo;
+
+    virtual ~nsXULPrototypeNode() {}
+
+protected:
+    nsXULPrototypeNode(Type aType, PRInt32 aLineNo)
+        : mType(aType), mLineNo(aLineNo) {}
+};
+
+class nsXULPrototypeElement : public nsXULPrototypeNode
+{
+public:
+    nsXULPrototypeElement(PRInt32 aLineNo)
+        : nsXULPrototypeNode(eType_Element, aLineNo),
+          mDocument(nsnull),
+          mNumChildren(0),
+          mChildren(nsnull),
+          mNumAttributes(0),
+          mAttributes(nsnull),
+          mClassList(nsnull)
+    {
+        MOZ_COUNT_CTOR(nsXULPrototypeElement);
+    }
+
+    virtual ~nsXULPrototypeElement()
+    {
+        MOZ_COUNT_DTOR(nsXULPrototypeElement);
+
+        delete[] mAttributes;
+        delete mClassList;
+
+        for (PRInt32 i = mNumChildren - 1; i >= 0; --i)
+            delete mChildren[i];
+
+        delete[] mChildren;
+    }
+
+
+    nsIXULPrototypeDocument* mDocument;           // [WEAK] because doc is refcounted
+    PRInt32                  mNumChildren;
+    nsXULPrototypeNode**     mChildren;           // [OWNER]
+
+    nsCOMPtr<nsINameSpace>   mNameSpace;          // [OWNER]
+    nsCOMPtr<nsIAtom>        mNameSpacePrefix;    // [OWNER]
+    PRInt32                  mNameSpaceID;
+    nsCOMPtr<nsIAtom>        mTag;                // [OWNER]
+
+    PRInt32                  mNumAttributes;
+    nsXULPrototypeAttribute* mAttributes;         // [OWNER]
+
+    nsCOMPtr<nsIStyleRule>   mInlineStyleRule;    // [OWNER]
+    nsClassList*             mClassList;
+
+    nsresult GetAttribute(PRInt32 aNameSpaceID, nsIAtom* aName, nsString& aValue);
+};
+
+struct JSRuntime;
+struct JSObject;
+class nsXULDocument;
+
+class nsXULPrototypeScript : public nsXULPrototypeNode
+{
+public:
+    nsXULPrototypeScript(PRInt32 aLineNo, const char *aVersion);
+    virtual ~nsXULPrototypeScript();
+
+    nsresult Compile(const PRUnichar* aText, PRInt32 aTextLength,
+                     nsIURI* aURI, PRInt32 aLineNo,
+                     nsIDocument* aDocument);
+
+    nsCOMPtr<nsIURI>         mSrcURI;
+    PRBool                   mSrcLoading;
+    nsXULDocument*           mSrcLoadWaiters;   // [OWNER] but not COMPtr
+    JSRuntime*               mScriptRuntime;    // XXX use service, save space?
+    JSObject*                mScriptObject;
+    const char*              mLangVersion;
+};
+
+class nsXULPrototypeText : public nsXULPrototypeNode
+{
+public:
+    nsXULPrototypeText(PRInt32 aLineNo)
+        : nsXULPrototypeNode(eType_Text, aLineNo)
+    {
+        MOZ_COUNT_CTOR(nsXULPrototypeText);
+    }
+
+    virtual ~nsXULPrototypeText()
+    {
+        MOZ_COUNT_DTOR(nsXULPrototypeText);
+    }
+
+    nsString                 mValue;
+};
+
+
+////////////////////////////////////////////////////////////////////////
+
+/**
+
+  This class serves as a base for aggregates that will implement a
+  per-element XUL API.
+
+ */
+
+class nsXULAggregateElement : public nsISupports
+{
+protected:
+    nsIDOMXULElement* mOuter;
+    nsXULAggregateElement(nsIDOMXULElement* aOuter) : mOuter(aOuter) {}
+    
+public:
+    virtual ~nsXULAggregateElement() {};
+
+    // nsISupports interface. Subclasses should use the
+    // NS_DECL/IMPL_ISUPPORTS_INHERITED macros to implement the
+    // nsISupports interface.
+    NS_IMETHOD_(nsrefcnt) AddRef() {
+        return mOuter->AddRef();
+    }
+
+    NS_IMETHOD_(nsrefcnt) Release() {
+        return mOuter->Release();
+    }
+
+    NS_IMETHOD QueryInterface(REFNSIID aIID, void** aResult) {
+        return mOuter->QueryInterface(aIID, aResult);
+    }
+};
+
+
+////////////////////////////////////////////////////////////////////////
+
+/**
+
+  The XUL element.
+
+ */
+
+class nsXULElement : public nsIStyledContent,
+                     public nsIXMLContent,
+                     public nsIXULContent,
+                     public nsIFocusableContent,
+                     public nsIDOMXULElement,
+                     public nsIDOMEventReceiver,
+                     public nsIScriptObjectOwner,
+                     public nsIJSScriptObject,
+                     public nsIStyleRule
+{
+public:
+protected:
+    // pseudo-constants
+    static nsrefcnt             gRefCnt;
+    static nsIRDFService*       gRDFService;
+    static nsINameSpaceManager* gNameSpaceManager;
+    static nsIXULContentUtils*  gXULUtils;
+    static PRInt32              kNameSpaceID_RDF;
+    static PRInt32              kNameSpaceID_XUL;
+
+    static nsIAtom*             kClassAtom;
+    static nsIAtom*             kContextAtom;
+    static nsIAtom*             kIdAtom;
+    static nsIAtom*             kObservesAtom;
+    static nsIAtom*             kPopupAtom;
+    static nsIAtom*             kRefAtom;
+    static nsIAtom*             kSelectedAtom;
+    static nsIAtom*             kStyleAtom;
+    static nsIAtom*             kTitledButtonAtom;
+    static nsIAtom*             kTooltipAtom;
+    static nsIAtom*             kTreeAtom;
+    static nsIAtom*             kTreeCellAtom;
+    static nsIAtom*             kTreeChildrenAtom;
+    static nsIAtom*             kTreeColAtom;
+    static nsIAtom*             kTreeItemAtom;
+    static nsIAtom*             kTreeRowAtom;
+    static nsIAtom*             kEditorAtom;
+    static nsIAtom*             kWindowAtom;
+
+public:
+    static nsresult
+    Create(nsXULPrototypeElement* aPrototype, nsIDocument* aDocument, PRBool aIsScriptable, nsIContent** aResult);
+
+    static nsresult
+    Create(PRInt32 aNameSpaceID, nsIAtom* aTag, nsIContent** aResult);
+
+    // nsISupports
+    NS_DECL_ISUPPORTS
+       
+    // nsIContent (from nsIStyledContent)
+    NS_IMETHOD GetDocument(nsIDocument*& aResult) const;
+    NS_IMETHOD SetDocument(nsIDocument* aDocument, PRBool aDeep);
+    NS_IMETHOD GetParent(nsIContent*& aResult) const;
+    NS_IMETHOD SetParent(nsIContent* aParent);
+    NS_IMETHOD CanContainChildren(PRBool& aResult) const;
+    NS_IMETHOD ChildCount(PRInt32& aResult) const;
+    NS_IMETHOD ChildAt(PRInt32 aIndex, nsIContent*& aResult) const;
+    NS_IMETHOD IndexOf(nsIContent* aPossibleChild, PRInt32& aResult) const;
+    NS_IMETHOD InsertChildAt(nsIContent* aKid, PRInt32 aIndex, PRBool aNotify);
+    NS_IMETHOD ReplaceChildAt(nsIContent* aKid, PRInt32 aIndex, PRBool aNotify);
+    NS_IMETHOD AppendChildTo(nsIContent* aKid, PRBool aNotify);
+    NS_IMETHOD RemoveChildAt(PRInt32 aIndex, PRBool aNotify);
+    NS_IMETHOD IsSynthetic(PRBool& aResult);
+    NS_IMETHOD GetNameSpaceID(PRInt32& aNameSpeceID) const;
+    NS_IMETHOD GetTag(nsIAtom*& aResult) const;
+    NS_IMETHOD ParseAttributeString(const nsString& aStr, nsIAtom*& aName, PRInt32& aNameSpaceID);
+    NS_IMETHOD GetNameSpacePrefixFromId(PRInt32 aNameSpaceID, nsIAtom*& aPrefix);
+    NS_IMETHOD SetAttribute(PRInt32 aNameSpaceID, nsIAtom* aName, const nsString& aValue, PRBool aNotify);
+    NS_IMETHOD GetAttribute(PRInt32 aNameSpaceID, nsIAtom* aName, nsString& aResult) const;
+    NS_IMETHOD UnsetAttribute(PRInt32 aNameSpaceID, nsIAtom* aName, PRBool aNotify);
+    NS_IMETHOD GetAttributeNameAt(PRInt32 aIndex, PRInt32& aNameSpaceID, 
+                                  nsIAtom*& aName) const;
+    NS_IMETHOD GetAttributeCount(PRInt32& aResult) const;
+    NS_IMETHOD List(FILE* out, PRInt32 aIndent) const;
+    NS_IMETHOD BeginConvertToXIF(nsXIFConverter& aConverter) const;
+    NS_IMETHOD ConvertContentToXIF(nsXIFConverter& aConverter) const;
+    NS_IMETHOD FinishConvertToXIF(nsXIFConverter& aConverter) const;
+    NS_IMETHOD SizeOf(nsISizeOfHandler* aSizer, PRUint32* aResult) const;
+    NS_IMETHOD HandleDOMEvent(nsIPresContext& aPresContext,
+                              nsEvent* aEvent,
+                              nsIDOMEvent** aDOMEvent,
+                              PRUint32 aFlags,
+                              nsEventStatus& aEventStatus);
+
+    NS_IMETHOD GetContentID(PRUint32* aID);
+    NS_IMETHOD SetContentID(PRUint32 aID);
+
+    NS_IMETHOD RangeAdd(nsIDOMRange& aRange);
+    NS_IMETHOD RangeRemove(nsIDOMRange& aRange); 
+    NS_IMETHOD GetRangeList(nsVoidArray*& aResult) const;
+
+    // nsIStyledContent
+    NS_IMETHOD GetID(nsIAtom*& aResult) const;
+    NS_IMETHOD GetClasses(nsVoidArray& aArray) const;
+    NS_IMETHOD HasClass(nsIAtom* aClass) const;
+
+    NS_IMETHOD GetContentStyleRules(nsISupportsArray* aRules);
+    NS_IMETHOD GetInlineStyleRules(nsISupportsArray* aRules);
+    NS_IMETHOD GetMappedAttributeImpact(const nsIAtom* aAttribute,
+                                        PRInt32& aHint) const;
+
+    // nsIXMLContent
+    NS_IMETHOD SetContainingNameSpace(nsINameSpace* aNameSpace);
+    NS_IMETHOD GetContainingNameSpace(nsINameSpace*& aNameSpace) const;
+    NS_IMETHOD SetNameSpacePrefix(nsIAtom* aNameSpace);
+    NS_IMETHOD GetNameSpacePrefix(nsIAtom*& aNameSpace) const;
+    NS_IMETHOD SetNameSpaceID(PRInt32 aNameSpaceID);
+
+    // nsIXULContent
+    NS_IMETHOD PeekChildCount(PRInt32& aCount) const;
+    NS_IMETHOD SetLazyState(PRInt32 aFlags);
+    NS_IMETHOD ClearLazyState(PRInt32 aFlags);
+    NS_IMETHOD GetLazyState(PRInt32 aFlag, PRBool& aValue);
+    NS_IMETHOD AddScriptEventListener(nsIAtom* aName, const nsString& aValue, REFNSIID aIID);
+    NS_IMETHOD ForceElementToOwnResource(PRBool aForce);
+
+    // nsIFocusableContent interface
+    NS_IMETHOD SetFocus(nsIPresContext* aPresContext);
+    NS_IMETHOD RemoveFocus(nsIPresContext* aPresContext);
+
+    // nsIDOMNode (from nsIDOMElement)
+    NS_DECL_IDOMNODE
+  
+    // nsIDOMElement
+    NS_DECL_IDOMELEMENT
+
+    // nsIDOMXULElement
+    NS_DECL_IDOMXULELEMENT
+
+    // nsIDOMEventTarget interface (from nsIDOMEventReceiver)
+    NS_IMETHOD AddEventListener(const nsString& aType, nsIDOMEventListener* aListener, 
+                                PRBool aUseCapture);
+    NS_IMETHOD RemoveEventListener(const nsString& aType, nsIDOMEventListener* aListener, 
+                                   PRBool aUseCapture);
+
+    // nsIDOMEventReceiver
+    NS_IMETHOD AddEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID);
+    NS_IMETHOD RemoveEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID);
+    NS_IMETHOD GetListenerManager(nsIEventListenerManager** aInstancePtrResult);
+    NS_IMETHOD GetNewListenerManager(nsIEventListenerManager **aInstancePtrResult);
+
+    // nsIScriptObjectOwner
+    NS_IMETHOD GetScriptObject(nsIScriptContext* aContext, void** aScriptObject);
+    NS_IMETHOD SetScriptObject(void *aScriptObject);
+
+    // nsIJSScriptObject
+    virtual PRBool AddProperty(JSContext *aContext, jsval aID, jsval *aVp);
+    virtual PRBool DeleteProperty(JSContext *aContext, jsval aID, jsval *aVp);
+    virtual PRBool GetProperty(JSContext *aContext, jsval aID, jsval *aVp);
+    virtual PRBool SetProperty(JSContext *aContext, jsval aID, jsval *aVp);
+    virtual PRBool EnumerateProperty(JSContext *aContext);
+    virtual PRBool Resolve(JSContext *aContext, jsval aID);
+    virtual PRBool Convert(JSContext *aContext, jsval aID);
+    virtual void   Finalize(JSContext *aContext);
+
+    // nsIStyleRule interface. The node implements this to deal with attributes that
+    // need to be mapped into style contexts (e.g., width in treecols).
+    NS_IMETHOD GetStyleSheet(nsIStyleSheet*& aSheet) const;
+    NS_IMETHOD GetStrength(PRInt32& aStrength) const;
+    NS_IMETHOD MapFontStyleInto(nsIMutableStyleContext* aContext, nsIPresContext* aPresContext);
+    NS_IMETHOD MapStyleInto(nsIMutableStyleContext* aContext, nsIPresContext* aPresContext);
+    
+protected:
+    nsXULElement();
+    nsresult Init();
+    virtual ~nsXULElement(void);
+
+
+    // Implementation methods
+    nsresult EnsureContentsGenerated(void) const;
+
+    nsresult ExecuteOnBroadcastHandler(nsIDOMElement* anElement, const nsString& attrName);
+
+    PRBool ElementIsInDocument();
+
+    static nsresult
+    ExecuteJSCode(nsIDOMElement* anElement, nsEvent* aEvent);
+
+    // Used with treecol width attributes
+    static PRBool ParseNumericValue(const nsString& aString,
+                                  PRInt32& aIntValue,
+                                  float& aFloatValue,
+                                  nsHTMLUnit& aValueUnit);
+
+    // Static helpers
+    static nsresult
+    GetElementsByTagName(nsIDOMNode* aNode,
+                         const nsString& aTagName,
+                         nsRDFDOMNodeList* aElements);
+
+    static nsresult
+    GetElementsByAttribute(nsIDOMNode* aNode,
+                           const nsString& aAttributeName,
+                           const nsString& aAttributeValue,
+                           nsRDFDOMNodeList* aElements);
+
+    static PRBool IsAncestor(nsIDOMNode* aParentNode, nsIDOMNode* aChildNode);
+
+    // Helper routine that crawls a parent chain looking for a tree element.
+    NS_IMETHOD GetParentTree(nsIDOMXULTreeElement** aTreeElement);
+
+    PRBool IsFocusableContent();
+
+    nsresult AddPopupListener(nsIAtom* aName);
+
+protected:
+    // Required fields
+    nsXULPrototypeElement*              mPrototype;
+    nsIDocument*                        mDocument;           // [WEAK]
+    nsIContent*                         mParent;             // [WEAK]
+    nsCOMPtr<nsISupportsArray>          mChildren;           // [OWNER]
+    nsCOMPtr<nsIEventListenerManager>   mListenerManager;    // [OWNER]
+    void*                               mScriptObject;       // [OWNER]
+
+    // The state of our sloth for lazy content model construction via
+    // RDF; see nsIXULContent and nsRDFGenericBuilder.
+    PRInt32                             mLazyState;
+
+    // Lazily instantiated if/when object is mutated. Instantiating
+    // the mSlots makes an nsXULElement 'heavyweight'.
+    struct Slots {
+        Slots(nsXULElement* mElement);
+        ~Slots();
+
+        nsXULElement*                       mElement;            // [WEAK]
+        PRInt32                             mNameSpaceID;
+        nsCOMPtr<nsINameSpace>              mNameSpace;          // [OWNER]
+        nsCOMPtr<nsIAtom>                   mNameSpacePrefix;    // [OWNER]
+        nsCOMPtr<nsIAtom>                   mTag;                // [OWNER]
+        nsVoidArray*                        mBroadcastListeners; // [WEAK]
+        nsIDOMXULElement*                   mBroadcaster;        // [WEAK]
+        nsCOMPtr<nsIControllers>            mControllers;        // [OWNER]
+        nsCOMPtr<nsIRDFCompositeDataSource> mDatabase;           // [OWNER]
+        nsCOMPtr<nsIRDFResource>            mOwnedResource;      // [OWNER]
+        nsXULAttributes*                    mAttributes;
+
+        // An unreferenced bare pointer to an aggregate that can
+        // implement element-specific APIs.
+        nsXULAggregateElement*              mInnerXULElement;
+    };
+
+    friend struct Slots;
+    Slots* mSlots;
+    nsresult EnsureSlots();
+
+
+protected:
+    // Internal accessors. These shadow the 'Slots', and return
+    // appropriate default values if there are no slots defined in the
+    // delegate.
+    PRInt32                    NameSpaceID() const     { return mSlots ? mSlots->mNameSpaceID           : mPrototype->mNameSpaceID; }
+    nsINameSpace*              NameSpace() const       { return mSlots ? mSlots->mNameSpace.get()       : mPrototype->mNameSpace.get(); }
+    nsIAtom*                   NameSpacePrefix() const { return mSlots ? mSlots->mNameSpacePrefix.get() : mPrototype->mNameSpacePrefix.get(); }
+    nsIAtom*                   Tag() const             { return mSlots ? mSlots->mTag.get()             : mPrototype->mTag.get(); }
+    nsVoidArray*               BroadcastListeners() const { return mSlots ? mSlots->mBroadcastListeners       : nsnull; }
+    nsIDOMXULElement*          Broadcaster() const        { return mSlots ? mSlots->mBroadcaster              : nsnull; }
+    nsIControllers*            Controllers() const        { return mSlots ? mSlots->mControllers.get()        : nsnull; }
+    nsIRDFCompositeDataSource* Database() const           { return mSlots ? mSlots->mDatabase.get()           : nsnull; }
+    nsIRDFResource*            OwnedResource() const      { return mSlots ? mSlots->mOwnedResource.get()      : nsnull; }
+    nsXULAttributes*           Attributes() const         { return mSlots ? mSlots->mAttributes               : nsnull; }
+    nsXULAggregateElement*     InnerXULElement() const    { return mSlots ? mSlots->mInnerXULElement          : nsnull; }
+
+};
+
+
+#endif // nsXULElement_h__

mozilla/content/xul/content/src/nsXULPopupListener.cpp

@@ -0,0 +1,548 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+  This file provides the implementation for xul popup listener which
+  tracks xul popups, context menus, and tooltips
+ */
+
+#include "nsCOMPtr.h"
+#include "nsIDOMElement.h"
+#include "nsIXULPopupListener.h"
+#include "nsIDOMMouseListener.h"
+#include "nsIDOMMouseMotionListener.h"
+#include "nsRDFCID.h"
+
+#include "nsIScriptGlobalObject.h"
+#include "nsIDOMWindow.h"
+#include "nsIScriptContextOwner.h"
+#include "nsIDOMXULDocument.h"
+#include "nsIDocument.h"
+#include "nsIContent.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsITimer.h"
+
+
+////////////////////////////////////////////////////////////////////////
+
+static NS_DEFINE_IID(kXULPopupListenerCID,      NS_XULPOPUPLISTENER_CID);
+static NS_DEFINE_IID(kIXULPopupListenerIID,     NS_IXULPOPUPLISTENER_IID);
+static NS_DEFINE_IID(kISupportsIID,           NS_ISUPPORTS_IID);
+
+static NS_DEFINE_IID(kIDomEventListenerIID,   NS_IDOMEVENTLISTENER_IID);
+
+
+////////////////////////////////////////////////////////////////////////
+// PopupListenerImpl
+//
+//   This is the popup listener implementation for popup menus, context menus,
+//   and tooltips.
+//
+class XULPopupListenerImpl : public nsIXULPopupListener,
+                             public nsIDOMMouseListener,
+                             public nsIDOMMouseMotionListener
+{
+public:
+    XULPopupListenerImpl(void);
+    virtual ~XULPopupListenerImpl(void);
+
+public:
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    // nsIXULPopupListener
+    NS_IMETHOD Init(nsIDOMElement* aElement, const XULPopupType& popupType);
+
+    // nsIDOMMouseListener
+    virtual nsresult MouseDown(nsIDOMEvent* aMouseEvent);
+    virtual nsresult MouseUp(nsIDOMEvent* aMouseEvent) { return NS_OK; };
+    virtual nsresult MouseClick(nsIDOMEvent* aMouseEvent) { return NS_OK; };
+    virtual nsresult MouseDblClick(nsIDOMEvent* aMouseEvent) { return NS_OK; };
+    virtual nsresult MouseOver(nsIDOMEvent* aMouseEvent) { return NS_OK; };
+    virtual nsresult MouseOut(nsIDOMEvent* aMouseEvent) ;
+
+    // nsIDOMMouseMotionListener
+    virtual nsresult MouseMove(nsIDOMEvent* aMouseEvent);
+    virtual nsresult DragMove(nsIDOMEvent* aMouseEvent) { return NS_OK; };
+
+    // nsIDOMEventListener
+    virtual nsresult HandleEvent(nsIDOMEvent* anEvent) { return NS_OK; };
+
+protected:
+
+    virtual nsresult LaunchPopup(nsIDOMEvent* anEvent);
+    virtual nsresult LaunchPopup(PRInt32 aClientX, PRInt32 aClientY) ;
+
+    nsresult FindDocumentForNode(nsIDOMNode* inNode, nsIDOMXULDocument** outDoc) ;
+
+private:
+    // |mElement| is the node to which this listener is attached.
+    nsIDOMElement* mElement;               // Weak ref. The element will go away first.
+
+    // The popup that is getting shown on top of mElement.
+    nsIDOMElement* mPopupContent; 
+
+    // The type of the popup
+    XULPopupType popupType;
+    
+    // The following members are not used unless |popupType| is tooltip.
+      
+      // a timer for determining if a tooltip should be displayed. 
+    static void sTooltipCallback ( nsITimer *aTimer, void *aClosure ) ;
+    nsCOMPtr<nsITimer> mTooltipTimer;
+    PRInt32 mMouseClientX, mMouseClientY;       // mouse coordinates for tooltip event
+    
+    // The node hovered over that fired the timer. This may turn into the node that
+    // triggered the tooltip, but only if the timer ever gets around to firing.
+    nsIDOMNode* mPossibleTooltipNode;     // weak ref.
+        
+};
+
+////////////////////////////////////////////////////////////////////////
+
+
+XULPopupListenerImpl::XULPopupListenerImpl(void)
+  : mElement(nsnull), mPopupContent(nsnull),
+    mMouseClientX(0), mMouseClientY(0),
+    mPossibleTooltipNode(nsnull)
+{
+	NS_INIT_REFCNT();	
+}
+
+XULPopupListenerImpl::~XULPopupListenerImpl(void)
+{
+  //XXX do we need to close the popup here? Will we get the right events as
+  //XXX the topLevel window is going away when the closebox is pressed?
+
+#ifdef DEBUG_REFS
+    --gInstanceCount;
+    fprintf(stdout, "%d - RDF: XULPopupListenerImpl\n", gInstanceCount);
+#endif
+}
+
+NS_IMPL_ADDREF(XULPopupListenerImpl)
+NS_IMPL_RELEASE(XULPopupListenerImpl)
+
+NS_IMETHODIMP
+XULPopupListenerImpl::QueryInterface(REFNSIID iid, void** result)
+{
+    if (! result)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = nsnull;
+    if (iid.Equals(nsIXULPopupListener::GetIID()) ||
+        iid.Equals(kISupportsIID)) {
+        *result = NS_STATIC_CAST(nsIXULPopupListener*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+    else if (iid.Equals(nsIDOMMouseListener::GetIID())) {
+        *result = NS_STATIC_CAST(nsIDOMMouseListener*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+    else if (iid.Equals(nsIDOMMouseMotionListener::GetIID())) {
+        *result = NS_STATIC_CAST(nsIDOMMouseMotionListener*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+      // compiler problems with nsIDOMEventListener::GetIID() cause us to do it this
+      // way. Please excuse the lameness (hyatt and pinkerton).
+    else if (iid.Equals(kIDomEventListenerIID)) {
+        *result = (nsIDOMEventListener*)(nsIDOMMouseListener*)this;
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+
+    return NS_NOINTERFACE;
+}
+
+NS_IMETHODIMP
+XULPopupListenerImpl::Init(nsIDOMElement* aElement, const XULPopupType& popup)
+{
+  mElement = aElement; // Weak reference. Don't addref it.
+  popupType = popup;
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////
+// nsIDOMMouseListener
+
+nsresult
+XULPopupListenerImpl::MouseDown(nsIDOMEvent* aMouseEvent)
+{
+  PRUint16 button;
+
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent;
+  mouseEvent = do_QueryInterface(aMouseEvent);
+  if (!mouseEvent) {
+    //non-ui event passed in.  bad things.
+    return NS_OK;
+  }
+
+  // Get the node that was clicked on.
+  nsCOMPtr<nsIDOMNode> targetNode;        
+  mouseEvent->GetTarget( getter_AddRefs( targetNode ) );
+
+  // Get the document with the popup.
+  nsCOMPtr<nsIDocument> document;
+  nsCOMPtr<nsIContent> content = do_QueryInterface(mElement);
+  nsresult rv;
+  if (NS_FAILED(rv = content->GetDocument(*getter_AddRefs(document)))) {
+    NS_ERROR("Unable to retrieve the document.");
+    return rv;
+  }
+
+  // Turn the document into a XUL document so we can use SetPopupNode.
+  nsCOMPtr<nsIDOMXULDocument> xulDocument = do_QueryInterface(document);
+  if (xulDocument == nsnull) {
+    NS_ERROR("Popup attached to an element that isn't in XUL!");
+    return NS_ERROR_FAILURE;
+  }
+
+  // Store clicked-on node in xul document.
+  xulDocument->SetPopupNode( targetNode );
+
+  switch (popupType) {
+    case eXULPopupType_popup:
+      // Check for left mouse button down
+      mouseEvent->GetButton(&button);
+      if (button == 1) {
+        // Time to launch a popup menu.
+        LaunchPopup(aMouseEvent);
+      }
+      break;
+    case eXULPopupType_context:
+#ifdef	XP_MAC
+      // XXX: Handle Mac (currently checks if CTRL key is down)
+	    PRBool	ctrlKey = PR_FALSE;
+	    mouseEvent->GetCtrlKey(&ctrlKey);
+	    if (ctrlKey == PR_TRUE)
+#else
+      // Check for right mouse button down
+      mouseEvent->GetButton(&button);
+      if (button == 3)
+#endif
+      {
+        // Time to launch a context menu.
+        LaunchPopup(aMouseEvent);
+      }
+      break;
+    
+    case eXULPopupType_tooltip:
+    case eXULPopupType_blur:
+      // ignore
+      break;
+
+  }
+  return NS_OK;
+}
+
+
+//
+// MouseMove
+//
+// If we're a tooltip, fire off a timer to see if a tooltip should be shown.
+//
+nsresult
+XULPopupListenerImpl::MouseMove(nsIDOMEvent* aMouseEvent)
+{
+  // make sure we're a tooltip. if not, bail.
+  if ( popupType != eXULPopupType_tooltip )
+    return NS_OK;
+  
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(aMouseEvent) );
+  if (!mouseEvent)
+    return NS_OK;
+
+  // stash the coordinates of the event so that we can still get back to it from within the 
+  // timer scallback. Also stash the node that started this so we can put it into the
+  // document later on (if the timer ever fires).
+  mouseEvent->GetClientX(&mMouseClientX);
+  mouseEvent->GetClientY(&mMouseClientY);
+
+  //XXX recognize when a popup is already up and immediately show the
+  //XXX tooltip for the new item if the dom element is different than
+  //XXX the element for which we are currently displaying the tip.
+  //XXX
+  //XXX for now, just be stupid to get things working.
+  if (mPopupContent || mTooltipTimer)
+    return NS_OK;
+  
+  NS_NewTimer ( getter_AddRefs(mTooltipTimer) );
+  if ( mTooltipTimer ) {
+    nsCOMPtr<nsIDOMNode> eventTarget;
+    aMouseEvent->GetTarget(getter_AddRefs(eventTarget));
+    mPossibleTooltipNode = eventTarget.get();
+    mTooltipTimer->Init(sTooltipCallback, this, 500);   // 500 ms delay
+  }
+  else
+    NS_WARNING ( "Could not create a timer for tooltip tracking" );
+    
+  return NS_OK;
+  
+} // MouseMove
+
+
+//
+// MouseOut
+//
+// If we're a tooltip, hide any tip that might be showing and remove any
+// timer that is pending since the mouse is no longer over this area.
+//
+nsresult
+XULPopupListenerImpl::MouseOut(nsIDOMEvent* aMouseEvent)
+{
+  // make sure we're a tooltip. if not, bail.
+  if ( popupType != eXULPopupType_tooltip )
+    return NS_OK;
+  
+  if ( mTooltipTimer ) {
+    mTooltipTimer->Cancel();
+    mTooltipTimer = nsnull;
+  }
+  
+  if ( mPopupContent ) {
+    mPopupContent->RemoveAttribute("menugenerated");  // hide the popup
+    mPopupContent->RemoveAttribute("menuactive");
+
+    mPopupContent = nsnull;  // release the popup
+    
+    // clear out the tooltip node on the document
+    nsCOMPtr<nsIDOMNode> eventTarget;
+    aMouseEvent->GetTarget(getter_AddRefs(eventTarget));
+    nsCOMPtr<nsIDOMXULDocument> doc;
+    FindDocumentForNode ( eventTarget, getter_AddRefs(doc) );
+    if ( doc )
+      doc->SetTooltipNode(nsnull);
+  }
+  
+  return NS_OK;
+  
+} // MouseOut
+
+
+//
+// FindDocumentForNode
+//
+// Given a DOM content node, finds the XUL document associated with it
+//
+nsresult
+XULPopupListenerImpl :: FindDocumentForNode ( nsIDOMNode* inElement, nsIDOMXULDocument** outDoc )
+{
+  nsresult rv = NS_OK;
+  
+  if ( !outDoc || !inElement )
+    return NS_ERROR_INVALID_ARG;
+  
+  // get the document associated with this content element
+  nsCOMPtr<nsIDocument> document;
+  nsCOMPtr<nsIContent> content = do_QueryInterface(inElement);
+  if (!content)
+    return rv;
+
+  if (NS_FAILED(rv = content->GetDocument(*getter_AddRefs(document)))) {
+    NS_ERROR("Unable to retrieve the document.");
+    return rv;
+  }
+
+  // Turn the document into a XUL document so we can use getElementById
+  nsCOMPtr<nsIDOMXULDocument> xulDocument = do_QueryInterface(document);
+  if (xulDocument == nsnull) {
+    NS_ERROR("Popup attached to an element that isn't in XUL!");
+    return NS_ERROR_FAILURE;
+  }
+
+  *outDoc = xulDocument;
+  NS_ADDREF ( *outDoc );
+  
+  return rv;
+
+} // FindDocumentForNode
+
+
+//
+// LaunchPopup
+//
+nsresult
+XULPopupListenerImpl::LaunchPopup ( nsIDOMEvent* anEvent )
+{
+  // Retrieve our x and y position.
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(anEvent) );
+  if (!mouseEvent) {
+    //non-ui event passed in.  bad things.
+    return NS_OK;
+  }
+
+  PRInt32 xPos, yPos;
+  mouseEvent->GetClientX(&xPos); 
+  mouseEvent->GetClientY(&yPos); 
+
+  return LaunchPopup(xPos, yPos);
+}
+
+
+//
+// LaunchPopup
+//
+// Given the element on which the event was triggered and the mouse locations in
+// Client and widget coordinates, popup a new window showing the appropriate 
+// content.
+//
+// This looks for an attribute on |aElement| of the appropriate popup type 
+// (popup, context, tooltip) and uses that attribute's value as an ID for
+// the popup content in the document.
+//
+nsresult
+XULPopupListenerImpl::LaunchPopup(PRInt32 aClientX, PRInt32 aClientY)
+{
+  nsresult rv = NS_OK;
+
+  nsAutoString type("popup");
+  if ( popupType == eXULPopupType_context )
+    type = "context";
+  else if ( popupType == eXULPopupType_tooltip )
+    type = "tooltip";
+
+  nsAutoString identifier;
+  mElement->GetAttribute(type, identifier);
+
+  if (identifier == "")
+    return rv;
+
+  // Try to find the popup content and the document. We don't use FindDocumentForNode()
+  // in this case because we need the nsIDocument interface anyway for the script 
+  // context. 
+  nsCOMPtr<nsIDocument> document;
+  nsCOMPtr<nsIContent> content = do_QueryInterface(mElement);
+  if (NS_FAILED(rv = content->GetDocument(*getter_AddRefs(document)))) {
+    NS_ERROR("Unable to retrieve the document.");
+    return rv;
+  }
+
+  // Turn the document into a XUL document so we can use getElementById
+  nsCOMPtr<nsIDOMXULDocument> xulDocument = do_QueryInterface(document);
+  if (xulDocument == nsnull) {
+    NS_ERROR("Popup attached to an element that isn't in XUL!");
+    return NS_ERROR_FAILURE;
+  }
+
+  // XXX Handle the _child case for popups and context menus!
+
+  // Use getElementById to obtain the popup content and gracefully fail if 
+  // we didn't find any popup content in the document. 
+  nsCOMPtr<nsIDOMElement> popupContent;
+  if (NS_FAILED(rv = xulDocument->GetElementById(identifier, getter_AddRefs(popupContent)))) {
+    NS_ERROR("GetElementById had some kind of spasm.");
+    return rv;
+  }
+  if ( !popupContent )
+    return NS_OK;
+
+  // We have some popup content. Obtain our window.
+  nsIScriptContextOwner* owner = document->GetScriptContextOwner();
+  nsCOMPtr<nsIScriptContext> context;
+  if (NS_OK == owner->GetScriptContext(getter_AddRefs(context))) {
+    nsIScriptGlobalObject* global = context->GetGlobalObject();
+    if (global) {
+      // Get the DOM window
+      nsCOMPtr<nsIDOMWindow> domWindow = do_QueryInterface(global);
+      if (domWindow != nsnull) {
+        // Find out if we're anchored.
+        nsAutoString anchorAlignment("none");
+        mElement->GetAttribute("popupanchor", anchorAlignment);
+
+        nsAutoString popupAlignment("topleft");
+        mElement->GetAttribute("popupalign", popupAlignment);
+
+        PRInt32 xPos = aClientX, yPos = aClientY;
+        
+        mPopupContent = popupContent.get();
+
+        nsCOMPtr<nsIDOMWindow> uselessPopup; // XXX Should go away.
+        domWindow->CreatePopup(mElement, popupContent, 
+                               xPos, yPos, 
+                               type, anchorAlignment, popupAlignment,
+                               getter_AddRefs(uselessPopup));
+      }
+      NS_RELEASE(global);
+    }
+  }
+  NS_IF_RELEASE(owner);
+
+  return NS_OK;
+}
+
+//
+// sTooltipCallback
+//
+// A timer callback, fired when the mouse has hovered inside of a frame for the 
+// appropriate amount of time. Getting to this point means that we should show the
+// toolip.
+//
+// This relies on certain things being cached into the |aClosure| object passed to
+// us by the timer:
+//   -- the x/y coordinates of the mouse
+//   -- the dom node the user hovered over
+//
+void
+XULPopupListenerImpl :: sTooltipCallback (nsITimer *aTimer, void *aClosure)
+{
+  XULPopupListenerImpl* self = NS_STATIC_CAST(XULPopupListenerImpl*, aClosure);
+  if ( self ) {
+    // set the node in the document that triggered the tooltip and show it
+    nsCOMPtr<nsIDOMXULDocument> doc;
+    self->FindDocumentForNode ( self->mPossibleTooltipNode, getter_AddRefs(doc) );
+    if ( doc ) {
+      nsCOMPtr<nsIDOMElement> element ( do_QueryInterface(self->mPossibleTooltipNode) );
+      if ( element ) {
+        // check that node is enabled before showing tooltip
+        nsAutoString disabledState;
+        element->GetAttribute ( "disabled", disabledState );
+        if ( disabledState != "true" ) {
+          doc->SetTooltipNode ( element );        
+          self->LaunchPopup (self->mMouseClientX, self->mMouseClientY+16);
+        } // if node enabled
+      } else {
+          // Tooltip on non-element; e.g., text
+          doc->SetTooltipNode ( self->mPossibleTooltipNode );        
+          self->LaunchPopup ( self->mMouseClientX, self->mMouseClientY+16);
+      }
+    } // if document
+  } // if "self" data valid
+  
+} // sTimerCallback
+
+
+
+////////////////////////////////////////////////////////////////
+nsresult
+NS_NewXULPopupListener(nsIXULPopupListener** pop)
+{
+    XULPopupListenerImpl* popup = new XULPopupListenerImpl();
+    if (!popup)
+      return NS_ERROR_OUT_OF_MEMORY;
+    
+    NS_ADDREF(popup);
+    *pop = popup;
+    return NS_OK;
+}

mozilla/content/xul/content/src/nsXULTreeElement.cpp

@@ -0,0 +1,384 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+  Implementation methods for the XUL tree element APIs.
+
+*/
+
+#include "nsCOMPtr.h"
+#include "nsRDFCID.h"
+#include "nsXULTreeElement.h"
+#include "nsIContent.h"
+#include "nsIDocument.h"
+#include "nsIPresContext.h"
+#include "nsIPresShell.h"
+#include "nsINameSpaceManager.h"
+#include "nsString.h"
+
+nsIAtom*             nsXULTreeElement::kSelectedAtom;
+int                  nsXULTreeElement::gRefCnt = 0;
+
+NS_IMPL_ADDREF_INHERITED(nsXULTreeElement, nsXULAggregateElement);
+NS_IMPL_RELEASE_INHERITED(nsXULTreeElement, nsXULAggregateElement);
+
+nsresult
+nsXULTreeElement::QueryInterface(REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    if (aIID.Equals(nsCOMTypeInfo<nsIDOMXULTreeElement>::GetIID())) {
+        *aResult = NS_STATIC_CAST(nsIDOMXULTreeElement*, this);
+    }
+    else if (aIID.Equals(nsCOMTypeInfo<nsIXULTreeContent>::GetIID())) {
+        *aResult = NS_STATIC_CAST(nsIXULTreeContent*, this);
+    }
+    else {
+        return nsXULAggregateElement::QueryInterface(aIID, aResult);
+    }
+
+    NS_ADDREF(NS_REINTERPRET_CAST(nsISupports*, *aResult));
+    return NS_OK;
+}
+
+
+nsXULTreeElement::nsXULTreeElement(nsIDOMXULElement* aOuter)
+  : nsXULAggregateElement(aOuter)
+{
+  if (gRefCnt++ == 0) {
+    kSelectedAtom    = NS_NewAtom("selected");
+  }
+
+  nsresult rv;
+
+  nsRDFDOMNodeList* children;
+  rv = nsRDFDOMNodeList::Create(&children);
+  NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create DOM node list");
+  if (NS_FAILED(rv)) return;
+
+  mSelectedItems = children;
+
+  children = nsnull;
+  rv = nsRDFDOMNodeList::Create(&children);
+  NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create DOM node list");
+  if (NS_FAILED(rv)) return;
+
+  mSelectedCells = children;
+}
+
+nsXULTreeElement::~nsXULTreeElement()
+{
+#ifdef DEBUG_REFS
+    --gInstanceCount;
+    fprintf(stdout, "%d - RDF: nsXULTreeElement\n", gInstanceCount);
+#endif
+
+  NS_IF_RELEASE(mSelectedItems);
+  NS_IF_RELEASE(mSelectedCells);
+
+  if (--gRefCnt == 0) {
+    NS_IF_RELEASE(kSelectedAtom);
+  }
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::GetSelectedItems(nsIDOMNodeList** aSelectedItems)
+{
+  NS_IF_ADDREF(mSelectedItems);
+  *aSelectedItems = mSelectedItems;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::GetSelectedCells(nsIDOMNodeList** aSelectedCells)
+{
+  NS_IF_ADDREF(mSelectedCells);
+  *aSelectedCells = mSelectedCells;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::SelectItem(nsIDOMXULElement* aTreeItem)
+{
+  // Sanity check. If we're the only item, just bail.
+  PRUint32 length;
+  mSelectedItems->GetLength(&length);
+  if (length == 1) {
+    // See if the single item already selected is us.
+    nsCOMPtr<nsIDOMNode> domNode;
+    mSelectedItems->Item(0, getter_AddRefs(domNode));
+    nsCOMPtr<nsIDOMXULElement> treeItem = do_QueryInterface(domNode);
+    if (treeItem.get() == aTreeItem)
+      return NS_OK;
+  }
+
+  // First clear our selection.
+  ClearItemSelectionInternal();
+
+  // Now add ourselves to the selection by setting our selected attribute.
+  AddItemToSelectionInternal(aTreeItem);
+
+  FireOnSelectHandler();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::SelectCell(nsIDOMXULElement* aTreeCell)
+{
+  // Sanity check. If we're the only item, just bail.
+  PRUint32 length;
+  mSelectedCells->GetLength(&length);
+  if (length == 1) {
+    // See if the single item already selected is us.
+    nsCOMPtr<nsIDOMNode> domNode;
+    mSelectedCells->Item(0, getter_AddRefs(domNode));
+    nsCOMPtr<nsIDOMXULElement> treeCell = do_QueryInterface(domNode);
+    if (treeCell.get() == aTreeCell)
+      return NS_OK;
+  }
+
+  // First clear our selection.
+  ClearCellSelectionInternal();
+
+  // Now add ourselves to the selection by setting our selected attribute.
+  AddCellToSelectionInternal(aTreeCell);
+
+  FireOnSelectHandler();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP    
+nsXULTreeElement::ClearItemSelection()
+{
+  ClearItemSelectionInternal();
+  FireOnSelectHandler();
+  return NS_OK;
+}
+
+void
+nsXULTreeElement::ClearItemSelectionInternal()
+{
+  // Enumerate the elements and remove them from the selection.
+  PRUint32 length;
+  mSelectedItems->GetLength(&length);
+  for (PRUint32 i = 0; i < length; i++) {
+    nsCOMPtr<nsIDOMNode> node;
+    mSelectedItems->Item(0, getter_AddRefs(node));
+    nsCOMPtr<nsIContent> content = do_QueryInterface(node);
+    content->UnsetAttribute(kNameSpaceID_None, kSelectedAtom, PR_TRUE);
+  }
+}
+
+void
+nsXULTreeElement::ClearCellSelectionInternal()
+{
+  // Enumerate the elements and remove them from the selection.
+  PRUint32 length;
+  mSelectedCells->GetLength(&length);
+  for (PRUint32 i = 0; i < length; i++) {
+    nsCOMPtr<nsIDOMNode> node;
+    mSelectedCells->Item(0, getter_AddRefs(node));
+    nsCOMPtr<nsIContent> content = do_QueryInterface(node);
+    content->UnsetAttribute(kNameSpaceID_None, kSelectedAtom, PR_TRUE);
+  }
+}
+
+NS_IMETHODIMP    
+nsXULTreeElement::ClearCellSelection()
+{
+  ClearCellSelectionInternal();
+  FireOnSelectHandler();
+  return NS_OK;
+}
+
+void
+nsXULTreeElement::AddItemToSelectionInternal(nsIDOMXULElement* aTreeItem)
+{
+  // Without clearing the selection, perform the add.
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aTreeItem);
+  content->SetAttribute(kNameSpaceID_None, kSelectedAtom, nsAutoString("true"), PR_TRUE);
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::AddItemToSelection(nsIDOMXULElement* aTreeItem)
+{
+  // Without clearing the selection, perform the add.
+  AddItemToSelectionInternal(aTreeItem);
+  FireOnSelectHandler();
+  return NS_OK;
+}
+
+
+void
+nsXULTreeElement::RemoveItemFromSelectionInternal(nsIDOMXULElement* aTreeItem)
+{
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aTreeItem);
+  content->UnsetAttribute(kNameSpaceID_None, kSelectedAtom, PR_TRUE);
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::RemoveItemFromSelection(nsIDOMXULElement* aTreeItem)
+{
+  RemoveItemFromSelectionInternal(aTreeItem);
+  FireOnSelectHandler();
+  return NS_OK;
+}
+
+void
+nsXULTreeElement::AddCellToSelectionInternal(nsIDOMXULElement* aTreeCell)
+{
+  // Without clearing the selection, perform the add.
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aTreeCell);
+  content->SetAttribute(kNameSpaceID_None, kSelectedAtom, nsAutoString("true"), PR_TRUE);
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::AddCellToSelection(nsIDOMXULElement* aTreeCell)
+{
+  AddCellToSelectionInternal(aTreeCell);
+  FireOnSelectHandler();
+  return NS_OK;
+}
+
+void
+nsXULTreeElement::RemoveCellFromSelectionInternal(nsIDOMXULElement* aTreeCell)
+{
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aTreeCell);
+  content->UnsetAttribute(kNameSpaceID_None, kSelectedAtom, PR_TRUE);
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::RemoveCellFromSelection(nsIDOMXULElement* aTreeCell)
+{
+  RemoveCellFromSelectionInternal(aTreeCell);
+  FireOnSelectHandler();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::ToggleItemSelection(nsIDOMXULElement* aTreeItem)
+{
+  nsAutoString isSelected;
+  aTreeItem->GetAttribute("selected", isSelected);
+  if (isSelected == "true")
+    RemoveItemFromSelectionInternal(aTreeItem);
+  else AddItemToSelectionInternal(aTreeItem);
+
+  FireOnSelectHandler();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::ToggleCellSelection(nsIDOMXULElement* aTreeCell)
+{
+  nsAutoString isSelected;
+  aTreeCell->GetAttribute("selected", isSelected);
+  if (isSelected == "true")
+    RemoveCellFromSelectionInternal(aTreeCell);
+  else AddCellToSelectionInternal(aTreeCell);
+
+  FireOnSelectHandler();
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULTreeElement::SelectItemRange(nsIDOMXULElement* aStartItem, nsIDOMXULElement* aEndItem)
+{
+  // XXX Fill in.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::SelectCellRange(nsIDOMXULElement* aStartItem, nsIDOMXULElement* aEndItem)
+{
+  // XXX Fill in.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::SelectAll()
+{
+  // XXX Select anything that isn't selected.
+  // Write later.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULTreeElement::InvertSelection()
+{
+  // XXX Woo hoo. Write this later.
+  // Yikes. Involves an enumeration of the whole tree.
+  return NS_OK;
+}
+
+nsresult
+nsXULTreeElement::FireOnSelectHandler()
+{
+  nsCOMPtr<nsIContent> content = do_QueryInterface(mOuter);
+  nsCOMPtr<nsIDocument> document;
+  content->GetDocument(*getter_AddRefs(document));
+
+  // If there's no document (e.g., a selection is occuring in a
+  // 'orphaned' node), then there ain't a whole lot to do here!
+  if (! document) {
+    NS_WARNING("FireOnSelectHandler occurred in orphaned node");
+    return NS_OK;
+  }
+
+  // The frame code can suppress the firing of this handler by setting an attribute
+  // for us.  Look for that and bail if it's present.
+  nsCOMPtr<nsIAtom> kSuppressSelectChange = dont_AddRef(NS_NewAtom("suppressonselect"));
+  nsAutoString value;
+  content->GetAttribute(kNameSpaceID_None, kSuppressSelectChange, value);
+  if (value == "true")
+    return NS_OK;
+
+  PRInt32 count = document->GetNumberOfShells();
+	for (PRInt32 i = 0; i < count; i++) {
+		nsIPresShell* shell = document->GetShellAt(i);
+		if (nsnull == shell)
+				continue;
+
+		// Retrieve the context in which our DOM event will fire.
+		nsCOMPtr<nsIPresContext> aPresContext;
+		shell->GetPresContext(getter_AddRefs(aPresContext));
+
+		NS_RELEASE(shell);
+				
+    nsEventStatus status = nsEventStatus_eIgnore;
+    nsEvent event;
+    event.eventStructType = NS_EVENT;
+    event.message = NS_FORM_SELECTED;
+
+    content->HandleDOMEvent(*aPresContext, &event, nsnull, NS_EVENT_FLAG_INIT, status);
+  }
+
+  return NS_OK;
+}
+

mozilla/content/xul/content/src/nsXULTreeElement.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+  An aggregate object that implements the XUL tree widget APIs
+
+*/
+
+#ifndef nsXULTreeElement_h__
+#define nsXULTreeElement_h__
+
+#include "nsXULElement.h"
+#include "nsIDOMXULTreeElement.h"
+#include "nsIXULTreeContent.h"
+#include "nsRDFDOMNodeList.h"
+
+class nsXULTreeElement : public nsXULAggregateElement,
+                         public nsIDOMXULTreeElement,
+                         public nsIXULTreeContent
+{
+public:
+    nsXULTreeElement(nsIDOMXULElement* aOuter);
+    ~nsXULTreeElement();
+
+    NS_DECL_ISUPPORTS_INHERITED
+
+    // nsIDOMNode interface
+    NS_FORWARD_IDOMNODE(mOuter->);
+
+    // nsIDOMElement interface
+    NS_FORWARD_IDOMELEMENT(mOuter->);
+
+    // nsIDOMXULElement interface
+    NS_FORWARD_IDOMXULELEMENT(mOuter->);
+
+    // nsIDOMXULTreeElement interface
+    NS_DECL_IDOMXULTREEELEMENT
+   
+    // nsIXULTreeContent interface
+    NS_IMETHOD FireOnSelectHandler();
+
+    static nsIAtom*             kSelectedAtom;
+    static int gRefCnt;
+
+protected:
+    // Helpers
+    void ClearItemSelectionInternal();
+    void ClearCellSelectionInternal();
+    void AddItemToSelectionInternal(nsIDOMXULElement* aTreeItem);
+    void RemoveItemFromSelectionInternal(nsIDOMXULElement* aTreeItem);
+    void AddCellToSelectionInternal(nsIDOMXULElement* aTreeCell);
+    void RemoveCellFromSelectionInternal(nsIDOMXULElement* aTreeCell);
+
+protected:
+    nsRDFDOMNodeList* mSelectedItems;
+    nsRDFDOMNodeList* mSelectedCells;
+};
+
+
+#endif // nsXULTreeElement_h__

mozilla/content/xul/document/public/nsIXULContentSink.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+#ifndef nsIXULContentSink_h__
+#define nsIXULContentSink_h__
+
+#include "nsIXMLContentSink.h"
+
+class nsIDocument;
+class nsIXULPrototypeDocument;
+
+// {E49AA620-C16C-11d2-A6AA-00104BDE6048}
+#define NS_IXULCONTENTSINK_IID \
+{ 0xe49aa620, 0xc16c, 0x11d2, { 0xa6, 0xaa, 0x0, 0x10, 0x4b, 0xde, 0x60, 0x48 } }
+
+
+class nsIXULContentSink : public nsIXMLContentSink
+{
+public:
+    static const nsIID& GetIID() { static nsIID iid = NS_IXULCONTENTSINK_IID; return iid; }
+
+    /**
+     * Initialize the content sink, giving it an nsIDocument object
+     * with which to communicate with the outside world, and an
+     * nsIXULPrototypeDocument to build.
+     */
+    NS_IMETHOD Init(nsIDocument* aDocument, nsIXULPrototypeDocument* aPrototype) = 0;
+};
+
+
+nsresult
+NS_NewXULContentSink(nsIXULContentSink** aResult);
+
+#endif // nsIXULContentSink_h__

mozilla/content/xul/document/public/nsIXULPrototypeCache.h

@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+
+
+ */
+
+#ifndef nsIXULPrototypeCache_h__
+#define nsIXULPrototypeCache_h__
+
+#include "nsISupports.h"
+class nsICSSStyleSheet;
+class nsIURI;
+class nsIXULPrototypeDocument;
+
+// {3A0A0FC0-8349-11d3-BE47-00104BDE6048}
+#define NS_IXULPROTOTYPECACHE_IID \
+{ 0x3a0a0fc0, 0x8349, 0x11d3, { 0xbe, 0x47, 0x0, 0x10, 0x4b, 0xde, 0x60, 0x48 } }
+
+
+class nsIXULPrototypeCache : public nsISupports
+{
+public:
+    NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXULPROTOTYPECACHE_IID);
+
+    NS_IMETHOD GetPrototype(nsIURI* aURI, nsIXULPrototypeDocument** _result) = 0;
+    NS_IMETHOD PutPrototype(nsIXULPrototypeDocument* aDocument) = 0;
+
+    NS_IMETHOD GetStyleSheet(nsIURI* aURI, nsICSSStyleSheet** _result) = 0;
+    NS_IMETHOD PutStyleSheet(nsICSSStyleSheet* aStyleSheet) = 0;
+
+    /**
+     * Flush the cache; remove all XUL prototype documents, style
+     * sheets, and scripts.
+     */
+    NS_IMETHOD Flush() = 0;
+};
+
+
+extern NS_IMETHODIMP
+NS_NewXULPrototypeCache(nsISupports* aOuter, REFNSIID aIID, void** aResult);
+
+#endif // nsIXULPrototypeCache_h__

mozilla/content/xul/document/src/nsElementMap.cpp

@@ -0,0 +1,378 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+   Maps IDs to elements.
+
+ */
+
+#include "nsCOMPtr.h"
+#include "nsCRT.h"
+#include "nsElementMap.h"
+#include "nsISupportsArray.h"
+#include "nsString.h"
+#include "prlog.h"
+
+#ifdef PR_LOGGING
+static PRLogModuleInfo* gMapLog;
+#endif
+
+nsElementMap::nsElementMap()
+{
+    MOZ_COUNT_CTOR(RDF_nsElementMap);
+
+    // Create a table for mapping IDs to elements in the content tree.
+    static PRInt32 kInitialResourceTableSize = 1023;
+    mMap = PL_NewHashTable(kInitialResourceTableSize,
+                                 Hash,
+                                 Compare,
+                                 PL_CompareValues,
+                                 nsnull,
+                                 nsnull);
+
+    NS_ASSERTION(mMap != nsnull, "could not create hash table for resources");
+
+#ifdef PR_LOGGING
+    if (! gMapLog)
+        gMapLog = PR_NewLogModule("nsElementMap");
+
+
+    PR_LOG(gMapLog, PR_LOG_ALWAYS,
+           ("xulelemap(%p) created", this));
+#endif
+}
+
+nsElementMap::~nsElementMap()
+{
+    MOZ_COUNT_DTOR(RDF_nsElementMap);
+
+    if (mMap) {
+        PL_HashTableEnumerateEntries(mMap, ReleaseContentList, nsnull);
+        PL_HashTableDestroy(mMap);
+    }
+
+    PR_LOG(gMapLog, PR_LOG_ALWAYS,
+           ("xulelemap(%p) destroyed", this));
+}
+
+
+PRIntn
+nsElementMap::ReleaseContentList(PLHashEntry* aHashEntry, PRIntn aIndex, void* aClosure)
+{
+    PRUnichar* id =
+        NS_REINTERPRET_CAST(PRUnichar*, NS_CONST_CAST(void*, aHashEntry->key));
+
+    delete[] id;
+        
+    ContentListItem* head =
+        NS_REINTERPRET_CAST(ContentListItem*, aHashEntry->value);
+
+    while (head) {
+        ContentListItem* doomed = head;
+        head = head->mNext;
+        delete doomed;
+    }
+
+    return HT_ENUMERATE_NEXT;
+}
+
+
+nsresult
+nsElementMap::Add(const nsString& aID, nsIContent* aContent)
+{
+    NS_PRECONDITION(mMap != nsnull, "not initialized");
+    if (! mMap)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    ContentListItem* head =
+        (ContentListItem*) PL_HashTableLookup(mMap, aID.GetUnicode());
+
+    if (! head) {
+        head = new ContentListItem(aContent);
+        if (! head)
+            return NS_ERROR_OUT_OF_MEMORY;
+
+        PRUnichar* key = new PRUnichar[aID.Length() + 1];
+        if (! key)
+            return NS_ERROR_OUT_OF_MEMORY;
+
+        nsCRT::memcpy(key, aID.GetUnicode(), aID.Length() * sizeof(PRUnichar));
+        key[aID.Length()] = PRUnichar(0);
+
+        PL_HashTableAdd(mMap, key, head);
+    }
+    else {
+        while (1) {
+            if (head->mContent.get() == aContent) {
+                // This can happen if an element that was created via
+                // frame construction code is then "appended" to the
+                // content model with aNotify == PR_TRUE. If you see
+                // this warning, it's an indication that you're
+                // unnecessarily notifying the frame system, and
+                // potentially causing unnecessary reflow.
+                //NS_ERROR("element was already in the map");
+#ifdef PR_LOGGING
+                if (PR_LOG_TEST(gMapLog, PR_LOG_ALWAYS)) {
+                    nsresult rv;
+
+                    nsCOMPtr<nsIAtom> tag;
+                    rv = aContent->GetTag(*getter_AddRefs(tag));
+                    if (NS_FAILED(rv)) return rv;
+
+                    nsAutoString tagname;
+                    rv = tag->ToString(tagname);
+                    if (NS_FAILED(rv)) return rv;
+
+                    PR_LOG(gMapLog, PR_LOG_ALWAYS,
+                           ("xulelemap(%p) dup    %s[%p] <-- %s\n",
+                            this,
+                            (const char*) nsCAutoString(tagname),
+                            aContent,
+                            (const char*) nsCAutoString(aID)));
+                }
+#endif
+
+                return NS_OK;
+            }
+            if (! head->mNext)
+                break;
+
+            head = head->mNext;
+        }
+
+        head->mNext = new ContentListItem(aContent);
+        if (! head->mNext)
+            return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+#ifdef PR_LOGGING
+    if (PR_LOG_TEST(gMapLog, PR_LOG_ALWAYS)) {
+        nsresult rv;
+
+        nsCOMPtr<nsIAtom> tag;
+        rv = aContent->GetTag(*getter_AddRefs(tag));
+        if (NS_FAILED(rv)) return rv;
+
+        nsAutoString tagname;
+        rv = tag->ToString(tagname);
+        if (NS_FAILED(rv)) return rv;
+
+        PR_LOG(gMapLog, PR_LOG_ALWAYS,
+               ("xulelemap(%p) add    %s[%p] <-- %s\n",
+                this,
+                (const char*) nsCAutoString(tagname),
+                aContent,
+                (const char*) nsCAutoString(aID)));
+    }
+#endif
+
+    return NS_OK;
+}
+
+
+nsresult
+nsElementMap::Remove(const nsString& aID, nsIContent* aContent)
+{
+    NS_PRECONDITION(mMap != nsnull, "not initialized");
+    if (! mMap)
+        return NS_ERROR_NOT_INITIALIZED;
+
+#ifdef PR_LOGGING
+    if (PR_LOG_TEST(gMapLog, PR_LOG_ALWAYS)) {
+        nsresult rv;
+
+        nsCOMPtr<nsIAtom> tag;
+        rv = aContent->GetTag(*getter_AddRefs(tag));
+        if (NS_FAILED(rv)) return rv;
+
+        nsAutoString tagname;
+        rv = tag->ToString(tagname);
+        if (NS_FAILED(rv)) return rv;
+
+        PR_LOG(gMapLog, PR_LOG_ALWAYS,
+               ("xulelemap(%p) remove  %s[%p] <-- %s\n",
+                this,
+                (const char*) nsCAutoString(tagname),
+                aContent,
+                (const char*) nsCAutoString(aID)));
+    }
+#endif
+
+    PLHashEntry** hep = PL_HashTableRawLookup(mMap,
+                                              Hash(aID.GetUnicode()),
+                                              aID.GetUnicode());
+
+    // XXX Don't comment out this assert: if you get here, something
+    // has gone dreadfully, horribly wrong. Curse. Scream. File a bug
+    // against waterson@netscape.com.
+    NS_ASSERTION(hep != nsnull && *hep != nsnull, "attempt to remove an element that was never added");
+    if (!hep || !*hep)
+        return NS_OK;
+
+    ContentListItem* head = NS_REINTERPRET_CAST(ContentListItem*, (*hep)->value);
+
+    if (head->mContent.get() == aContent) {
+        ContentListItem* next = head->mNext;
+        if (next) {
+            (*hep)->value = next;
+        }
+        else {
+            // It was the last reference in the table
+            PRUnichar* key = NS_REINTERPRET_CAST(PRUnichar*, NS_CONST_CAST(void*, (*hep)->key));
+            PL_HashTableRawRemove(mMap, hep, *hep);
+            delete[] key;
+        }
+        delete head;
+    }
+    else {
+        ContentListItem* item = head->mNext;
+        while (item) {
+            if (item->mContent.get() == aContent) {
+                head->mNext = item->mNext;
+                delete item;
+                break;
+            }
+            head = item;
+            item = item->mNext;
+        }
+    }
+
+    return NS_OK;
+}
+
+
+
+nsresult
+nsElementMap::Find(const nsString& aID, nsISupportsArray* aResults)
+{
+    NS_PRECONDITION(mMap != nsnull, "not initialized");
+    if (! mMap)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    aResults->Clear();
+    ContentListItem* item =
+        NS_REINTERPRET_CAST(ContentListItem*, PL_HashTableLookup(mMap, aID.GetUnicode()));
+
+    while (item) {
+        aResults->AppendElement(item->mContent);
+        item = item->mNext;
+    }
+    return NS_OK;
+}
+
+
+nsresult
+nsElementMap::FindFirst(const nsString& aID, nsIContent** aResult)
+{
+    NS_PRECONDITION(mMap != nsnull, "not initialized");
+    if (! mMap)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    ContentListItem* item =
+        NS_REINTERPRET_CAST(ContentListItem*, PL_HashTableLookup(mMap, aID.GetUnicode()));
+
+    if (item) {
+        *aResult = item->mContent;
+        NS_ADDREF(*aResult);
+    }
+    else {
+        *aResult = nsnull;
+    }
+
+    return NS_OK;
+}
+
+nsresult
+nsElementMap::Enumerate(nsElementMapEnumerator aEnumerator, void* aClosure)
+{
+    EnumerateClosure closure = { aEnumerator, aClosure };
+    PL_HashTableEnumerateEntries(mMap, EnumerateImpl, &closure);
+    return NS_OK;
+}
+
+
+PRIntn
+nsElementMap::EnumerateImpl(PLHashEntry* aHashEntry, PRIntn aIndex, void* aClosure)
+{
+    // This routine will be called once for each key in the
+    // hashtable. It will in turn call the enumerator that the user
+    // has passed in via Enumerate() once for each element that's been
+    // mapped to this ID.
+    EnumerateClosure* closure = NS_REINTERPRET_CAST(EnumerateClosure*, aClosure);
+
+    const PRUnichar* id =
+        NS_REINTERPRET_CAST(const PRUnichar*, aHashEntry->key);
+
+    // 'link' holds a pointer to the previous element's link field.
+    ContentListItem** link = 
+        NS_REINTERPRET_CAST(ContentListItem**, &aHashEntry->value);
+
+    ContentListItem* item = *link;
+
+    // Iterate through each content node that's been mapped to this ID
+    while (item) {
+        ContentListItem* current = item;
+        item = item->mNext;
+        PRIntn result = (*closure->mEnumerator)(id, current->mContent, closure->mClosure);
+
+        if (result == HT_ENUMERATE_REMOVE) {
+            // If the user wants to remove the current, then deal.
+            *link = item;
+            delete current;
+
+            if ((! *link) && (link == NS_REINTERPRET_CAST(ContentListItem**, &aHashEntry->value))) {
+                // It's the last content node that was mapped to this
+                // ID. Unhash it.
+                PRUnichar* key = NS_CONST_CAST(PRUnichar*, id);
+                delete[] key;
+                return HT_ENUMERATE_REMOVE;
+            }
+        }
+        else {
+            link = &current->mNext;
+        }
+    }
+
+    return HT_ENUMERATE_NEXT;
+}
+
+
+PLHashNumber
+nsElementMap::Hash(const void* aKey)
+{
+    PLHashNumber result = 0;
+    const PRUnichar* s = NS_REINTERPRET_CAST(const PRUnichar*, aKey);
+    while (*s != nsnull) {
+        result = (result >> 28) ^ (result << 4) ^ *s;
+        ++s;
+    }
+    return result;
+}
+
+
+PRIntn
+nsElementMap::Compare(const void* aLeft, const void* aRight)
+{
+    return 0 == nsCRT::strcmp(NS_REINTERPRET_CAST(const PRUnichar*, aLeft),
+                              NS_REINTERPRET_CAST(const PRUnichar*, aRight));
+}

mozilla/content/xul/document/src/nsElementMap.h

@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+   Maintains one-to-many mapping between element IDs and content
+   nodes.
+
+ */
+
+#ifndef nsElementMap_h__
+#define nsElementMap_h__
+
+#include "nscore.h"
+#include "nsError.h"
+#include "plhash.h"
+#include "nsIContent.h"
+
+class nsString;
+class nsISupportsArray;
+
+class nsElementMap
+{
+private:
+    PLHashTable* mMap;
+
+    class ContentListItem {
+    public:
+        ContentListItem(nsIContent* aContent) : mNext(nsnull), mContent(aContent) {
+            MOZ_COUNT_CTOR(RDF_nsElementMap_ContentListItem);
+        }
+
+        ~ContentListItem() {
+            MOZ_COUNT_DTOR(RDF_nsElementMap_ContentListItem);
+        }
+
+        ContentListItem* mNext;
+        nsCOMPtr<nsIContent> mContent;
+    };
+
+    static PLHashNumber
+    Hash(const void* akey);
+
+    static PRIntn
+    Compare(const void* aLeft, const void* aRight);
+
+    static PRIntn
+    ReleaseContentList(PLHashEntry* aHashEntry, PRIntn aIndex, void* aClosure);
+
+public:
+    nsElementMap(void);
+    virtual ~nsElementMap();
+
+    nsresult
+    Add(const nsString& aID, nsIContent* aContent);
+
+    nsresult
+    Remove(const nsString& aID, nsIContent* aContent);
+
+    nsresult
+    Find(const nsString& aID, nsISupportsArray* aResults);
+
+    nsresult
+    FindFirst(const nsString& aID, nsIContent** aContent);
+
+    typedef PRIntn (*nsElementMapEnumerator)(const nsString& aID,
+                                             nsIContent* aElement,
+                                             void* aClosure);
+    nsresult
+    Enumerate(nsElementMapEnumerator aEnumerator, void* aClosure);
+
+private:
+    struct EnumerateClosure {
+        nsElementMapEnumerator mEnumerator;
+        void*                  mClosure;
+    };
+        
+    static PRIntn
+    EnumerateImpl(PLHashEntry* aHashEntry, PRIntn aIndex, void* aClosure);
+};
+
+
+#endif // nsElementMap_h__

mozilla/content/xul/document/src/nsForwardReference.h

@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsForwardReference_h__
+#define nsForwardReference_h__
+
+class nsForwardReference
+{
+protected:
+    nsForwardReference() {}
+
+public:
+    virtual ~nsForwardReference() {}
+
+    /**
+     * Priority codes returned from GetPriority()
+     */
+    enum Priority {
+        /** The initial pass, after which the content model will be
+            fully built */
+        ePriority_Construction,
+
+        /** A second pass, after which all 'magic attribute' hookup
+            will have been performed */
+        ePriority_Hookup,
+
+        /** A dummy marker, used in kPasses to indicate termination */
+        ePriority_Done
+    };
+
+    /**
+     * Forward references are categorized by 'priority', and all
+     * forward references in a higher priority are resolved before any
+     * reference in a lower priority. This variable specifies this
+     * ordering. The last Priority is guaranteed to be ePriority_Done.
+     */
+    static const Priority kPasses[];
+
+    /**
+     * Get the priority of the forward reference. 'ePriority_Construction'
+     * references are all resolved before 'ePriority_Hookup' references
+     * are resolved.
+     *
+     * @return the Priority of the reference
+     */
+    virtual Priority GetPriority() = 0;
+
+    /**
+     * Result codes returned from Resolve()
+     */
+    enum Result {
+        /** Resolution succeeded, I'm done. */
+        eResolve_Succeeded,
+
+        /** Couldn't resolve, but try me later. */
+        eResolve_Later,
+
+        /** Something bad happened, don't try again. */
+        eResolve_Error
+    };
+
+    /**
+     * Attempt to resolve the forward reference.
+     *
+     * @return a Result that tells the resolver how to treat
+     * the reference.
+     */
+    virtual Result Resolve() = 0;
+};
+
+#endif // nsForwardReference_h__

mozilla/content/xul/document/src/nsXULCommandDispatcher.cpp

@@ -0,0 +1,555 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+  This file provides the implementation for the XUL Command Dispatcher.
+ */
+
+#include "nsCOMPtr.h"
+
+#include "nsVoidArray.h"
+
+#include "nsIDOMElement.h"
+#include "nsIDOMXULCommandDispatcher.h"
+#include "nsIXULCommandDispatcher.h"
+#include "nsIDOMFocusListener.h"
+#include "nsRDFCID.h"
+
+#include "nsIScriptObjectOwner.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsIDOMWindow.h"
+#include "nsIScriptContextOwner.h"
+#include "nsIDOMXULDocument.h"
+#include "nsIDocument.h"
+#include "nsIContent.h"
+#include "nsIDOMUIEvent.h"
+
+#include "nsIDOMXULElement.h"
+#include "nsIControllers.h"
+
+#include "nsIPresContext.h"
+#include "nsIPresShell.h"
+#include "nsPIDOMWindow.h"
+
+#include "prlog.h"
+
+////////////////////////////////////////////////////////////////////////
+
+static NS_DEFINE_IID(kIScriptObjectOwnerIID,      NS_ISCRIPTOBJECTOWNER_IID);
+
+static NS_DEFINE_IID(kISupportsIID,           NS_ISUPPORTS_IID);
+
+static NS_DEFINE_IID(kIDomNodeIID,            NS_IDOMNODE_IID);
+static NS_DEFINE_IID(kIDomElementIID,         NS_IDOMELEMENT_IID);
+static NS_DEFINE_IID(kIDomEventListenerIID,   NS_IDOMEVENTLISTENER_IID);
+
+#ifdef PR_LOGGING
+static PRLogModuleInfo* gLog;
+#endif
+
+////////////////////////////////////////////////////////////////////////
+// XULCommandDispatcherImpl
+//
+//   This is the focus manager for XUL documents.
+//
+class XULCommandDispatcherImpl : public nsIDOMXULCommandDispatcher,
+                                 public nsIXULCommandDispatcher,
+                                 public nsIDOMFocusListener,
+                                 public nsIScriptObjectOwner
+{
+public:
+    XULCommandDispatcherImpl(void);
+    virtual ~XULCommandDispatcherImpl(void);
+
+public:
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    // nsIDOMXULCommandDispatcher interface
+    NS_DECL_IDOMXULCOMMANDDISPATCHER
+   
+    // nsIDOMFocusListener
+    virtual nsresult Focus(nsIDOMEvent* aEvent);
+    virtual nsresult Blur(nsIDOMEvent* aEvent);
+
+    // nsIDOMEventListener
+    virtual nsresult HandleEvent(nsIDOMEvent* anEvent) { return NS_OK; };
+
+    // nsIScriptObjectOwner interface
+    NS_IMETHOD GetScriptObject(nsIScriptContext *aContext, void** aScriptObject);
+    NS_IMETHOD SetScriptObject(void *aScriptObject);
+
+protected:
+    NS_IMETHOD GetParentWindowFromElement(nsIDOMElement* aElement, nsPIDOMWindow** aPWindow);
+
+    void*                      mScriptObject;       // ????
+
+    // XXX THis was supposed to be WEAK, but c'mon, that's an accident
+    // waiting to happen! If somebody deletes the node, then asks us
+    // for the focus, we'll get killed!
+    nsCOMPtr<nsIDOMNode> mCurrentNode; // [OWNER]
+
+    class Updater {
+    public:
+        Updater(nsIDOMElement* aElement,
+                const nsString& aEvents,
+                const nsString& aTargets)
+            : mElement(aElement),
+              mEvents(aEvents),
+              mTargets(aTargets),
+              mNext(nsnull)
+        {}
+
+        nsIDOMElement* mElement; // [WEAK]
+        nsString       mEvents;
+        nsString       mTargets;
+        Updater*       mNext;
+    };
+
+    Updater* mUpdaters;
+
+    PRBool Matches(const nsString& aList, const nsString& aElement);
+};
+
+////////////////////////////////////////////////////////////////////////
+
+XULCommandDispatcherImpl::XULCommandDispatcherImpl(void)
+    : mScriptObject(nsnull), mCurrentNode(nsnull), mUpdaters(nsnull)
+{
+	NS_INIT_REFCNT();
+
+#ifdef PR_LOGGING
+    if (! gLog)
+        gLog = PR_NewLogModule("nsXULCommandDispatcher");
+#endif
+}
+
+XULCommandDispatcherImpl::~XULCommandDispatcherImpl(void)
+{
+    while (mUpdaters) {
+        Updater* doomed = mUpdaters;
+        mUpdaters = mUpdaters->mNext;
+        delete doomed;
+    }
+}
+
+NS_IMPL_ADDREF(XULCommandDispatcherImpl)
+NS_IMPL_RELEASE(XULCommandDispatcherImpl)
+
+NS_IMETHODIMP
+XULCommandDispatcherImpl::QueryInterface(REFNSIID iid, void** result)
+{
+    if (! result)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = nsnull;
+    if (iid.Equals(kISupportsIID)) {
+        *result = (nsISupports*)(nsIXULCommandDispatcher*)this;
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+    else if (iid.Equals(nsIXULCommandDispatcher::GetIID())) {
+        *result = NS_STATIC_CAST(nsIXULCommandDispatcher*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    } 
+    else if (iid.Equals(nsIDOMXULCommandDispatcher::GetIID())) {
+        *result = NS_STATIC_CAST(nsIDOMXULCommandDispatcher*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+    else if (iid.Equals(nsIDOMFocusListener::GetIID())) {
+        *result = NS_STATIC_CAST(nsIDOMFocusListener*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+    else if (iid.Equals(kIDomEventListenerIID)) {
+        *result = (nsIDOMEventListener*)(nsIDOMFocusListener*)this;
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+    else if (iid.Equals(kIScriptObjectOwnerIID)) {
+        *result = NS_STATIC_CAST(nsIScriptObjectOwner*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+
+    return NS_NOINTERFACE;
+}
+
+
+////////////////////////////////////////////////////////////////
+// nsIDOMXULTracker Interface
+
+NS_IMETHODIMP
+XULCommandDispatcherImpl::GetFocusedNode(nsIDOMNode** aNode)
+{
+  *aNode = mCurrentNode;
+  NS_IF_ADDREF(*aNode);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+XULCommandDispatcherImpl::SetFocusedNode(nsIDOMNode* aNode)
+{
+  // XXX On a blur, will need to fire an updatecommands (focus) on the
+  // parent window.
+  mCurrentNode = aNode;
+  if (mCurrentNode)
+    UpdateCommands(nsAutoString("focus"));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+XULCommandDispatcherImpl::AddCommandUpdater(nsIDOMElement* aElement,
+                                            const nsString& aEvents,
+                                            const nsString& aTargets)
+{
+    NS_PRECONDITION(aElement != nsnull, "null ptr");
+    if (! aElement)
+        return NS_ERROR_NULL_POINTER;
+
+    Updater* updater = mUpdaters;
+    Updater** link = &mUpdaters;
+
+    while (updater) {
+        if (updater->mElement == aElement) {
+            PR_LOG(gLog, PR_LOG_ALWAYS,
+                   ("xulcmd[%p] replace %p(events=%s targets=%s) with (events=%s targets=%s)",
+                    this, aElement,
+                    (const char*) nsCAutoString(updater->mEvents),
+                    (const char*) nsCAutoString(updater->mTargets),
+                    (const char*) nsCAutoString(aEvents),
+                    (const char*) nsCAutoString(aTargets)));
+
+            // If the updater was already in the list, then replace
+            // (?) the 'events' and 'targets' filters with the new
+            // specification.
+            updater->mEvents  = aEvents;
+            updater->mTargets = aTargets;
+            return NS_OK;
+        }
+
+        link = &(updater->mNext);
+        updater = updater->mNext;
+    }
+
+    PR_LOG(gLog, PR_LOG_ALWAYS,
+           ("xulcmd[%p] add     %p(events=%s targets=%s)",
+            this, aElement,
+            (const char*) nsCAutoString(aEvents),
+            (const char*) nsCAutoString(aTargets)));
+
+    // If we get here, this is a new updater. Append it to the list.
+    updater = new Updater(aElement, aEvents, aTargets);
+    if (! updater)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    *link = updater;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XULCommandDispatcherImpl::RemoveCommandUpdater(nsIDOMElement* aElement)
+{
+    NS_PRECONDITION(aElement != nsnull, "null ptr");
+    if (! aElement)
+        return NS_ERROR_NULL_POINTER;
+
+    Updater* updater = mUpdaters;
+    Updater** link = &mUpdaters;
+
+    while (updater) {
+        if (updater->mElement == aElement) {
+            PR_LOG(gLog, PR_LOG_ALWAYS,
+                   ("xulcmd[%p] remove  %p(events=%s targets=%s)",
+                    this, aElement,
+                    (const char*) nsCAutoString(updater->mEvents),
+                    (const char*) nsCAutoString(updater->mTargets)));
+
+            *link = updater->mNext;
+            delete updater;
+            return NS_OK;
+        }
+
+        link = &(updater->mNext);
+        updater = updater->mNext;
+    }
+
+    // Hmm. Not found. Oh well.
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XULCommandDispatcherImpl::UpdateCommands(const nsString& aEventName)
+{
+    nsresult rv;
+
+    nsAutoString id;
+    nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mCurrentNode);
+    if (element) {
+        rv = element->GetAttribute(nsAutoString("id"), id);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get element's id");
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    for (Updater* updater = mUpdaters; updater != nsnull; updater = updater->mNext) {
+        // Skip any nodes that don't match our 'events' or 'targets'
+        // filters.
+        if (! Matches(updater->mEvents, aEventName))
+            continue;
+
+        if (! Matches(updater->mTargets, id))
+            continue;
+
+        nsCOMPtr<nsIContent> content = do_QueryInterface(updater->mElement);
+        NS_ASSERTION(content != nsnull, "not an nsIContent");
+        if (! content)
+            return NS_ERROR_UNEXPECTED;
+
+        nsCOMPtr<nsIDocument> document;
+        rv = content->GetDocument(*getter_AddRefs(document));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get document");
+        if (NS_FAILED(rv)) return rv;
+
+        NS_ASSERTION(document != nsnull, "element has no document");
+        if (! document)
+            continue;
+
+        PR_LOG(gLog, PR_LOG_ALWAYS,
+               ("xulcmd[%p] update %p event=%s",
+                this, updater->mElement,
+                (const char*) nsCAutoString(aEventName)));
+
+        PRInt32 count = document->GetNumberOfShells();
+        for (PRInt32 i = 0; i < count; i++) {
+            nsCOMPtr<nsIPresShell> shell = dont_AddRef(document->GetShellAt(i));
+            if (! shell)
+                continue;
+
+            // Retrieve the context in which our DOM event will fire.
+            nsCOMPtr<nsIPresContext> context;
+            rv = shell->GetPresContext(getter_AddRefs(context));
+            if (NS_FAILED(rv)) return rv;
+
+            // Handle the DOM event
+            nsEventStatus status = nsEventStatus_eIgnore;
+            nsEvent event;
+            event.eventStructType = NS_EVENT;
+            event.message = NS_XUL_COMMAND_UPDATE; 
+            content->HandleDOMEvent(*context, &event, nsnull, NS_EVENT_FLAG_INIT, status);
+        }
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XULCommandDispatcherImpl::GetControllers(nsIControllers** aResult)
+{
+  if (mCurrentNode) {
+    nsCOMPtr<nsIDOMXULElement> xulElement = do_QueryInterface(mCurrentNode);
+    if (xulElement)
+      return xulElement->GetControllers(aResult);
+    else {
+      nsCOMPtr<nsIDOMWindow> domWindow = do_QueryInterface(mCurrentNode);
+      if (domWindow)
+        return domWindow->GetControllers(aResult);
+    }
+  }
+
+  *aResult = nsnull;
+  return NS_OK;
+}
+
+/////
+// nsIDOMFocusListener
+/////
+
+nsresult 
+XULCommandDispatcherImpl::Focus(nsIDOMEvent* aEvent)
+{
+  nsCOMPtr<nsIDOMNode> t;
+  aEvent->GetTarget(getter_AddRefs(t));
+  
+  // XXX: Bad fix
+  nsCOMPtr<nsIDOMElement> element = do_QueryInterface(t);
+  if(element) {
+    SetFocusedNode(t);
+  }
+
+  return NS_OK;
+}
+
+nsresult 
+XULCommandDispatcherImpl::Blur(nsIDOMEvent* aEvent)
+{
+  nsCOMPtr<nsIDOMNode> t;
+  aEvent->GetTarget(getter_AddRefs(t));
+  if( t == mCurrentNode ) {
+    SetFocusedNode(nsnull);
+  }
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+// nsIScriptObjectOwner interface
+NS_IMETHODIMP
+XULCommandDispatcherImpl::GetScriptObject(nsIScriptContext *aContext, void** aScriptObject)
+{
+    nsresult res = NS_OK;
+    nsIScriptGlobalObject *global = aContext->GetGlobalObject();
+
+    if (nsnull == mScriptObject) {
+        res = NS_NewScriptXULCommandDispatcher(aContext, (nsISupports *)(nsIDOMXULCommandDispatcher*)this, global, (void**)&mScriptObject);
+    }
+    *aScriptObject = mScriptObject;
+
+    NS_RELEASE(global);
+    return res;
+}
+
+
+NS_IMETHODIMP
+XULCommandDispatcherImpl::SetScriptObject(void *aScriptObject)
+{
+    mScriptObject = aScriptObject;
+    return NS_OK;
+}
+
+
+PRBool
+XULCommandDispatcherImpl::Matches(const nsString& aList, const nsString& aElement)
+{
+    if (aList == "*")
+        return PR_TRUE; // match _everything_!
+
+    PRInt32 indx = aList.Find(aElement);
+    if (indx == -1)
+        return PR_FALSE; // not in the list at all
+
+    // okay, now make sure it's not a substring snafu; e.g., 'ur'
+    // found inside of 'blur'.
+    if (indx > 0) {
+        PRUnichar ch = aList[indx - 1];
+        if (! nsString::IsSpace(ch) && ch != PRUnichar(','))
+            return PR_FALSE;
+    }
+
+    if (indx + aElement.Length() < aList.Length()) {
+        PRUnichar ch = aList[indx + aElement.Length()];
+        if (! nsString::IsSpace(ch) && ch != PRUnichar(','))
+            return PR_FALSE;
+    }
+
+    return PR_TRUE;
+}
+
+
+  NS_IMETHODIMP XULCommandDispatcherImpl::GetParentWindowFromElement(nsIDOMElement* aElement, nsPIDOMWindow** aPWindow)
+  {
+    nsCOMPtr<nsIDOMDocument> document;
+    aElement->GetOwnerDocument(getter_AddRefs(document));
+    if(!document) return NS_OK;
+
+    nsCOMPtr<nsIDocument> objectOwner = do_QueryInterface(document);
+    if(!objectOwner) return NS_OK;
+
+    nsCOMPtr<nsIScriptContextOwner> contextOwner = dont_QueryInterface(objectOwner->GetScriptContextOwner());
+    if(!contextOwner) return NS_OK;
+
+    nsCOMPtr<nsIScriptGlobalObject> globalObject;
+    contextOwner->GetScriptGlobalObject(getter_AddRefs(globalObject));
+    if(!globalObject) return NS_OK;
+
+    nsCOMPtr<nsPIDOMWindow> privateDOMWindow = do_QueryInterface(globalObject);
+    if(!privateDOMWindow) return NS_OK;
+
+    privateDOMWindow->GetPrivateParent(aPWindow);
+
+    return NS_OK;
+  }
+
+  NS_IMETHODIMP XULCommandDispatcherImpl::GetControllerForCommand(const nsString& command, nsIController** _retval)
+  {
+    *_retval = nsnull;
+
+    nsCOMPtr<nsIControllers> controllers;
+    GetControllers(getter_AddRefs(controllers));
+    if(controllers) {
+      nsCOMPtr<nsIController> controller;
+      controllers->GetControllerForCommand(command.GetUnicode(), getter_AddRefs(controller));
+      if(controller) {
+        *_retval = controller;
+        NS_ADDREF(*_retval);
+        return NS_OK;
+      }
+    }
+     
+    if(!mCurrentNode) return NS_OK;
+
+    nsCOMPtr<nsPIDOMWindow> currentWindow;
+
+    nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mCurrentNode);
+    if(element) {
+      GetParentWindowFromElement(element, getter_AddRefs(currentWindow));
+    } else {
+      nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(mCurrentNode);
+      if(!window) return NS_OK;
+
+      window->GetPrivateParent(getter_AddRefs(currentWindow));
+    }
+
+    while(currentWindow) {
+      nsCOMPtr<nsIDOMWindow> domWindow = do_QueryInterface(currentWindow);
+      if(domWindow) {
+        nsCOMPtr<nsIControllers> controllers2;
+        domWindow->GetControllers(getter_AddRefs(controllers2));
+        if(controllers2) {
+          nsCOMPtr<nsIController> controller;
+          controllers2->GetControllerForCommand(command.GetUnicode(), getter_AddRefs(controller));
+          if(controller) {
+            *_retval = controller;
+            NS_ADDREF(*_retval);
+            return NS_OK;
+          }
+        }
+      } 
+      nsCOMPtr<nsPIDOMWindow> parentPWindow = currentWindow;
+      parentPWindow->GetPrivateParent(getter_AddRefs(currentWindow));
+    }
+    
+    return NS_OK;
+  }
+
+////////////////////////////////////////////////////////////////
+nsresult
+NS_NewXULCommandDispatcher(nsIXULCommandDispatcher** CommandDispatcher)
+{
+    XULCommandDispatcherImpl* focus = new XULCommandDispatcherImpl();
+    if (!focus)
+      return NS_ERROR_OUT_OF_MEMORY;
+    
+    NS_ADDREF(focus);
+    *CommandDispatcher = focus;
+    return NS_OK;
+}

mozilla/content/xul/document/src/nsXULControllers.cpp

@@ -0,0 +1,228 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+  This file provides the implementation for the XUL Command Dispatcher.
+ */
+
+#include "nsCOMPtr.h"
+
+#include "nsVoidArray.h"
+#include "nsISupportsArray.h"
+
+#include "nsIDOMElement.h"
+#include "nsIXULCommandDispatcher.h"
+#include "nsIDOMFocusListener.h"
+#include "nsRDFCID.h"
+
+#include "nsIScriptObjectOwner.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsIDOMWindow.h"
+#include "nsIScriptContextOwner.h"
+#include "nsIDOMXULDocument.h"
+#include "nsIDocument.h"
+#include "nsIContent.h"
+#include "nsIDOMUIEvent.h"
+
+#include "nsIDOMXULElement.h"
+#include "nsIControllers.h"
+
+#include "nsIPresContext.h"
+#include "nsIPresShell.h"
+
+////////////////////////////////////////////////////////////////////////
+
+static NS_DEFINE_IID(kIScriptObjectOwnerIID,      NS_ISCRIPTOBJECTOWNER_IID);
+
+static NS_DEFINE_IID(kISupportsIID,           NS_ISUPPORTS_IID);
+
+static NS_DEFINE_IID(kIDomNodeIID,            NS_IDOMNODE_IID);
+static NS_DEFINE_IID(kIDomElementIID,         NS_IDOMELEMENT_IID);
+static NS_DEFINE_IID(kIDomEventListenerIID,   NS_IDOMEVENTLISTENER_IID);
+
+////////////////////////////////////////////////////////////////////////
+// XULControllersImpl
+//
+//   This is the focus manager for XUL documents.
+//
+class XULControllersImpl : public nsIControllers
+{
+public:
+    XULControllersImpl(void);
+    virtual ~XULControllersImpl(void);
+
+public:
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+	NS_DECL_NSICONTROLLERS
+   
+  
+protected:
+    nsISupportsArray* mControllers;
+};
+
+////////////////////////////////////////////////////////////////////////
+
+XULControllersImpl::XULControllersImpl(void) :
+  mControllers(nsnull)
+{
+	NS_INIT_REFCNT();
+}
+
+XULControllersImpl::~XULControllersImpl(void)
+{
+	NS_IF_RELEASE(mControllers);
+}
+
+NS_IMPL_ADDREF(XULControllersImpl)
+NS_IMPL_RELEASE(XULControllersImpl)
+
+NS_IMETHODIMP
+XULControllersImpl::QueryInterface(REFNSIID iid, void** result)
+{
+    if (! result)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = nsnull;
+    if (iid.Equals(kISupportsIID)) {
+        *result = (nsISupports*)(nsIControllers*)this;
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+    else if (iid.Equals(nsIControllers::GetIID())) {
+        *result = NS_STATIC_CAST(nsIControllers*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    } 
+
+    return NS_NOINTERFACE;
+}
+
+
+  /* boolean SupportsCommand (in string command); */
+  NS_IMETHODIMP XULControllersImpl::GetControllerForCommand(const PRUnichar *command, nsIController** _retval)
+  {
+    *_retval = nsnull;
+    if(!mControllers) 
+      return NS_OK;
+
+    PRUint32 count;
+    mControllers->Count(&count);
+    for(PRUint32 i=0; i < count; i++) {
+        nsCOMPtr<nsIController> controller;
+        nsCOMPtr<nsISupports>   supports;
+        mControllers->GetElementAt(i, getter_AddRefs(supports));
+        controller = do_QueryInterface(supports);
+        if( controller ) {
+          PRBool supportsCommand;
+          controller->SupportsCommand(command, &supportsCommand);
+          if(supportsCommand) {
+            *_retval = controller;
+            NS_ADDREF(*_retval);
+            return NS_OK;
+          }
+        }
+    }
+    return NS_OK;
+  }
+
+  /* void InsertControllerAt (in short index, in nsIController controller); */
+  NS_IMETHODIMP XULControllersImpl::InsertControllerAt(PRUint32 index, nsIController *controller)
+  {
+    if(! mControllers )
+      NS_NewISupportsArray(&mControllers);
+
+    mControllers->InsertElementAt(controller, index);
+    return NS_OK;
+  }
+
+  /* nsIController RemoveControllerAt (in short index); */
+  NS_IMETHODIMP XULControllersImpl::RemoveControllerAt(PRUint32 index, nsIController **_retval)
+  {
+    if(mControllers) {
+       nsCOMPtr<nsISupports> supports;
+       mControllers->GetElementAt(index, getter_AddRefs(supports));
+       supports->QueryInterface(nsIController::GetIID(), (void**)_retval);
+       mControllers->RemoveElementAt(index);  
+    } else
+      *_retval = nsnull;
+    
+    return NS_OK;
+  }
+
+  /* nsIController GetControllerAt (in short index); */
+  NS_IMETHODIMP XULControllersImpl::GetControllerAt(PRUint32 index, nsIController **_retval)
+  {
+    if(mControllers) {
+       nsCOMPtr<nsISupports> supports;
+       mControllers->GetElementAt(index, getter_AddRefs(supports));
+       supports->QueryInterface(nsIController::GetIID(), (void**)_retval);
+    } else 
+      *_retval = nsnull;
+    
+    return NS_OK;
+  }
+
+  /* void AppendController (in nsIController controller); */
+  NS_IMETHODIMP XULControllersImpl::AppendController(nsIController *controller)
+  {
+    if(! mControllers )
+      NS_NewISupportsArray(&mControllers);
+     
+    mControllers->AppendElement(controller);
+    return NS_OK;
+  }
+
+  /* void RemoveController (in nsIController controller); */
+  NS_IMETHODIMP XULControllersImpl::RemoveController(nsIController *controller)
+  {
+    if(mControllers) {
+       nsCOMPtr<nsISupports> supports = do_QueryInterface(controller);
+       mControllers->RemoveElement(supports);  
+    }
+    
+    return NS_OK;
+  }
+
+  /* short GetControllerCount (); */
+  NS_IMETHODIMP XULControllersImpl::GetControllerCount(PRUint32 *_retval)
+  {
+    *_retval = 0;
+    if(mControllers) 
+      mControllers->Count(_retval);
+    
+    return NS_OK;
+  }
+
+////////////////////////////////////////////////////////////////
+nsresult
+NS_NewXULControllers(nsIControllers** aControllers)
+{
+    nsIControllers* impl = new XULControllersImpl();
+    if (!impl)
+      return NS_ERROR_OUT_OF_MEMORY;
+    
+    NS_ADDREF(impl);
+    *aControllers = impl;
+    return NS_OK;
+}

mozilla/content/xul/document/src/nsXULDocument.h

@@ -0,0 +1,749 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsXULDocument_h__
+#define nsXULDocument_h__
+
+#include "nsCOMPtr.h"
+#include "nsElementMap.h"
+#include "nsForwardReference.h"
+#include "nsIArena.h"
+#include "nsICSSLoader.h"
+#include "nsIContent.h"
+#include "nsIDOMEventCapturer.h"
+#include "nsIDOMHTMLFormElement.h"
+#include "nsIDOMNSDocument.h"
+#include "nsIDOMSelection.h"
+#include "nsIDOMXULCommandDispatcher.h"
+#include "nsIDOMXULDocument.h"
+#include "nsIDocument.h"
+#include "nsIEventListenerManager.h"
+#include "nsIHTMLCSSStyleSheet.h"
+#include "nsIHTMLContentContainer.h"
+#include "nsIHTMLStyleSheet.h"
+#include "nsIJSScriptObject.h"
+#include "nsILineBreakerFactory.h"
+#include "nsINameSpaceManager.h"
+#include "nsIParser.h"
+#include "nsIPrincipal.h"
+#include "nsIRDFDataSource.h"
+#include "nsIScriptObjectOwner.h"
+#include "nsIStreamLoadableDocument.h"
+#include "nsISupportsArray.h"
+#include "nsIURI.h"
+#include "nsIWordBreakerFactory.h"
+#include "nsIXULDocument.h"
+#include "nsIXULPrototypeDocument.h"
+#include "nsRDFDOMNodeList.h"
+#include "nsTime.h"
+#include "nsVoidArray.h"
+#include "nsWeakPtr.h"
+#include "nsWeakReference.h"
+#include "nsIUnicharStreamLoader.h"
+
+class nsIAtom;
+class nsIHTMLElementFactory;
+class nsILoadGroup;
+class nsIRDFResource;
+class nsIRDFService;
+class nsIScriptContextOwner;
+class nsIUnicharStreamLoader;
+class nsIXMLElementFactory;
+class nsIXULContentUtils;
+class nsIXULPrototypeCache;
+#if 0 // XXXbe save me, scc (need NSCAP_FORWARD_DECL(nsXULPrototypeScript))
+class nsIXULPrototypeScript;
+#else
+#include "nsXULElement.h"
+#endif
+
+struct JSObject;
+struct PRLogModuleInfo;
+
+/**
+ * The XUL document class
+ */
+class nsXULDocument : public nsIDocument,
+                      public nsIXULDocument,
+                      public nsIStreamLoadableDocument,
+                      public nsIDOMXULDocument,
+                      public nsIDOMNSDocument,
+                      public nsIDOMEventCapturer,
+                      public nsIJSScriptObject,
+                      public nsIScriptObjectOwner,
+                      public nsIHTMLContentContainer,
+                      public nsIUnicharStreamLoaderObserver,
+                      public nsSupportsWeakReference
+{
+public:
+    nsXULDocument();
+    virtual ~nsXULDocument();
+
+    // nsISupports interface
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIUNICHARSTREAMLOADEROBSERVER
+
+    // nsIDocument interface
+    virtual nsIArena* GetArena();
+
+    NS_IMETHOD GetContentType(nsString& aContentType) const;
+
+    NS_IMETHOD StartDocumentLoad(const char* aCommand,
+                                 nsIChannel* aChannel,
+                                 nsILoadGroup* aLoadGroup,
+                                 nsIContentViewerContainer* aContainer,
+                                 nsIStreamListener **aDocListener);
+
+    virtual const nsString* GetDocumentTitle() const;
+
+    virtual nsIURI* GetDocumentURL() const;
+
+    virtual nsIPrincipal* GetDocumentPrincipal();
+
+    NS_IMETHOD GetDocumentLoadGroup(nsILoadGroup **aGroup) const;
+
+    NS_IMETHOD GetBaseURL(nsIURI*& aURL) const;
+
+    NS_IMETHOD GetDocumentCharacterSet(nsString& oCharSetID);
+
+    NS_IMETHOD SetDocumentCharacterSet(const nsString& aCharSetID);
+
+    NS_IMETHOD GetLineBreaker(nsILineBreaker** aResult) ;
+    NS_IMETHOD SetLineBreaker(nsILineBreaker* aLineBreaker) ;
+    NS_IMETHOD GetWordBreaker(nsIWordBreaker** aResult) ;
+    NS_IMETHOD SetWordBreaker(nsIWordBreaker* aWordBreaker) ;
+
+    NS_IMETHOD GetHeaderData(nsIAtom* aHeaderField, nsString& aData) const;
+    NS_IMETHOD SetHeaderData(nsIAtom* aheaderField, const nsString& aData);
+
+    NS_IMETHOD CreateShell(nsIPresContext* aContext,
+                           nsIViewManager* aViewManager,
+                           nsIStyleSet* aStyleSet,
+                           nsIPresShell** aInstancePtrResult);
+
+    virtual PRBool DeleteShell(nsIPresShell* aShell);
+
+    virtual PRInt32 GetNumberOfShells();
+
+    virtual nsIPresShell* GetShellAt(PRInt32 aIndex);
+
+    virtual nsIDocument* GetParentDocument();
+
+    virtual void SetParentDocument(nsIDocument* aParent);
+
+    virtual void AddSubDocument(nsIDocument* aSubDoc);
+
+    virtual PRInt32 GetNumberOfSubDocuments();
+
+    virtual nsIDocument* GetSubDocumentAt(PRInt32 aIndex);
+
+    virtual nsIContent* GetRootContent();
+
+    virtual void SetRootContent(nsIContent* aRoot);
+
+    NS_IMETHOD AppendToProlog(nsIContent* aContent);
+    NS_IMETHOD AppendToEpilog(nsIContent* aContent);
+    NS_IMETHOD ChildAt(PRInt32 aIndex, nsIContent*& aResult) const;
+    NS_IMETHOD IndexOf(nsIContent* aPossibleChild, PRInt32& aIndex) const;
+    NS_IMETHOD GetChildCount(PRInt32& aCount);
+
+    virtual PRInt32 GetNumberOfStyleSheets();
+
+    virtual nsIStyleSheet* GetStyleSheetAt(PRInt32 aIndex);
+
+    virtual PRInt32 GetIndexOfStyleSheet(nsIStyleSheet* aSheet);
+
+    virtual void AddStyleSheet(nsIStyleSheet* aSheet);
+    NS_IMETHOD InsertStyleSheetAt(nsIStyleSheet* aSheet, PRInt32 aIndex, PRBool aNotify);
+
+    virtual void SetStyleSheetDisabledState(nsIStyleSheet* aSheet,
+                                            PRBool mDisabled);
+
+    NS_IMETHOD GetCSSLoader(nsICSSLoader*& aLoader);
+
+    virtual nsIScriptContextOwner *GetScriptContextOwner();
+
+    virtual void SetScriptContextOwner(nsIScriptContextOwner *aScriptContextOwner);
+
+    NS_IMETHOD GetNameSpaceManager(nsINameSpaceManager*& aManager);
+
+    virtual void AddObserver(nsIDocumentObserver* aObserver);
+
+    virtual PRBool RemoveObserver(nsIDocumentObserver* aObserver);
+
+    NS_IMETHOD BeginLoad();
+
+    NS_IMETHOD EndLoad();
+
+    NS_IMETHOD ContentChanged(nsIContent* aContent,
+                              nsISupports* aSubContent);
+
+    NS_IMETHOD ContentStatesChanged(nsIContent* aContent1, nsIContent* aContent2);
+
+    NS_IMETHOD AttributeChanged(nsIContent* aChild,
+                                PRInt32 aNameSpaceID,
+                                nsIAtom* aAttribute,
+                                PRInt32 aHint); // See nsStyleConsts fot hint values
+
+    NS_IMETHOD ContentAppended(nsIContent* aContainer,
+                               PRInt32 aNewIndexInContainer);
+
+    NS_IMETHOD ContentInserted(nsIContent* aContainer,
+                               nsIContent* aChild,
+                               PRInt32 aIndexInContainer);
+
+    NS_IMETHOD ContentReplaced(nsIContent* aContainer,
+                               nsIContent* aOldChild,
+                               nsIContent* aNewChild,
+                               PRInt32 aIndexInContainer);
+
+    NS_IMETHOD ContentRemoved(nsIContent* aContainer,
+                              nsIContent* aChild,
+                              PRInt32 aIndexInContainer);
+
+    NS_IMETHOD StyleRuleChanged(nsIStyleSheet* aStyleSheet,
+                                nsIStyleRule* aStyleRule,
+                                PRInt32 aHint); // See nsStyleConsts fot hint values
+
+    NS_IMETHOD StyleRuleAdded(nsIStyleSheet* aStyleSheet,
+                              nsIStyleRule* aStyleRule);
+
+    NS_IMETHOD StyleRuleRemoved(nsIStyleSheet* aStyleSheet,
+                                nsIStyleRule* aStyleRule);
+
+    NS_IMETHOD GetSelection(nsIDOMSelection** aSelection);
+
+    NS_IMETHOD SelectAll();
+
+    NS_IMETHOD FindNext(const nsString &aSearchStr, PRBool aMatchCase, PRBool aSearchDown, PRBool &aIsFound);
+
+    NS_IMETHOD CreateXIF(nsString & aBuffer, nsIDOMSelection* aSelection);
+
+    NS_IMETHOD ToXIF(nsXIFConverter& aConverter, nsIDOMNode* aNode);
+
+    virtual void BeginConvertToXIF(nsXIFConverter& aConverter, nsIDOMNode* aNode);
+
+    virtual void ConvertChildrenToXIF(nsXIFConverter& aConverter, nsIDOMNode* aNode);
+
+    virtual void FinishConvertToXIF(nsXIFConverter& aConverter, nsIDOMNode* aNode);
+
+    virtual PRBool IsInRange(const nsIContent *aStartContent, const nsIContent* aEndContent, const nsIContent* aContent) const;
+
+    virtual PRBool IsBefore(const nsIContent *aNewContent, const nsIContent* aCurrentContent) const;
+
+    virtual PRBool IsInSelection(nsIDOMSelection* aSelection, const nsIContent *aContent) const;
+
+    virtual nsIContent* GetPrevContent(const nsIContent *aContent) const;
+
+    virtual nsIContent* GetNextContent(const nsIContent *aContent) const;
+
+    virtual void SetDisplaySelection(PRBool aToggle);
+
+    virtual PRBool GetDisplaySelection() const;
+
+    NS_IMETHOD HandleDOMEvent(nsIPresContext& aPresContext,
+                              nsEvent* aEvent,
+                              nsIDOMEvent** aDOMEvent,
+                              PRUint32 aFlags,
+                              nsEventStatus& aEventStatus);
+
+
+    // nsIXMLDocument interface
+    NS_IMETHOD GetContentById(const nsString& aName, nsIContent** aContent);
+#ifdef XSL
+    NS_IMETHOD SetTransformMediator(nsITransformMediator* aMediator);
+#endif
+
+    // nsIXULDocument interface
+    NS_IMETHOD AddElementForID(const nsString& aID, nsIContent* aElement);
+    NS_IMETHOD RemoveElementForID(const nsString& aID, nsIContent* aElement);
+    NS_IMETHOD GetElementsForID(const nsString& aID, nsISupportsArray* aElements);
+    NS_IMETHOD CreateContents(nsIContent* aElement);
+    NS_IMETHOD AddContentModelBuilder(nsIRDFContentModelBuilder* aBuilder);
+    NS_IMETHOD GetForm(nsIDOMHTMLFormElement** aForm);
+    NS_IMETHOD SetForm(nsIDOMHTMLFormElement* aForm);
+    NS_IMETHOD AddForwardReference(nsForwardReference* aRef);
+    NS_IMETHOD ResolveForwardReferences();
+
+    NS_IMETHOD CreateFromPrototype(const char* aCommand,
+                                   nsIXULPrototypeDocument* aPrototype,
+                                   nsIContentViewerContainer* aContainer);
+
+    // nsIStreamLoadableDocument interface
+    NS_IMETHOD LoadFromStream(nsIInputStream& xulStream,
+                              nsIContentViewerContainer* aContainer,
+                              const char* aCommand );
+
+    // nsIDOMEventCapturer interface
+    NS_IMETHOD    CaptureEvent(const nsString& aType);
+    NS_IMETHOD    ReleaseEvent(const nsString& aType);
+
+    // nsIDOMEventReceiver interface (yuck. inherited from nsIDOMEventCapturer)
+    NS_IMETHOD AddEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID);
+    NS_IMETHOD RemoveEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID);
+    NS_IMETHOD GetListenerManager(nsIEventListenerManager** aInstancePtrResult);
+    NS_IMETHOD GetNewListenerManager(nsIEventListenerManager **aInstancePtrResult);
+
+    // nsIDOMEventTarget interface
+    NS_IMETHOD AddEventListener(const nsString& aType, nsIDOMEventListener* aListener,
+                                PRBool aUseCapture);
+    NS_IMETHOD RemoveEventListener(const nsString& aType, nsIDOMEventListener* aListener,
+                                   PRBool aUseCapture);
+
+    // nsIDOMDocument interface
+    NS_IMETHOD    GetDoctype(nsIDOMDocumentType** aDoctype);
+    NS_IMETHOD    GetImplementation(nsIDOMDOMImplementation** aImplementation);
+    NS_IMETHOD    GetDocumentElement(nsIDOMElement** aDocumentElement);
+
+    NS_IMETHOD    CreateElement(const nsString& aTagName, nsIDOMElement** aReturn);
+    NS_IMETHOD    CreateDocumentFragment(nsIDOMDocumentFragment** aReturn);
+    NS_IMETHOD    CreateTextNode(const nsString& aData, nsIDOMText** aReturn);
+    NS_IMETHOD    CreateComment(const nsString& aData, nsIDOMComment** aReturn);
+    NS_IMETHOD    CreateCDATASection(const nsString& aData, nsIDOMCDATASection** aReturn);
+    NS_IMETHOD    CreateProcessingInstruction(const nsString& aTarget, const nsString& aData, nsIDOMProcessingInstruction** aReturn);
+    NS_IMETHOD    CreateAttribute(const nsString& aName, nsIDOMAttr** aReturn);
+    NS_IMETHOD    CreateEntityReference(const nsString& aName, nsIDOMEntityReference** aReturn);
+    NS_IMETHOD    GetElementsByTagName(const nsString& aTagname, nsIDOMNodeList** aReturn);
+
+    // nsIDOMNSDocument interface
+    NS_IMETHOD    GetStyleSheets(nsIDOMStyleSheetCollection** aStyleSheets);
+    NS_IMETHOD    CreateElementWithNameSpace(const nsString& aTagName, const nsString& aNameSpace, nsIDOMElement** aResult);
+    NS_IMETHOD    CreateRange(nsIDOMRange** aRange);
+    NS_IMETHOD    GetWidth(PRInt32* aWidth);
+    NS_IMETHOD    GetHeight(PRInt32* aHeight);
+
+    // nsIDOMXULDocument interface
+    NS_DECL_IDOMXULDOCUMENT
+
+    // nsIDOMNode interface
+    NS_IMETHOD    GetNodeName(nsString& aNodeName);
+    NS_IMETHOD    GetNodeValue(nsString& aNodeValue);
+    NS_IMETHOD    SetNodeValue(const nsString& aNodeValue);
+    NS_IMETHOD    GetNodeType(PRUint16* aNodeType);
+    NS_IMETHOD    GetParentNode(nsIDOMNode** aParentNode);
+    NS_IMETHOD    GetChildNodes(nsIDOMNodeList** aChildNodes);
+    NS_IMETHOD    HasChildNodes(PRBool* aHasChildNodes);
+    NS_IMETHOD    GetFirstChild(nsIDOMNode** aFirstChild);
+    NS_IMETHOD    GetLastChild(nsIDOMNode** aLastChild);
+    NS_IMETHOD    GetPreviousSibling(nsIDOMNode** aPreviousSibling);
+    NS_IMETHOD    GetNextSibling(nsIDOMNode** aNextSibling);
+    NS_IMETHOD    GetAttributes(nsIDOMNamedNodeMap** aAttributes);
+    NS_IMETHOD    GetOwnerDocument(nsIDOMDocument** aOwnerDocument);
+    NS_IMETHOD    InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aReturn);
+    NS_IMETHOD    ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aReturn);
+    NS_IMETHOD    RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn);
+    NS_IMETHOD    AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aReturn);
+    NS_IMETHOD    CloneNode(PRBool aDeep, nsIDOMNode** aReturn);
+
+    // nsIJSScriptObject interface
+    virtual PRBool    AddProperty(JSContext *aContext, jsval aID, jsval *aVp);
+    virtual PRBool    DeleteProperty(JSContext *aContext, jsval aID, jsval *aVp);
+    virtual PRBool    GetProperty(JSContext *aContext, jsval aID, jsval *aVp);
+    virtual PRBool    SetProperty(JSContext *aContext, jsval aID, jsval *aVp);
+    virtual PRBool    EnumerateProperty(JSContext *aContext);
+    virtual PRBool    Resolve(JSContext *aContext, jsval aID);
+    virtual PRBool    Convert(JSContext *aContext, jsval aID);
+    virtual void      Finalize(JSContext *aContext);
+
+    // nsIScriptObjectOwner interface
+    NS_IMETHOD GetScriptObject(nsIScriptContext *aContext, void** aScriptObject);
+    NS_IMETHOD SetScriptObject(void *aScriptObject);
+
+    // nsIHTMLContentContainer interface
+    NS_IMETHOD GetAttributeStyleSheet(nsIHTMLStyleSheet** aResult);
+    NS_IMETHOD GetInlineStyleSheet(nsIHTMLCSSStyleSheet** aResult);
+
+protected:
+    // Implementation methods
+    friend nsresult
+    NS_NewXULDocument(nsIXULDocument** aResult);
+
+    nsresult Init(void);
+    nsresult StartLayout(void);
+
+    nsresult OpenWidgetItem(nsIContent* aElement);
+    nsresult CloseWidgetItem(nsIContent* aElement);
+    nsresult RebuildWidgetItem(nsIContent* aElement);
+
+    nsresult
+    AddSubtreeToDocument(nsIContent* aElement);
+
+    nsresult
+    RemoveSubtreeFromDocument(nsIContent* aElement);
+
+    nsresult
+    AddElementToMap(nsIContent* aElement);
+
+    nsresult
+    RemoveElementFromMap(nsIContent* aElement);
+
+    static PRIntn
+    RemoveElementsFromMapByContent(const nsString& aID,
+                                   nsIContent* aElement,
+                                   void* aClosure);
+
+    static nsresult
+    GetElementsByTagName(nsIDOMNode* aNode,
+                         const nsString& aTagName,
+                         nsRDFDOMNodeList* aElements);
+
+    static nsresult
+    GetElementsByAttribute(nsIDOMNode* aNode,
+                           const nsString& aAttribute,
+                           const nsString& aValue,
+                           nsRDFDOMNodeList* aElements);
+
+    nsresult
+    ParseTagString(const nsString& aTagName, nsIAtom*& aName, PRInt32& aNameSpaceID);
+
+    NS_IMETHOD PrepareStyleSheets(nsIURI* anURL);
+
+    void SetDocumentURLAndGroup(nsIURI* anURL);
+    void SetIsPopup(PRBool isPopup) { mIsPopup = isPopup; };
+
+    nsresult CreateElement(PRInt32 aNameSpaceID,
+                           nsIAtom* aTag,
+                           nsIContent** aResult);
+
+    nsresult PrepareToLoad(nsIContentViewerContainer* aContainer,
+                           const char* aCommand,
+                           nsIChannel* aChannel,
+                           nsILoadGroup* aLoadGroup,
+                           nsIParser** aResult);
+
+    nsresult
+    PrepareToLoadPrototype(nsIURI* aURI,
+                           const char* aCommand,
+                           nsIPrincipal* aDocumentPrincipal,
+                           nsIParser** aResult);
+
+    nsresult ApplyPersistentAttributes();
+    nsresult ApplyPersistentAttributesToElements(nsIRDFResource* aResource, nsISupportsArray* aElements);
+
+protected:
+    // pseudo constants
+    static PRInt32 gRefCnt;
+
+    static nsIAtom*  kAttributeAtom;
+    static nsIAtom*  kCommandUpdaterAtom;
+    static nsIAtom*  kDataSourcesAtom;
+    static nsIAtom*  kElementAtom;
+    static nsIAtom*  kIdAtom;
+    static nsIAtom*  kKeysetAtom;
+    static nsIAtom*  kObservesAtom;
+    static nsIAtom*  kOpenAtom;
+    static nsIAtom*  kOverlayAtom;
+    static nsIAtom*  kPersistAtom;
+    static nsIAtom*  kPositionAtom;
+    static nsIAtom*  kRefAtom;
+    static nsIAtom*  kRuleAtom;
+    static nsIAtom*  kTemplateAtom;
+
+    static nsIAtom** kIdentityAttrs[];
+
+    static nsIRDFService* gRDFService;
+    static nsIRDFResource* kNC_persist;
+    static nsIRDFResource* kNC_attribute;
+    static nsIRDFResource* kNC_value;
+
+    static nsIHTMLElementFactory* gHTMLElementFactory;
+    static nsIXMLElementFactory* gXMLElementFactory;
+
+    static nsINameSpaceManager* gNameSpaceManager;
+    static PRInt32 kNameSpaceID_XUL;
+
+    static nsIXULContentUtils* gXULUtils;
+    static nsIXULPrototypeCache* gXULCache;
+
+    static PRLogModuleInfo* gXULLog;
+
+    nsIContent*
+    FindContent(const nsIContent* aStartNode,
+                const nsIContent* aTest1,
+                const nsIContent* aTest2) const;
+
+    nsresult
+    Persist(nsIContent* aElement, PRInt32 aNameSpaceID, nsIAtom* aAttribute);
+
+    nsresult
+    DestroyForwardReferences();
+
+    // IMPORTANT: The ownership implicit in the following member variables has been
+    // explicitly checked and set using nsCOMPtr for owning pointers and raw COM interface
+    // pointers for weak (ie, non owning) references. If you add any members to this
+    // class, please make the ownership explicit (pinkerton, scc).
+    // NOTE, THIS IS STILL IN PROGRESS, TALK TO PINK OR SCC BEFORE CHANGING
+
+    nsCOMPtr<nsIArena>         mArena;
+    nsVoidArray                mObservers;
+    nsAutoString               mDocumentTitle;
+    nsCOMPtr<nsIURI>           mDocumentURL;        // [OWNER] ??? compare with loader
+    nsWeakPtr                  mDocumentLoadGroup;  // [WEAK] leads to loader
+    nsCOMPtr<nsIPrincipal>     mDocumentPrincipal;  // [OWNER]
+    nsCOMPtr<nsIContent>       mRootContent;        // [OWNER]
+    nsIDocument*               mParentDocument;     // [WEAK]
+    nsIScriptContextOwner*     mScriptContextOwner; // [WEAK] it owns me! (indirectly)
+    void*                      mScriptObject;       // ????
+    nsXULDocument*             mNextSrcLoadWaiter;  // [OWNER] but not COMPtr
+    nsString                   mCharSetID;
+    nsVoidArray                mStyleSheets;
+    nsCOMPtr<nsIDOMSelection>  mSelection;          // [OWNER]
+    PRBool                     mDisplaySelection;
+    nsVoidArray                mPresShells;
+    nsCOMPtr<nsIEventListenerManager> mListenerManager;   // [OWNER]
+    nsCOMPtr<nsINameSpaceManager>     mNameSpaceManager;  // [OWNER]
+    nsCOMPtr<nsIHTMLStyleSheet>       mAttrStyleSheet;    // [OWNER]
+    nsCOMPtr<nsIHTMLCSSStyleSheet>    mInlineStyleSheet;  // [OWNER]
+    nsCOMPtr<nsICSSLoader>            mCSSLoader;         // [OWNER]
+    nsElementMap               mElementMap;
+    nsCOMPtr<nsISupportsArray> mBuilders;        // [OWNER] of array, elements shouldn't own this, but they do
+    nsCOMPtr<nsIRDFDataSource>          mLocalStore;
+    nsCOMPtr<nsILineBreaker>            mLineBreaker;    // [OWNER]
+    nsCOMPtr<nsIWordBreaker>            mWordBreaker;    // [OWNER]
+    nsIContentViewerContainer* mContentViewerContainer;  // [WEAK] it owns me! (indirectly)
+    nsString                   mCommand;
+    nsVoidArray                mSubDocuments;     // [OWNER] of subelements
+    PRBool                     mIsPopup;
+    nsCOMPtr<nsIDOMHTMLFormElement>     mHiddenForm;   // [OWNER] of this content element
+    nsCOMPtr<nsIDOMXULCommandDispatcher>     mCommandDispatcher; // [OWNER] of the focus tracker
+
+    nsVoidArray mForwardReferences;
+    PRBool mForwardReferencesResolved;
+
+    // The following are pointers into the content model which provide access to
+    // the objects triggering either a popup or a tooltip. These are marked as
+    // [OWNER] only because someone could, through DOM calls, delete the object from the
+    // content model while the popup/tooltip was visible. If we didn't have a reference
+    // to it, the object would go away and we'd be left pointing to garbage. This
+    // does not introduce cycles into the ownership model because this is still
+    // parent/child ownership. Just wanted the reader to know hyatt and I had thought about
+    // this (pinkerton).
+    nsCOMPtr<nsIDOMNode>    mPopupNode;            // [OWNER] element triggering the popup
+    nsCOMPtr<nsIDOMNode>    mTooltipNode;          // [OWNER] element triggering the tooltip
+
+    /**
+     * Context stack, which maintains the state of the Builder and allows
+     * it to be interrupted.
+     */
+    class ContextStack {
+    protected:
+        struct Entry {
+            nsXULPrototypeElement* mPrototype;
+            nsIContent*            mElement;
+            PRInt32                mIndex;
+            Entry*                 mNext;
+        };
+
+        Entry* mTop;
+        PRInt32 mDepth;
+
+    public:
+        ContextStack();
+        ~ContextStack();
+
+        PRInt32 Depth() { return mDepth; }
+
+        nsresult Push(nsXULPrototypeElement* aPrototype, nsIContent* aElement);
+        nsresult Pop();
+        nsresult Peek(nsXULPrototypeElement** aPrototype, nsIContent** aElement, PRInt32* aIndex);
+
+        nsresult SetTopIndex(PRInt32 aIndex);
+
+        PRBool IsInsideXULTemplate();
+    };
+
+    friend class ContextStack;
+    ContextStack mContextStack;
+
+    enum State { eState_Master, eState_Overlay };
+    State mState;
+
+    /**
+     * An array of overlay nsIURIs that have yet to be resolved. The
+     * order of the array is significant: overlays at the _end_ of the
+     * array are resolved before overlays earlier in the array (i.e.,
+     * it is a stack).
+     */
+    nsCOMPtr<nsISupportsArray> mUnloadedOverlays;
+
+    /**
+     * Load the transcluded script at the specified URI. If the
+     * prototype construction must 'block' until the load has
+     * completed, aBlock will be set to true.
+     */
+    nsresult LoadScript(nsXULPrototypeScript *aScriptProto, PRBool* aBlock);
+
+    /**
+     * Execute the precompiled script object scoped by this XUL document's
+     * containing window object, and using its associated script context.
+     */
+    nsresult ExecuteScript(JSObject* aScriptObject);
+
+    /**
+     * Create a delegate content model element from a prototype.
+     */
+    nsresult CreateElement(nsXULPrototypeElement* aPrototype, nsIContent** aResult);
+
+    /**
+     * Create a temporary 'overlay' element to which content nodes
+     * can be attached for later resolution.
+     */
+    nsresult CreateOverlayElement(nsXULPrototypeElement* aPrototype, nsIContent** aResult);
+
+    /**
+     * Add attributes from the prototype to the element.
+     */
+    nsresult AddAttributes(nsXULPrototypeElement* aPrototype, nsIContent* aElement);
+
+    /**
+     * The prototype-script of the current transcluded script that is being
+     * loaded.  For document.write('<script src="nestedwrite.js"><\/script>')
+     * to work, these need to be in a stack element type, and we need to hold
+     * the top of stack here.
+     */
+    nsXULPrototypeScript* mCurrentScriptProto;
+
+    /**
+     * Create a XUL template builder on the specified node if a 'datasources'
+     * attribute is present.
+     */
+    static nsresult
+    CheckTemplateBuilder(nsIContent* aElement);
+
+    /**
+     * Do hookup for <xul:observes> tag
+     */
+    nsresult HookupObserver(nsIContent* aElement);
+
+    /**
+     * Add the current prototype's style sheets to the document.
+     */
+    nsresult AddPrototypeSheets();
+
+    /**
+     * Used to resolve broadcaster references
+     */
+    class BroadcasterHookup : public nsForwardReference
+    {
+    protected:
+        nsXULDocument* mDocument;              // [WEAK]
+        nsCOMPtr<nsIContent> mObservesElement; // [OWNER]
+        PRBool mResolved;
+
+    public:
+        BroadcasterHookup(nsXULDocument* aDocument, nsIContent* aObservesElement) :
+            mDocument(aDocument),
+            mObservesElement(aObservesElement),
+            mResolved(PR_FALSE) {}
+
+        virtual ~BroadcasterHookup();
+
+        virtual Priority GetPriority() { return ePriority_Hookup; }
+        virtual Result Resolve();
+    };
+
+    friend class BroadcasterHookup;
+
+
+    /**
+     * Used to hook up overlays
+     */
+    class OverlayForwardReference : public nsForwardReference
+    {
+    protected:
+        nsXULDocument* mDocument;      // [WEAK]
+        nsCOMPtr<nsIContent> mOverlay; // [OWNER]
+        PRBool mResolved;
+
+        nsresult Merge(nsIContent* aTargetNode, nsIContent* aOverlayNode);
+
+    public:
+        OverlayForwardReference(nsXULDocument* aDocument, nsIContent* aOverlay)
+            : mDocument(aDocument), mOverlay(aOverlay), mResolved(PR_FALSE) {}
+
+        virtual ~OverlayForwardReference();
+
+        virtual Priority GetPriority() { return ePriority_Construction; }
+        virtual Result Resolve();
+    };
+
+    friend class OverlayForwardReference;
+
+
+    static
+    nsresult
+    CheckBroadcasterHookup(nsXULDocument* aDocument,
+                           nsIContent* aElement,
+                           PRBool* aDidResolve);
+
+    static
+    nsresult
+    InsertElement(nsIContent* aParent, nsIContent* aChild);
+
+    static
+    PRBool
+    IsChromeURI(nsIURI* aURI);
+
+    /**
+     * The current prototype that we are walking to construct the
+     * content model.
+     */
+    nsCOMPtr<nsIXULPrototypeDocument> mCurrentPrototype;
+
+    /**
+     * The master document (outermost, .xul) prototype, from which
+     * all subdocuments get their security principals.
+     */
+    nsCOMPtr<nsIXULPrototypeDocument> mMasterPrototype;
+
+    /**
+     * Owning references to all of the prototype documents that were
+     * used to construct this document.
+     */
+    nsCOMPtr<nsISupportsArray> mPrototypes;
+
+    /**
+     * Prepare to walk the current prototype.
+     */
+    nsresult PrepareToWalk();
+
+    /**
+     * Add overlays from the chrome registry to the set of unprocessed
+     * overlays still to do.
+     */
+    nsresult AddChromeOverlays();
+
+    /**
+     * Resume (or initiate) an interrupted (or newly prepared)
+     * prototype walk.
+     */
+    nsresult ResumeWalk();
+
+#if defined(DEBUG_waterson) || defined(DEBUG_hyatt)
+    // timing
+    nsTime mLoadStart;
+#endif
+};
+
+
+
+#endif // nsXULDocument_h__

mozilla/content/xul/document/src/nsXULPrototypeCache.cpp

@@ -0,0 +1,183 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+
+
+ */
+
+#include "nsCOMPtr.h"
+#include "nsICSSStyleSheet.h"
+#include "nsIXULPrototypeCache.h"
+#include "nsIXULPrototypeDocument.h"
+#include "nsIURI.h"
+#include "nsHashtable.h"
+#include "nsXPIDLString.h"
+#include "plstr.h"
+
+
+class nsXULPrototypeCache : public nsIXULPrototypeCache
+{
+public:
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD GetPrototype(nsIURI* aURI, nsIXULPrototypeDocument** _result);
+    NS_IMETHOD PutPrototype(nsIXULPrototypeDocument* aDocument);
+
+    NS_IMETHOD GetStyleSheet(nsIURI* aURI, nsICSSStyleSheet** _result);
+    NS_IMETHOD PutStyleSheet(nsICSSStyleSheet* aStyleSheet);
+
+    NS_IMETHOD Flush();
+
+protected:
+    friend NS_IMETHODIMP
+    NS_NewXULPrototypeCache(nsISupports* aOuter, REFNSIID aIID, void** aResult);
+
+    nsXULPrototypeCache();
+    virtual ~nsXULPrototypeCache();
+
+    nsSupportsHashtable mPrototypeTable;
+    nsSupportsHashtable mStyleSheetTable;
+
+
+    class nsIURIKey : public nsHashKey {
+    protected:
+        nsCOMPtr<nsIURI> mKey;
+  
+    public:
+        nsIURIKey(nsIURI* key) : mKey(key) {}
+        ~nsIURIKey(void) {}
+  
+        PRUint32 HashValue(void) const {
+            nsXPIDLCString spec;
+            mKey->GetSpec(getter_Copies(spec));
+            return (PRUint32) PL_HashString(spec);
+        }
+
+        PRBool Equals(const nsHashKey *aKey) const {
+            PRBool eq;
+            mKey->Equals( ((nsIURIKey*) aKey)->mKey, &eq );
+            return eq;
+        }
+
+        nsHashKey *Clone(void) const {
+            return new nsIURIKey(mKey);
+        }
+    };
+};
+
+
+
+nsXULPrototypeCache::nsXULPrototypeCache()
+{
+    NS_INIT_REFCNT();
+}
+
+
+nsXULPrototypeCache::~nsXULPrototypeCache()
+{
+}
+
+
+NS_IMPL_ISUPPORTS1(nsXULPrototypeCache, nsIXULPrototypeCache);
+
+
+NS_IMETHODIMP
+NS_NewXULPrototypeCache(nsISupports* aOuter, REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(! aOuter, "no aggregation");
+    if (aOuter)
+        return NS_ERROR_NO_AGGREGATION;
+
+    nsXULPrototypeCache* result = new nsXULPrototypeCache();
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    nsresult rv;
+
+    NS_ADDREF(result);
+    rv = result->QueryInterface(aIID, aResult);
+    NS_RELEASE(result);
+
+    return rv;
+}
+
+
+//----------------------------------------------------------------------
+
+
+NS_IMETHODIMP
+nsXULPrototypeCache::GetPrototype(nsIURI* aURI, nsIXULPrototypeDocument** _result)
+{
+    nsIURIKey key(aURI);
+    *_result = NS_STATIC_CAST(nsIXULPrototypeDocument*, mPrototypeTable.Get(&key));
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeCache::PutPrototype(nsIXULPrototypeDocument* aDocument)
+{
+    nsresult rv;
+    nsCOMPtr<nsIURI> uri;
+    rv = aDocument->GetURI(getter_AddRefs(uri));
+
+    nsIURIKey key(uri);
+    mPrototypeTable.Put(&key, aDocument);
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeCache::GetStyleSheet(nsIURI* aURI, nsICSSStyleSheet** _result)
+{
+    nsIURIKey key(aURI);
+    *_result = NS_STATIC_CAST(nsICSSStyleSheet*, mStyleSheetTable.Get(&key));
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeCache::PutStyleSheet(nsICSSStyleSheet* aStyleSheet)
+{
+    nsresult rv;
+    nsCOMPtr<nsIURI> uri;
+    rv = aStyleSheet->GetURL(*getter_AddRefs(uri));
+
+    nsIURIKey key(uri);
+    mStyleSheetTable.Put(&key, aStyleSheet);
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeCache::Flush()
+{
+    mPrototypeTable.Reset();
+    mStyleSheetTable.Reset();
+    return NS_OK;
+}
+

mozilla/content/xul/document/src/nsXULPrototypeDocument.cpp

@@ -0,0 +1,263 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+
+
+*/
+
+#include "nsCOMPtr.h"
+#include "nsString2.h"
+#include "nsVoidArray.h"
+#include "nsIPrincipal.h"
+#include "nsISupportsArray.h"
+#include "nsIURI.h"
+#include "nsIServiceManager.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIXULPrototypeDocument.h"
+#include "nsXULElement.h"
+
+class nsXULPrototypeDocument : public nsIXULPrototypeDocument
+{
+public:
+    static nsresult
+    Create(nsIURI* aURI, nsXULPrototypeDocument** aResult);
+
+    // nsISupports interface
+    NS_DECL_ISUPPORTS
+
+    // nsIXULPrototypeDocument interface
+    NS_IMETHOD GetURI(nsIURI** aResult);
+    NS_IMETHOD SetURI(nsIURI* aURI);
+
+    NS_IMETHOD GetRootElement(nsXULPrototypeElement** aResult);
+    NS_IMETHOD SetRootElement(nsXULPrototypeElement* aElement);
+
+    NS_IMETHOD AddStyleSheetReference(nsIURI* aStyleSheet);
+    NS_IMETHOD GetStyleSheetReferences(nsISupportsArray** aResult);
+
+    NS_IMETHOD AddOverlayReference(nsIURI* aURI);
+    NS_IMETHOD GetOverlayReferences(nsISupportsArray** aResult);
+
+    NS_IMETHOD GetHeaderData(nsIAtom* aField, nsString& aData) const;
+    NS_IMETHOD SetHeaderData(nsIAtom* aField, const nsString& aData);
+
+    NS_IMETHOD GetDocumentPrincipal(nsIPrincipal** aResult);
+    NS_IMETHOD SetDocumentPrincipal(nsIPrincipal* aPrincipal);
+
+protected:
+    nsCOMPtr<nsIURI> mURI;
+    nsXULPrototypeElement* mRoot;
+    nsCOMPtr<nsISupportsArray> mStyleSheetReferences;
+    nsCOMPtr<nsISupportsArray> mOverlayReferences;
+    nsCOMPtr<nsIPrincipal> mDocumentPrincipal;
+
+    nsXULPrototypeDocument();
+    virtual ~nsXULPrototypeDocument();
+    nsresult Init();
+
+    friend NS_IMETHODIMP
+    NS_NewXULPrototypeDocument(nsISupports* aOuter, REFNSIID aIID, void** aResult);
+};
+
+
+//----------------------------------------------------------------------
+
+nsXULPrototypeDocument::nsXULPrototypeDocument()
+    : mRoot(nsnull)
+{
+    NS_INIT_REFCNT();
+}
+
+
+nsresult
+nsXULPrototypeDocument::Init()
+{
+    nsresult rv;
+
+    rv = NS_NewISupportsArray(getter_AddRefs(mStyleSheetReferences));
+    if (NS_FAILED(rv)) return rv;
+
+    rv = NS_NewISupportsArray(getter_AddRefs(mOverlayReferences));
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+
+nsXULPrototypeDocument::~nsXULPrototypeDocument()
+{
+    delete mRoot;
+}
+
+
+NS_IMPL_ISUPPORTS1(nsXULPrototypeDocument, nsIXULPrototypeDocument);
+
+NS_IMETHODIMP
+NS_NewXULPrototypeDocument(nsISupports* aOuter, REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(aOuter == nsnull, "no aggregation");
+    if (aOuter)
+        return NS_ERROR_NO_AGGREGATION;
+
+    nsXULPrototypeDocument* result = new nsXULPrototypeDocument();
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    nsresult rv;
+    rv = result->Init();
+    if (NS_FAILED(rv)) {
+        delete result;
+        return rv;
+    }
+
+    NS_ADDREF(result);
+    rv = result->QueryInterface(aIID, aResult);
+    NS_RELEASE(result);
+
+    return rv;
+}
+
+
+//----------------------------------------------------------------------
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::GetURI(nsIURI** aResult)
+{
+    *aResult = mURI;
+    NS_IF_ADDREF(*aResult);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::SetURI(nsIURI* aURI)
+{
+    mURI = aURI;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::GetRootElement(nsXULPrototypeElement** aResult)
+{
+    *aResult = mRoot;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::SetRootElement(nsXULPrototypeElement* aElement)
+{
+    mRoot = aElement;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::AddStyleSheetReference(nsIURI* aURI)
+{
+    NS_PRECONDITION(aURI != nsnull, "null ptr");
+    if (! aURI)
+        return NS_ERROR_NULL_POINTER;
+
+    mStyleSheetReferences->AppendElement(aURI);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::GetStyleSheetReferences(nsISupportsArray** aResult)
+{
+    *aResult = mStyleSheetReferences;
+    NS_ADDREF(*aResult);
+    return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::AddOverlayReference(nsIURI* aURI)
+{
+    NS_PRECONDITION(aURI != nsnull, "null ptr");
+    if (! aURI)
+        return NS_ERROR_NULL_POINTER;
+
+    mOverlayReferences->AppendElement(aURI);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::GetOverlayReferences(nsISupportsArray** aResult)
+{
+    *aResult = mOverlayReferences;
+    NS_ADDREF(*aResult);
+    return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::GetHeaderData(nsIAtom* aField, nsString& aData) const
+{
+    // XXX Not implemented
+    aData.Truncate();
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::SetHeaderData(nsIAtom* aField, const nsString& aData)
+{
+    // XXX Not implemented
+    return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::GetDocumentPrincipal(nsIPrincipal** aResult)
+{
+    if (!mDocumentPrincipal) {
+        nsresult rv;
+        NS_WITH_SERVICE(nsIScriptSecurityManager, securityManager,
+                        NS_SCRIPTSECURITYMANAGER_PROGID, &rv);
+        if (NS_FAILED(rv))
+            return NS_ERROR_FAILURE;
+        rv = securityManager->CreateCodebasePrincipal(mURI, getter_AddRefs(mDocumentPrincipal));
+        if (NS_FAILED(rv))
+            return NS_ERROR_FAILURE;
+    }
+    *aResult = mDocumentPrincipal;
+    NS_ADDREF(*aResult);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULPrototypeDocument::SetDocumentPrincipal(nsIPrincipal* aPrincipal)
+{
+    mDocumentPrincipal = aPrincipal;
+    return NS_OK;
+}

mozilla/content/xul/templates/public/nsIRDFContentModelBuilder.h

@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+  A content model builder interface. An object that implements this
+  interface is associated with an nsIXULDocument object to construct
+  an NGLayout content model.
+
+ */
+
+#ifndef nsIRDFContentModelBuilder_h__
+#define nsIRDFContentModelBuilder_h__
+
+#include "nsISupports.h"
+
+class nsIAtom;
+class nsIContent;
+class nsIRDFCompositeDataSource;
+class nsIXULDocument;
+class nsIRDFNode;
+class nsIRDFResource;
+
+// {541AFCB0-A9A3-11d2-8EC5-00805F29F370}
+#define NS_IRDFCONTENTMODELBUILDER_IID \
+{ 0x541afcb0, 0xa9a3, 0x11d2, { 0x8e, 0xc5, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }
+
+class nsIRDFContentModelBuilder : public nsISupports
+{
+public:
+    static const nsIID& GetIID() { static nsIID iid = NS_IRDFCONTENTMODELBUILDER_IID; return iid; }
+
+    /**
+     * Point the content model builder to the document. The content model
+     * builder must not reference count the document.
+     */
+    NS_IMETHOD SetDocument(nsIXULDocument* aDocument) = 0;
+
+    NS_IMETHOD SetDataBase(nsIRDFCompositeDataSource* aDataBase) = 0;
+    NS_IMETHOD GetDataBase(nsIRDFCompositeDataSource** aDataBase) = 0;
+
+    /**
+     * Set the root element from which this content model will
+     * operate.
+     */
+    NS_IMETHOD CreateRootContent(nsIRDFResource* aResource) = 0;
+    NS_IMETHOD SetRootContent(nsIContent* aElement) = 0;
+
+    /**
+     * Construct the contents for a container element.
+     */
+    NS_IMETHOD CreateContents(nsIContent* aElement) = 0;
+
+    /** 
+     * 'Open' a container element that was closed before. This gives
+     * the container a chance to populate its contents.
+     */
+    NS_IMETHOD OpenContainer(nsIContent* aContainer) = 0;
+
+    /**
+     * 'Close' an open container. This gives the container a chance to
+     * release unused content nodes.
+     */
+    NS_IMETHOD CloseContainer(nsIContent* aContainer) = 0;
+
+    /**
+     * Rebuild the contents of a container.
+     */
+    NS_IMETHOD RebuildContainer(nsIContent* aContainer) = 0;
+};
+
+extern nsresult NS_NewXULTemplateBuilder(nsIRDFContentModelBuilder** aResult);
+extern nsresult NS_NewRDFXULBuilder(nsIRDFContentModelBuilder** aResult);
+
+#endif // nsIRDFContentModelBuilder_h__

mozilla/content/xul/templates/src/nsXULContentUtils.cpp

@@ -0,0 +1,997 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+/*
+
+  A package of routines shared by the XUL content code.
+
+ */
+
+
+#include "nsCOMPtr.h"
+#include "nsIContent.h"
+#include "nsIDocument.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMXULCommandDispatcher.h"
+#include "nsIDOMXULDocument.h"
+#include "nsIDOMMouseListener.h"
+#include "nsIDOMMouseMotionListener.h"
+#include "nsIDOMLoadListener.h"
+#include "nsIDOMFocusListener.h"
+#include "nsIDOMPaintListener.h"
+#include "nsIDOMKeyListener.h"
+#include "nsIDOMFormListener.h"
+#include "nsIDOMMenuListener.h"
+#include "nsIDOMDragListener.h"
+#include "nsIRDFNode.h"
+#include "nsINameSpace.h"
+#include "nsINameSpaceManager.h"
+#include "nsIPref.h"
+#include "nsIRDFService.h"
+#include "nsIServiceManager.h"
+#include "nsITextContent.h"
+#include "nsIURL.h"
+#include "nsIXMLContent.h"
+#include "nsIXULContentUtils.h"
+#include "nsIXULPrototypeCache.h"
+#include "nsLayoutCID.h"
+#include "nsNeckoUtil.h"
+#include "nsRDFCID.h"
+#include "nsString.h"
+#include "nsXPIDLString.h"
+#include "prlog.h"
+#include "prtime.h"
+#include "rdf.h"
+#include "rdfutil.h"
+
+#include "nsILocale.h"
+#include "nsLocaleCID.h"
+#include "nsILocaleFactory.h"
+
+#include "nsIDateTimeFormat.h"
+#include "nsDateTimeFormatCID.h"
+#include "nsIScriptableDateFormat.h"
+
+
+static NS_DEFINE_CID(kDateTimeFormatCID,    NS_DATETIMEFORMAT_CID);
+static NS_DEFINE_CID(kDateTimeFormatIID,    NS_IDATETIMEFORMAT_IID);
+static NS_DEFINE_CID(kLocaleCID,            NS_LOCALE_CID);
+static NS_DEFINE_CID(kLocaleFactoryCID,     NS_LOCALEFACTORY_CID);
+static NS_DEFINE_CID(kNameSpaceManagerCID,  NS_NAMESPACEMANAGER_CID);
+static NS_DEFINE_CID(kRDFServiceCID,        NS_RDFSERVICE_CID);
+static NS_DEFINE_CID(kTextNodeCID,          NS_TEXTNODE_CID);
+static NS_DEFINE_CID(kXULPrototypeCacheCID, NS_XULPROTOTYPECACHE_CID);
+
+//------------------------------------------------------------------------
+
+class nsXULContentUtils : public nsIXULContentUtils
+{
+protected:
+    nsXULContentUtils();
+    nsresult Init();
+    virtual ~nsXULContentUtils();
+
+    friend NS_IMETHODIMP
+    NS_NewXULContentUtils(nsISupports* aOuter, const nsIID& aIID, void** aResult);
+
+    static nsrefcnt gRefCnt;
+    static nsIRDFService* gRDF;
+    static nsINameSpaceManager* gNameSpaceManager;
+    static nsIDateTimeFormat* gFormat;
+
+    static nsIAtom* kEventsAtom;
+    static nsIAtom* kTargetsAtom;
+
+    struct EventHandlerMapEntry {
+        const char*  mAttributeName;
+        nsIAtom*     mAttributeAtom;
+        const nsIID* mHandlerIID;
+    };
+
+    static EventHandlerMapEntry kEventHandlerMap[];
+
+    static PRBool gDisableXULCache;
+
+    static int
+    DisableXULCacheChangedCallback(const char* aPrefName, void* aClosure);
+
+public:
+    // nsISupports methods
+    NS_DECL_ISUPPORTS
+
+    // nsIXULContentUtils methods
+    NS_IMETHOD
+    AttachTextNode(nsIContent* parent, nsIRDFNode* value);
+    
+    NS_IMETHOD
+    FindChildByTag(nsIContent *aElement,
+                   PRInt32 aNameSpaceID,
+                   nsIAtom* aTag,
+                   nsIContent **aResult);
+
+    NS_IMETHOD
+    FindChildByResource(nsIContent* aElement,
+                        nsIRDFResource* aResource,
+                        nsIContent** aResult);
+
+    NS_IMETHOD
+    GetElementResource(nsIContent* aElement, nsIRDFResource** aResult);
+
+    NS_IMETHOD
+    GetElementRefResource(nsIContent* aElement, nsIRDFResource** aResult);
+
+    NS_IMETHOD
+    GetTextForNode(nsIRDFNode* aNode, nsString& aResult);
+
+    NS_IMETHOD
+    GetElementLogString(nsIContent* aElement, nsString& aResult);
+
+    NS_IMETHOD
+    GetAttributeLogString(nsIContent* aElement, PRInt32 aNameSpaceID, nsIAtom* aTag, nsString& aResult);
+
+    NS_IMETHOD
+    MakeElementURI(nsIDocument* aDocument, const nsString& aElementID, nsCString& aURI);
+
+    NS_IMETHOD
+    MakeElementResource(nsIDocument* aDocument, const nsString& aElementID, nsIRDFResource** aResult);
+
+    NS_IMETHOD
+    MakeElementID(nsIDocument* aDocument, const nsString& aURI, nsString& aElementID);
+
+    NS_IMETHOD_(PRBool)
+    IsContainedBy(nsIContent* aElement, nsIContent* aContainer);
+
+    NS_IMETHOD
+    GetResource(PRInt32 aNameSpaceID, nsIAtom* aAttribute, nsIRDFResource** aResult);
+
+    NS_IMETHOD
+    GetResource(PRInt32 aNameSpaceID, const nsString& aAttribute, nsIRDFResource** aResult);
+
+    NS_IMETHOD
+    SetCommandUpdater(nsIDocument* aDocument, nsIContent* aElement);
+
+    NS_IMETHOD
+    GetEventHandlerIID(nsIAtom* aName, nsIID* aIID, PRBool* aFound);
+
+    NS_IMETHOD_(PRBool)
+    UseXULCache();
+};
+
+nsrefcnt nsXULContentUtils::gRefCnt;
+nsIRDFService* nsXULContentUtils::gRDF;
+nsINameSpaceManager* nsXULContentUtils::gNameSpaceManager;
+nsIDateTimeFormat* nsXULContentUtils::gFormat;
+
+nsIAtom* nsXULContentUtils::kEventsAtom;
+nsIAtom* nsXULContentUtils::kTargetsAtom;
+
+nsXULContentUtils::EventHandlerMapEntry
+nsXULContentUtils::kEventHandlerMap[] = {
+    { "onclick",         nsnull, &NS_GET_IID(nsIDOMMouseListener)       },
+    { "ondblclick",      nsnull, &NS_GET_IID(nsIDOMMouseListener)       },
+    { "onmousedown",     nsnull, &NS_GET_IID(nsIDOMMouseListener)       },
+    { "onmouseup",       nsnull, &NS_GET_IID(nsIDOMMouseListener)       },
+    { "onmouseover",     nsnull, &NS_GET_IID(nsIDOMMouseListener)       },
+    { "onmouseout",      nsnull, &NS_GET_IID(nsIDOMMouseListener)       },
+
+    { "onmousemove",     nsnull, &NS_GET_IID(nsIDOMMouseMotionListener) },
+
+    { "onkeydown",       nsnull, &NS_GET_IID(nsIDOMKeyListener)         },
+    { "onkeyup",         nsnull, &NS_GET_IID(nsIDOMKeyListener)         },
+    { "onkeypress",      nsnull, &NS_GET_IID(nsIDOMKeyListener)         },
+
+    { "onload",          nsnull, &NS_GET_IID(nsIDOMLoadListener)        },
+    { "onunload",        nsnull, &NS_GET_IID(nsIDOMLoadListener)        },
+    { "onabort",         nsnull, &NS_GET_IID(nsIDOMLoadListener)        },
+    { "onerror",         nsnull, &NS_GET_IID(nsIDOMLoadListener)        },
+
+    { "oncreate",        nsnull, &NS_GET_IID(nsIDOMMenuListener)        },
+    { "ondestroy",       nsnull, &NS_GET_IID(nsIDOMMenuListener)        },
+    { "oncommand",       nsnull, &NS_GET_IID(nsIDOMMenuListener)        },
+    { "onbroadcast",     nsnull, &NS_GET_IID(nsIDOMMenuListener)        },
+    { "oncommandupdate", nsnull, &NS_GET_IID(nsIDOMMenuListener)        },
+
+    { "onfocus",         nsnull, &NS_GET_IID(nsIDOMFocusListener)       },
+    { "onblur",          nsnull, &NS_GET_IID(nsIDOMFocusListener)       },
+
+    { "onsubmit",        nsnull, &NS_GET_IID(nsIDOMFormListener)        },
+    { "onreset",         nsnull, &NS_GET_IID(nsIDOMFormListener)        },
+    { "onchange",        nsnull, &NS_GET_IID(nsIDOMFormListener)        },
+    { "onselect",        nsnull, &NS_GET_IID(nsIDOMFormListener)        },
+    { "oninput",         nsnull, &NS_GET_IID(nsIDOMFormListener)        },
+
+    { "onpaint",         nsnull, &NS_GET_IID(nsIDOMPaintListener)       },
+    
+    { "ondragenter",     nsnull, &NS_GET_IID(nsIDOMDragListener)        },
+    { "ondragover",      nsnull, &NS_GET_IID(nsIDOMDragListener)        },
+    { "ondragexit",      nsnull, &NS_GET_IID(nsIDOMDragListener)        },
+    { "ondragdrop",      nsnull, &NS_GET_IID(nsIDOMDragListener)        },
+    { "ondraggesture",   nsnull, &NS_GET_IID(nsIDOMDragListener)        },
+
+    { nsnull,            nsnull, nsnull                                 }
+};
+
+
+// Enabled by default. Must be over-ridden to disable
+PRBool nsXULContentUtils::gDisableXULCache = PR_FALSE;
+
+
+static const char kDisableXULCachePref[] = "nglayout.debug.disable_xul_cache";
+
+//------------------------------------------------------------------------
+// Constructors n' stuff
+//
+
+nsXULContentUtils::nsXULContentUtils()
+{
+    NS_INIT_REFCNT();
+}
+
+nsresult
+nsXULContentUtils::Init()
+{
+    if (gRefCnt++ == 0) {
+        nsresult rv;
+        rv = nsServiceManager::GetService(kRDFServiceCID,
+                                          NS_GET_IID(nsIRDFService),
+                                          (nsISupports**) &gRDF);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = nsComponentManager::CreateInstance(kNameSpaceManagerCID,
+                                                nsnull,
+                                                NS_GET_IID(nsINameSpaceManager),
+                                                (void**) &gNameSpaceManager);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = nsComponentManager::CreateInstance(kDateTimeFormatCID,
+                                                nsnull,
+                                                NS_GET_IID(nsIDateTimeFormat),
+                                                (void**) &gFormat);
+
+        if (NS_FAILED(rv)) return rv;
+
+        kEventsAtom  = NS_NewAtom("events");
+        kTargetsAtom = NS_NewAtom("targets");
+
+        EventHandlerMapEntry* entry = kEventHandlerMap;
+        while (entry->mAttributeName) {
+            entry->mAttributeAtom = NS_NewAtom(entry->mAttributeName);
+            ++entry;
+        }
+
+        NS_WITH_SERVICE(nsIPref, prefs, NS_PREF_PROGID, &rv);
+        if (NS_SUCCEEDED(rv)) {
+            // XXX Ignore return values.
+            prefs->GetBoolPref(kDisableXULCachePref, &gDisableXULCache);
+            prefs->RegisterCallback(kDisableXULCachePref, DisableXULCacheChangedCallback, nsnull);
+        }
+    }
+    return NS_OK;
+}
+
+
+nsXULContentUtils::~nsXULContentUtils()
+{
+#ifdef DEBUG_REFS
+    --gInstanceCount;
+    fprintf(stdout, "%d - RDF: nsXULContentUtils\n", gInstanceCount);
+#endif
+
+    if (--gRefCnt == 0) {
+        if (gRDF) {
+            nsServiceManager::ReleaseService(kRDFServiceCID, gRDF);
+            gRDF = nsnull;
+        }
+
+        NS_IF_RELEASE(gNameSpaceManager);
+
+        NS_IF_RELEASE(kEventsAtom);
+        NS_IF_RELEASE(kTargetsAtom);
+
+        EventHandlerMapEntry* entry = kEventHandlerMap;
+        while (entry->mAttributeName) {
+            NS_IF_RELEASE(entry->mAttributeAtom);
+            ++entry;
+        }
+    }
+}
+
+NS_IMETHODIMP
+NS_NewXULContentUtils(nsISupports* aOuter, const nsIID& aIID, void** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aOuter == nsnull, "no aggregation");
+    if (aOuter)
+        return NS_ERROR_NO_AGGREGATION;
+
+    nsXULContentUtils* result = new nsXULContentUtils();
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    nsresult rv;
+    rv = result->Init();
+    if (NS_FAILED(rv)) {
+        delete result;
+        return rv;
+    }
+
+    NS_ADDREF(result);
+    rv = result->QueryInterface(aIID, aResult);
+    NS_RELEASE(result);
+
+    return rv;
+}
+
+
+
+//------------------------------------------------------------------------
+// nsISupports methods
+
+NS_IMPL_ISUPPORTS(nsXULContentUtils, NS_GET_IID(nsIXULContentUtils));
+
+//------------------------------------------------------------------------
+// nsIXULContentUtils methods
+
+NS_IMETHODIMP
+nsXULContentUtils::AttachTextNode(nsIContent* parent, nsIRDFNode* value)
+{
+    nsresult rv;
+
+    nsAutoString s;
+    rv = GetTextForNode(value, s);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsITextContent> text;
+    rv = nsComponentManager::CreateInstance(kTextNodeCID,
+                                            nsnull,
+                                            NS_GET_IID(nsITextContent),
+                                            getter_AddRefs(text));
+    if (NS_FAILED(rv)) return rv;
+
+
+    rv = text->SetText(s.GetUnicode(), s.Length(), PR_FALSE);
+    if (NS_FAILED(rv)) return rv;
+
+    // hook it up to the child
+    rv = parent->AppendChildTo(nsCOMPtr<nsIContent>( do_QueryInterface(text) ), PR_FALSE);
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::FindChildByTag(nsIContent* aElement,
+                                  PRInt32 aNameSpaceID,
+                                  nsIAtom* aTag,
+                                  nsIContent** aResult)
+{
+    nsresult rv;
+
+    PRInt32 count;
+    if (NS_FAILED(rv = aElement->ChildCount(count)))
+        return rv;
+
+    for (PRInt32 i = 0; i < count; ++i) {
+        nsCOMPtr<nsIContent> kid;
+        if (NS_FAILED(rv = aElement->ChildAt(i, *getter_AddRefs(kid))))
+            return rv; // XXX fatal
+
+        PRInt32 nameSpaceID;
+        if (NS_FAILED(rv = kid->GetNameSpaceID(nameSpaceID)))
+            return rv; // XXX fatal
+
+        if (nameSpaceID != aNameSpaceID)
+            continue; // wrong namespace
+
+        nsCOMPtr<nsIAtom> kidTag;
+        if (NS_FAILED(rv = kid->GetTag(*getter_AddRefs(kidTag))))
+            return rv; // XXX fatal
+
+        if (kidTag.get() != aTag)
+            continue;
+
+        *aResult = kid;
+        NS_ADDREF(*aResult);
+        return NS_OK;
+    }
+
+    return NS_RDF_NO_VALUE; // not found
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::FindChildByResource(nsIContent* aElement,
+                                       nsIRDFResource* aResource,
+                                       nsIContent** aResult)
+{
+    nsresult rv;
+
+    PRInt32 count;
+    if (NS_FAILED(rv = aElement->ChildCount(count)))
+        return rv;
+
+    for (PRInt32 i = 0; i < count; ++i) {
+        nsCOMPtr<nsIContent> kid;
+        if (NS_FAILED(rv = aElement->ChildAt(i, *getter_AddRefs(kid))))
+            return rv; // XXX fatal
+
+        // Now get the resource ID from the RDF:ID attribute. We do it
+        // via the content model, because you're never sure who
+        // might've added this stuff in...
+        nsCOMPtr<nsIRDFResource> resource;
+        rv = GetElementResource(kid, getter_AddRefs(resource));
+        if (NS_FAILED(rv)) continue;
+
+        if (resource.get() != aResource)
+            continue; // not the resource we want
+
+        // Fount it!
+        *aResult = kid;
+        NS_ADDREF(*aResult);
+        return NS_OK;
+    }
+
+    return NS_RDF_NO_VALUE; // not found
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::GetElementResource(nsIContent* aElement, nsIRDFResource** aResult)
+{
+    // Perform a reverse mapping from an element in the content model
+    // to an RDF resource.
+    nsresult rv;
+
+    PRUnichar buf[128];
+    nsAutoString id(CBufDescriptor(buf, PR_TRUE, sizeof(buf) / sizeof(PRUnichar), 0));
+
+    nsCOMPtr<nsIAtom> kIdAtom( dont_AddRef(NS_NewAtom("id")) );
+    rv = aElement->GetAttribute(kNameSpaceID_None, kIdAtom, id);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "severe error retrieving attribute");
+    if (NS_FAILED(rv)) return rv;
+
+    if (rv != NS_CONTENT_ATTR_HAS_VALUE)
+        return NS_ERROR_FAILURE;
+
+    // Since the element will store its ID attribute as a document-relative value,
+    // we may need to qualify it first...
+    nsCOMPtr<nsIDocument> doc;
+    rv = aElement->GetDocument(*getter_AddRefs(doc));
+    if (NS_FAILED(rv)) return rv;
+
+    NS_ASSERTION(doc != nsnull, "element is not in any document");
+    if (! doc)
+        return NS_ERROR_FAILURE;
+
+    rv = nsXULContentUtils::MakeElementResource(doc, id, aResult);
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::GetElementRefResource(nsIContent* aElement, nsIRDFResource** aResult)
+{
+    // Perform a reverse mapping from an element in the content model
+    // to an RDF resource. Check for a "ref" attribute first, then
+    // fallback on an "id" attribute.
+    nsresult rv;
+    PRUnichar buf[128];
+    nsAutoString uri(CBufDescriptor(buf, PR_TRUE, sizeof(buf) / sizeof(PRUnichar), 0));
+
+    nsCOMPtr<nsIAtom> kIdAtom( dont_AddRef(NS_NewAtom("ref")) );
+    rv = aElement->GetAttribute(kNameSpaceID_None, kIdAtom, uri);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "severe error retrieving attribute");
+    if (NS_FAILED(rv)) return rv;
+
+    if (rv == NS_CONTENT_ATTR_HAS_VALUE) {
+        // We'll use rdf_MakeAbsolute() to translate this to a URL.
+        nsCOMPtr<nsIDocument> doc;
+        rv = aElement->GetDocument(*getter_AddRefs(doc));
+        if (NS_FAILED(rv)) return rv;
+
+        nsCOMPtr<nsIURI> url = dont_AddRef( doc->GetDocumentURL() );
+        NS_ASSERTION(url != nsnull, "element has no document");
+        if (! url)
+            return NS_ERROR_UNEXPECTED;
+
+        rv = rdf_MakeAbsoluteURI(url, uri);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = gRDF->GetUnicodeResource(uri.GetUnicode(), aResult);
+    }
+    else {
+        rv = GetElementResource(aElement, aResult);
+    }
+
+    return rv;
+}
+
+
+
+/*
+	Note: this routine is similiar, yet distinctly different from, nsBookmarksService::GetTextForNode
+*/
+
+NS_IMETHODIMP
+nsXULContentUtils::GetTextForNode(nsIRDFNode* aNode, nsString& aResult)
+{
+    if (! aNode) {
+        aResult.Truncate();
+        return NS_OK;
+    }
+
+    nsresult rv;
+
+    // Literals are the most common, so try these first.
+    nsCOMPtr<nsIRDFLiteral> literal = do_QueryInterface(aNode);
+    if (literal) {
+        const PRUnichar* p;
+        rv = literal->GetValueConst(&p);
+        if (NS_FAILED(rv)) return rv;
+
+        aResult = p;
+        return NS_OK;
+    }
+
+    nsCOMPtr<nsIRDFDate> dateLiteral = do_QueryInterface(aNode);
+    if (dateLiteral) {
+        PRInt64	value;
+        rv = dateLiteral->GetValue(&value);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = gFormat->FormatPRTime(nsnull /* nsILocale* locale */,
+                                  kDateFormatShort,
+                                  kTimeFormatSeconds,
+                                  PRTime(value),
+                                  aResult);
+
+        if (NS_FAILED(rv)) return rv;
+
+        return NS_OK;
+    }
+
+    nsCOMPtr<nsIRDFInt> intLiteral = do_QueryInterface(aNode);
+    if (intLiteral) {
+        PRInt32	value;
+        rv = intLiteral->GetValue(&value);
+        if (NS_FAILED(rv)) return rv;
+
+        aResult.Truncate();
+        aResult.Append(value, 10);
+        return NS_OK;
+    }
+
+
+    nsCOMPtr<nsIRDFResource> resource = do_QueryInterface(aNode);
+    if (resource) {
+        const char* p;
+        rv = resource->GetValueConst(&p);
+        if (NS_FAILED(rv)) return rv;
+        aResult = p;
+        return NS_OK;
+    }
+
+    NS_ERROR("not a resource or a literal");
+    return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMETHODIMP
+nsXULContentUtils::GetElementLogString(nsIContent* aElement, nsString& aResult)
+{
+    nsresult rv;
+
+    aResult = '<';
+
+    nsCOMPtr<nsINameSpace> ns;
+
+    PRInt32 elementNameSpaceID;
+    rv = aElement->GetNameSpaceID(elementNameSpaceID);
+    if (NS_FAILED(rv)) return rv;
+
+    if (kNameSpaceID_HTML == elementNameSpaceID) {
+        aResult.Append("html:");
+    }
+    else {
+        nsCOMPtr<nsIXMLContent> xml( do_QueryInterface(aElement) );
+        NS_ASSERTION(xml != nsnull, "not an XML or HTML element");
+        if (! xml) return NS_ERROR_UNEXPECTED;
+
+        rv = xml->GetContainingNameSpace(*getter_AddRefs(ns));
+        if (NS_FAILED(rv)) return rv;
+        
+        nsCOMPtr<nsIAtom> prefix;
+        rv = ns->FindNameSpacePrefix(elementNameSpaceID, *getter_AddRefs(prefix));
+        if (NS_SUCCEEDED(rv) && (prefix != nsnull)) {
+            nsAutoString prefixStr;
+            prefix->ToString(prefixStr);
+            if (prefixStr.Length()) {
+                const PRUnichar *unicodeString;
+                prefix->GetUnicode(&unicodeString);
+                aResult.Append(unicodeString);
+                aResult.Append(':');
+            }
+        }
+    }
+
+    nsCOMPtr<nsIAtom> tag;
+    rv = aElement->GetTag(*getter_AddRefs(tag));
+    if (NS_FAILED(rv)) return rv;
+
+    const PRUnichar *unicodeString;
+    tag->GetUnicode(&unicodeString);
+    aResult.Append(unicodeString);
+
+    PRInt32 count;
+    rv = aElement->GetAttributeCount(count);
+    if (NS_FAILED(rv)) return rv;
+
+    for (PRInt32 i = 0; i < count; ++i) {
+        aResult.Append(' ');
+
+        PRInt32 nameSpaceID;
+        nsCOMPtr<nsIAtom> name;
+        rv = aElement->GetAttributeNameAt(i, nameSpaceID, *getter_AddRefs(name));
+        if (NS_FAILED(rv)) return rv;
+
+        nsAutoString attr;
+        nsXULContentUtils::GetAttributeLogString(aElement, nameSpaceID, name, attr);
+
+        aResult.Append(attr);
+        aResult.Append("=\"");
+
+        nsAutoString value;
+        rv = aElement->GetAttribute(nameSpaceID, name, value);
+        if (NS_FAILED(rv)) return rv;
+
+        aResult.Append(value);
+        aResult.Append("\"");
+    }
+
+    aResult.Append('>');
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::GetAttributeLogString(nsIContent* aElement, PRInt32 aNameSpaceID, nsIAtom* aTag, nsString& aResult)
+{
+    nsresult rv;
+
+    PRInt32 elementNameSpaceID;
+    rv = aElement->GetNameSpaceID(elementNameSpaceID);
+    if (NS_FAILED(rv)) return rv;
+
+    if ((kNameSpaceID_HTML == elementNameSpaceID) ||
+        (kNameSpaceID_None == aNameSpaceID)) {
+        aResult.Truncate();
+    }
+    else {
+        // we may have a namespace prefix on the attribute
+        nsCOMPtr<nsIXMLContent> xml( do_QueryInterface(aElement) );
+        NS_ASSERTION(xml != nsnull, "not an XML or HTML element");
+        if (! xml) return NS_ERROR_UNEXPECTED;
+
+        nsCOMPtr<nsINameSpace> ns;
+        rv = xml->GetContainingNameSpace(*getter_AddRefs(ns));
+        if (NS_FAILED(rv)) return rv;
+
+        nsCOMPtr<nsIAtom> prefix;
+        rv = ns->FindNameSpacePrefix(aNameSpaceID, *getter_AddRefs(prefix));
+        if (NS_SUCCEEDED(rv) && (prefix != nsnull)) {
+            nsAutoString prefixStr;
+            prefix->ToString(prefixStr);
+            if (prefixStr.Length()) {
+                const PRUnichar *unicodeString;
+                prefix->GetUnicode(&unicodeString);
+                aResult.Append(unicodeString);
+                aResult.Append(':');
+            }
+        }
+    }
+
+    const PRUnichar *unicodeString;
+    aTag->GetUnicode(&unicodeString);
+    aResult.Append(unicodeString);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::MakeElementURI(nsIDocument* aDocument, const nsString& aElementID, nsCString& aURI)
+{
+    // Convert an element's ID to a URI that can be used to refer to
+    // the element in the XUL graph.
+
+    if (aElementID.FindChar(':') > 0) {
+        // Assume it's absolute already. Use as is.
+        aURI = aElementID;
+    }
+    else {
+        nsresult rv;
+
+        nsCOMPtr<nsIURI> docURL;
+        rv = aDocument->GetBaseURL(*getter_AddRefs(docURL));
+        if (NS_FAILED(rv)) return rv;
+
+        // XXX Urgh. This is so broken; I'd really just like to use
+        // NS_MakeAbsolueURI(). Unfortunatly, doing that breaks
+        // MakeElementID in some cases that I haven't yet been able to
+        // figure out.
+#define USE_BROKEN_RELATIVE_PARSING
+#ifdef USE_BROKEN_RELATIVE_PARSING
+        nsXPIDLCString spec;
+        docURL->GetSpec(getter_Copies(spec));
+        if (! spec)
+            return NS_ERROR_FAILURE;
+
+        aURI = spec;
+
+        if (aElementID.First() != '#') {
+            aURI.Append('#');
+        }
+        aURI.Append(nsCAutoString(aElementID));
+#else
+        nsXPIDLCString spec;
+        rv = NS_MakeAbsoluteURI(nsCAutoString(aElementID), docURL, getter_Copies(spec));
+        if (NS_SUCCEEDED(rv)) {
+            aURI = spec;
+        }
+        else {
+            NS_WARNING("MakeElementURI: NS_MakeAbsoluteURI failed");
+            aURI = aElementID;
+        }
+#endif
+    }
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::MakeElementResource(nsIDocument* aDocument, const nsString& aID, nsIRDFResource** aResult)
+{
+    nsresult rv;
+
+    char buf[256];
+    nsCAutoString uri(CBufDescriptor(buf, PR_TRUE, sizeof(buf), 0));
+    rv = MakeElementURI(aDocument, aID, uri);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = gRDF->GetResource(uri, aResult);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create resource");
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+nsXULContentUtils::MakeElementID(nsIDocument* aDocument, const nsString& aURI, nsString& aElementID)
+{
+    // Convert a URI into an element ID that can be accessed from the
+    // DOM APIs.
+    nsresult rv;
+
+    nsCOMPtr<nsIURI> docURL;
+    rv = aDocument->GetBaseURL(*getter_AddRefs(docURL));
+    if (NS_FAILED(rv)) return rv;
+
+    nsXPIDLCString spec;
+    docURL->GetSpec(getter_Copies(spec));
+    if (! spec)
+        return NS_ERROR_FAILURE;
+
+    if (aURI.Find(spec) == 0) {
+#ifdef USE_BROKEN_RELATIVE_PARSING
+        static const PRInt32 kFudge = 1;  // XXX assume '#'
+#else
+        static const PRInt32 kFudge = 0;
+#endif
+        PRInt32 len = PL_strlen(spec);
+        aURI.Right(aElementID, aURI.Length() - (len + kFudge));
+    }
+    else {
+        aElementID = aURI;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP_(PRBool)
+nsXULContentUtils::IsContainedBy(nsIContent* aElement, nsIContent* aContainer)
+{
+    nsCOMPtr<nsIContent> element( dont_QueryInterface(aElement) );
+    while (element) {
+        nsresult rv;
+
+        nsCOMPtr<nsIContent> parent;
+        rv = element->GetParent(*getter_AddRefs(parent));
+        if (NS_FAILED(rv)) return PR_FALSE;
+
+        if (parent.get() == aContainer)
+            return PR_TRUE;
+
+        element = parent;
+    }
+
+    return PR_FALSE;
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::GetResource(PRInt32 aNameSpaceID, nsIAtom* aAttribute, nsIRDFResource** aResult)
+{
+    // construct a fully-qualified URI from the namespace/tag pair.
+    NS_PRECONDITION(aAttribute != nsnull, "null ptr");
+    if (! aAttribute)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+
+    nsAutoString attr;
+    rv = aAttribute->ToString(attr);
+    if (NS_FAILED(rv)) return rv;
+
+    return GetResource(aNameSpaceID, attr, aResult);
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::GetResource(PRInt32 aNameSpaceID, const nsString& aAttribute, nsIRDFResource** aResult)
+{
+    // construct a fully-qualified URI from the namespace/tag pair.
+
+    // XXX should we allow nodes with no namespace???
+    //NS_PRECONDITION(aNameSpaceID != kNameSpaceID_Unknown, "no namespace");
+    //if (aNameSpaceID == kNameSpaceID_Unknown)
+    //    return NS_ERROR_UNEXPECTED;
+
+    nsresult rv;
+
+    PRUnichar buf[256];
+    nsAutoString uri(CBufDescriptor(buf, PR_TRUE, sizeof(buf) / sizeof(PRUnichar), 0));
+    if (aNameSpaceID != kNameSpaceID_Unknown && aNameSpaceID != kNameSpaceID_None) {
+        rv = gNameSpaceManager->GetNameSpaceURI(aNameSpaceID, uri);
+        // XXX ignore failure; treat as "no namespace"
+    }
+
+    // XXX check to see if we need to insert a '/' or a '#'. Oy.
+    if (uri.Length() > 0 && uri.Last() != '#' && uri.Last() != '/' && aAttribute.First() != '#')
+        uri.Append('#');
+
+    uri.Append(aAttribute);
+
+    rv = gRDF->GetUnicodeResource(uri.GetUnicode(), aResult);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get resource");
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsXULContentUtils::SetCommandUpdater(nsIDocument* aDocument, nsIContent* aElement)
+{
+    // Deal with setting up a 'commandupdater'. Pulls the 'events' and
+    // 'targets' attributes off of aElement, and adds it to the
+    // document's command dispatcher.
+    NS_PRECONDITION(aDocument != nsnull, "null ptr");
+    if (! aDocument)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aElement != nsnull, "null ptr");
+    if (! aElement)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+
+    nsCOMPtr<nsIDOMXULDocument> xuldoc = do_QueryInterface(aDocument);
+    NS_ASSERTION(xuldoc != nsnull, "not a xul document");
+    if (! xuldoc)
+        return NS_ERROR_UNEXPECTED;
+
+    nsCOMPtr<nsIDOMXULCommandDispatcher> dispatcher;
+    rv = xuldoc->GetCommandDispatcher(getter_AddRefs(dispatcher));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get dispatcher");
+    if (NS_FAILED(rv)) return rv;
+
+    NS_ASSERTION(dispatcher != nsnull, "no dispatcher");
+    if (! dispatcher)
+        return NS_ERROR_UNEXPECTED;
+
+    nsAutoString events;
+    rv = aElement->GetAttribute(kNameSpaceID_None, kEventsAtom, events);
+
+    if (rv != NS_CONTENT_ATTR_HAS_VALUE)
+        events = "*";
+
+    nsAutoString targets;
+    rv = aElement->GetAttribute(kNameSpaceID_None, kTargetsAtom, targets);
+
+    if (rv != NS_CONTENT_ATTR_HAS_VALUE)
+        targets = "*";
+
+    nsCOMPtr<nsIDOMElement> domelement = do_QueryInterface(aElement);
+    NS_ASSERTION(domelement != nsnull, "not a DOM element");
+    if (! domelement)
+        return NS_ERROR_UNEXPECTED;
+
+    rv = dispatcher->AddCommandUpdater(domelement, events, targets);
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXULContentUtils::GetEventHandlerIID(nsIAtom* aName, nsIID* aIID, PRBool* aFound)
+{
+    *aFound = PR_FALSE;
+
+    EventHandlerMapEntry* entry = kEventHandlerMap;
+    while (entry->mAttributeAtom) {
+        if (entry->mAttributeAtom == aName) {
+            *aIID = *entry->mHandlerIID;
+            *aFound = PR_TRUE;
+            break;
+        }
+        ++entry;
+    }
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP_(PRBool)
+nsXULContentUtils::UseXULCache()
+{
+    return !gDisableXULCache;
+}
+
+
+//----------------------------------------------------------------------
+
+int
+nsXULContentUtils::DisableXULCacheChangedCallback(const char* aPref, void* aClosure)
+{
+    nsresult rv;
+
+    NS_WITH_SERVICE(nsIPref, prefs, NS_PREF_PROGID, &rv);
+    if (NS_SUCCEEDED(rv)) {
+        prefs->GetBoolPref(kDisableXULCachePref, &gDisableXULCache);
+    }
+
+    // Flush the cache, regardless
+    NS_WITH_SERVICE(nsIXULPrototypeCache, cache, kXULPrototypeCacheCID, &rv);
+    if (NS_SUCCEEDED(rv)) {
+        cache->Flush();
+    }
+
+    return 0;
+}

mozilla/dom/public/MANIFEST

@@ -0,0 +1,37 @@
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+# This is a list of local files which get copied to the mozilla:dist:dom directory
+#
+
+nsIScriptContext.h
+nsIJSScriptObject.h
+nsIJSNativeInitializer.h
+nsIScriptObjectOwner.h
+nsIScriptContextOwner.h
+nsIScriptGlobalObject.h
+nsIScriptEventListener.h
+nsIDOMScriptObjectFactory.h
+nsIDOMNativeObjectRegistry.h
+nsDOMCID.h
+nsIScriptGlobalObjectData.h
+nsIScriptNameSetRegistry.h
+nsIScriptExternalNameSet.h
+nsIScriptNameSpaceManager.h
+nsDOMError.h

mozilla/dom/public/MANIFEST_IDL

@@ -0,0 +1 @@
+domstubs.idl

mozilla/dom/public/Makefile.in

@@ -0,0 +1,56 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= dom
+
+DIRS		= base coreDom coreEvents range events html css
+
+XPIDLSRCS	= domstubs.idl
+
+EXPORTS		= \
+		nsIScriptContext.h \
+		nsIScriptContextOwner.h \
+		nsIJSScriptObject.h \
+		nsIJSNativeInitializer.h \
+		nsIScriptEventListener.h \
+		nsIScriptObjectOwner.h \
+		nsIScriptGlobalObject.h \
+		nsIDOMScriptObjectFactory.h \
+		nsIDOMNativeObjectRegistry.h \
+		nsDOMCID.h \
+		nsIScriptGlobalObjectData.h \
+		nsIScriptNameSetRegistry.h \
+		nsIScriptExternalNameSet.h \
+		nsIScriptNameSpaceManager.h \
+		nsDOMError.h \
+		$(NULL)
+
+EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/dom/public/base/MANIFEST

@@ -0,0 +1,37 @@
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+# This is a list of local files which get copied to the mozilla:dist:dom directory
+#
+
+nsIDOMWindow.h
+nsIDOMLocation.h
+nsIDOMNSLocation.h
+nsIDOMNavigator.h
+nsIDOMWindowCollection.h
+nsIDOMScreen.h
+nsIDOMHistory.h
+nsIDOMMimeType.h
+nsIDOMMimeTypeArray.h
+nsIDOMPlugin.h
+nsIDOMPluginArray.h
+nsIDOMBarProp.h
+nsIDOMDOMException.h
+nsPIDOMWindow.h
+nsIDOMAbstractView.h

mozilla/dom/public/base/Makefile.in

@@ -0,0 +1,52 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= dom
+
+EXPORTS		= \
+		nsIDOMWindow.h \
+		nsIDOMNavigator.h \
+		nsIDOMLocation.h \
+		nsIDOMNSLocation.h \
+		nsIDOMWindowCollection.h \
+		nsIDOMScreen.h \
+		nsIDOMHistory.h \
+		nsIDOMMimeType.h \
+		nsIDOMMimeTypeArray.h \
+		nsIDOMPlugin.h \
+		nsIDOMPluginArray.h \
+		nsIDOMBarProp.h \
+		nsIDOMDOMException.h \
+		nsPIDOMWindow.h \
+		nsIDOMAbstractView.h \
+		$(NULL)
+
+EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/dom/public/base/makefile.win

@@ -0,0 +1,35 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+
+DEPTH=..\..\..
+
+
+DEFINES=-D_IMPL_NS_DOM 
+EXPORTS=nsIDOMWindow.h nsIDOMNavigator.h nsIDOMLocation.h nsIDOMNSLocation.h \
+	nsIDOMWindowCollection.h nsIDOMScreen.h nsIDOMHistory.h \
+	nsIDOMMimeType.h nsIDOMMimeTypeArray.h \
+	nsIDOMPlugin.h nsIDOMPluginArray.h nsIDOMBarProp.h \
+	nsIDOMDOMException.h nsPIDOMWindow.h nsIDOMAbstractView.h
+
+MODULE=dom 
+
+include <$(DEPTH)\config\rules.mak>
+

mozilla/dom/public/base/nsIDOMAbstractView.h

@@ -19,32 +19,36 @@
  *
  * Contributor(s): 
  */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
 
-#ifndef nsIFontRetrieverService_h__
-#define nsIFontRetrieverService_h__
+#ifndef nsIDOMAbstractView_h__
+#define nsIDOMAbstractView_h__
 
 #include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
 
-class nsIFontNameIterator;
-class nsIFontSizeIterator;
-class nsString;
+class nsIDOMDocument;
 
-// {285EF9B2-094A-11d3-9A87-0050046CDA96}
-#define NS_IFONTRETRIEVERSERVICE_IID \
-{ 0x285ef9b2, 0x94a, 0x11d3, { 0x9a, 0x87, 0x0, 0x50, 0x4, 0x6c, 0xda, 0x96 } };
+#define NS_IDOMABSTRACTVIEW_IID \
+ { 0xf51ebade, 0x8b1a, 0x11d3, \
+  { 0xaa, 0xe7, 0x00, 0x10, 0x83, 0x01, 0x23, 0xb4 } } 
 
-class nsIFontRetrieverService : public nsISupports
-		// This (singleton) service exists soley as a factory to manufacture iterators
-{
-		public:
-      NS_DEFINE_STATIC_IID_ACCESSOR(NS_IFONTRETRIEVERSERVICE_IID)
+class nsIDOMAbstractView : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMABSTRACTVIEW_IID; return iid; }
 
-			NS_IMETHOD CreateFontNameIterator( nsIFontNameIterator** aIterator ) = 0;
-
-			NS_IMETHOD CreateFontSizeIterator( const nsString &aFontName, nsIFontSizeIterator** aIterator ) = 0;
-
-			NS_IMETHOD IsFontScalable( const nsString &aFontName, PRBool* aResult ) = 0;	
+  NS_IMETHOD    GetDocument(nsIDOMDocument** aDocument)=0;
 };
 
 
-#endif
+#define NS_DECL_IDOMABSTRACTVIEW   \
+  NS_IMETHOD    GetDocument(nsIDOMDocument** aDocument);  \
+
+
+
+#define NS_FORWARD_IDOMABSTRACTVIEW(_to)  \
+  NS_IMETHOD    GetDocument(nsIDOMDocument** aDocument) { return _to GetDocument(aDocument); } \
+
+
+#endif // nsIDOMAbstractView_h__

mozilla/dom/public/base/nsIDOMBarProp.h

@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMBarProp_h__
+#define nsIDOMBarProp_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+
+#define NS_IDOMBARPROP_IID \
+ { 0x9eb2c150, 0x1d56, 0x11d3, \
+  { 0x82, 0x21, 0x00, 0x60, 0x08, 0x3a, 0x0b, 0xcf } } 
+
+class nsIDOMBarProp : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMBARPROP_IID; return iid; }
+
+  NS_IMETHOD    GetVisible(PRBool* aVisible)=0;
+  NS_IMETHOD    SetVisible(PRBool aVisible)=0;
+};
+
+
+#define NS_DECL_IDOMBARPROP   \
+  NS_IMETHOD    GetVisible(PRBool* aVisible);  \
+  NS_IMETHOD    SetVisible(PRBool aVisible);  \
+
+
+
+#define NS_FORWARD_IDOMBARPROP(_to)  \
+  NS_IMETHOD    GetVisible(PRBool* aVisible) { return _to GetVisible(aVisible); } \
+  NS_IMETHOD    SetVisible(PRBool aVisible) { return _to SetVisible(aVisible); } \
+
+
+extern "C" NS_DOM nsresult NS_InitBarPropClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptBarProp(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMBarProp_h__

mozilla/dom/public/base/nsIDOMDOMException.h

@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMDOMException_h__
+#define nsIDOMDOMException_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+
+#define NS_IDOMDOMEXCEPTION_IID \
+ { 0xa6cf910a, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMDOMException : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMDOMEXCEPTION_IID; return iid; }
+  enum {
+    INDEX_SIZE_ERR = 1,
+    DOMSTRING_SIZE_ERR = 2,
+    HIERARCHY_REQUEST_ERR = 3,
+    WRONG_DOCUMENT_ERR = 4,
+    INVALID_CHARACTER_ERR = 5,
+    NO_DATA_ALLOWED_ERR = 6,
+    NO_MODIFICATION_ALLOWED_ERR = 7,
+    NOT_FOUND_ERR = 8,
+    NOT_SUPPORTED_ERR = 9,
+    INUSE_ATTRIBUTE_ERR = 10
+  };
+
+  NS_IMETHOD    GetCode(PRUint32* aCode)=0;
+
+  NS_IMETHOD    GetResult(PRUint32* aResult)=0;
+
+  NS_IMETHOD    GetMessage(nsString& aMessage)=0;
+
+  NS_IMETHOD    GetName(nsString& aName)=0;
+
+  NS_IMETHOD    ToString(nsString& aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMDOMEXCEPTION   \
+  NS_IMETHOD    GetCode(PRUint32* aCode);  \
+  NS_IMETHOD    GetResult(PRUint32* aResult);  \
+  NS_IMETHOD    GetMessage(nsString& aMessage);  \
+  NS_IMETHOD    GetName(nsString& aName);  \
+  NS_IMETHOD    ToString(nsString& aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMDOMEXCEPTION(_to)  \
+  NS_IMETHOD    GetCode(PRUint32* aCode) { return _to GetCode(aCode); } \
+  NS_IMETHOD    GetResult(PRUint32* aResult) { return _to GetResult(aResult); } \
+  NS_IMETHOD    GetMessage(nsString& aMessage) { return _to GetMessage(aMessage); } \
+  NS_IMETHOD    GetName(nsString& aName) { return _to GetName(aName); } \
+  NS_IMETHOD    ToString(nsString& aReturn) { return _to ToString(aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitDOMExceptionClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptDOMException(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMDOMException_h__

mozilla/dom/public/base/nsIDOMHistory.h

@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMHistory_h__
+#define nsIDOMHistory_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "jsapi.h"
+
+
+#define NS_IDOMHISTORY_IID \
+ { 0x896d1d20, 0xb4c4, 0x11d2, \
+  { 0xbd, 0x93, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4 } } 
+
+class nsIDOMHistory : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMHISTORY_IID; return iid; }
+
+  NS_IMETHOD    GetLength(PRInt32* aLength)=0;
+
+  NS_IMETHOD    GetCurrent(nsString& aCurrent)=0;
+
+  NS_IMETHOD    GetPrevious(nsString& aPrevious)=0;
+
+  NS_IMETHOD    GetNext(nsString& aNext)=0;
+
+  NS_IMETHOD    Back()=0;
+
+  NS_IMETHOD    Forward()=0;
+
+  NS_IMETHOD    Go(JSContext* cx, jsval* argv, PRUint32 argc)=0;
+};
+
+
+#define NS_DECL_IDOMHISTORY   \
+  NS_IMETHOD    GetLength(PRInt32* aLength);  \
+  NS_IMETHOD    GetCurrent(nsString& aCurrent);  \
+  NS_IMETHOD    GetPrevious(nsString& aPrevious);  \
+  NS_IMETHOD    GetNext(nsString& aNext);  \
+  NS_IMETHOD    Back();  \
+  NS_IMETHOD    Forward();  \
+  NS_IMETHOD    Go(JSContext* cx, jsval* argv, PRUint32 argc);  \
+
+
+
+#define NS_FORWARD_IDOMHISTORY(_to)  \
+  NS_IMETHOD    GetLength(PRInt32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    GetCurrent(nsString& aCurrent) { return _to GetCurrent(aCurrent); } \
+  NS_IMETHOD    GetPrevious(nsString& aPrevious) { return _to GetPrevious(aPrevious); } \
+  NS_IMETHOD    GetNext(nsString& aNext) { return _to GetNext(aNext); } \
+  NS_IMETHOD    Back() { return _to Back(); }  \
+  NS_IMETHOD    Forward() { return _to Forward(); }  \
+  NS_IMETHOD    Go(JSContext* cx, jsval* argv, PRUint32 argc) { return _to Go(cx, argv, argc); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitHistoryClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptHistory(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMHistory_h__

mozilla/dom/public/base/nsIDOMLocation.h

@@ -0,0 +1,121 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMLocation_h__
+#define nsIDOMLocation_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+
+#define NS_IDOMLOCATION_IID \
+ { 0xa6cf906d, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMLocation : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMLOCATION_IID; return iid; }
+
+  NS_IMETHOD    GetHash(nsString& aHash)=0;
+  NS_IMETHOD    SetHash(const nsString& aHash)=0;
+
+  NS_IMETHOD    GetHost(nsString& aHost)=0;
+  NS_IMETHOD    SetHost(const nsString& aHost)=0;
+
+  NS_IMETHOD    GetHostname(nsString& aHostname)=0;
+  NS_IMETHOD    SetHostname(const nsString& aHostname)=0;
+
+  NS_IMETHOD    GetHref(nsString& aHref)=0;
+  NS_IMETHOD    SetHref(const nsString& aHref)=0;
+
+  NS_IMETHOD    GetPathname(nsString& aPathname)=0;
+  NS_IMETHOD    SetPathname(const nsString& aPathname)=0;
+
+  NS_IMETHOD    GetPort(nsString& aPort)=0;
+  NS_IMETHOD    SetPort(const nsString& aPort)=0;
+
+  NS_IMETHOD    GetProtocol(nsString& aProtocol)=0;
+  NS_IMETHOD    SetProtocol(const nsString& aProtocol)=0;
+
+  NS_IMETHOD    GetSearch(nsString& aSearch)=0;
+  NS_IMETHOD    SetSearch(const nsString& aSearch)=0;
+
+  NS_IMETHOD    Reload(PRBool aForceget)=0;
+
+  NS_IMETHOD    Replace(const nsString& aUrl)=0;
+
+  NS_IMETHOD    ToString(nsString& aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMLOCATION   \
+  NS_IMETHOD    GetHash(nsString& aHash);  \
+  NS_IMETHOD    SetHash(const nsString& aHash);  \
+  NS_IMETHOD    GetHost(nsString& aHost);  \
+  NS_IMETHOD    SetHost(const nsString& aHost);  \
+  NS_IMETHOD    GetHostname(nsString& aHostname);  \
+  NS_IMETHOD    SetHostname(const nsString& aHostname);  \
+  NS_IMETHOD    GetHref(nsString& aHref);  \
+  NS_IMETHOD    SetHref(const nsString& aHref);  \
+  NS_IMETHOD    GetPathname(nsString& aPathname);  \
+  NS_IMETHOD    SetPathname(const nsString& aPathname);  \
+  NS_IMETHOD    GetPort(nsString& aPort);  \
+  NS_IMETHOD    SetPort(const nsString& aPort);  \
+  NS_IMETHOD    GetProtocol(nsString& aProtocol);  \
+  NS_IMETHOD    SetProtocol(const nsString& aProtocol);  \
+  NS_IMETHOD    GetSearch(nsString& aSearch);  \
+  NS_IMETHOD    SetSearch(const nsString& aSearch);  \
+  NS_IMETHOD    Reload(PRBool aForceget);  \
+  NS_IMETHOD    Replace(const nsString& aUrl);  \
+  NS_IMETHOD    ToString(nsString& aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMLOCATION(_to)  \
+  NS_IMETHOD    GetHash(nsString& aHash) { return _to GetHash(aHash); } \
+  NS_IMETHOD    SetHash(const nsString& aHash) { return _to SetHash(aHash); } \
+  NS_IMETHOD    GetHost(nsString& aHost) { return _to GetHost(aHost); } \
+  NS_IMETHOD    SetHost(const nsString& aHost) { return _to SetHost(aHost); } \
+  NS_IMETHOD    GetHostname(nsString& aHostname) { return _to GetHostname(aHostname); } \
+  NS_IMETHOD    SetHostname(const nsString& aHostname) { return _to SetHostname(aHostname); } \
+  NS_IMETHOD    GetHref(nsString& aHref) { return _to GetHref(aHref); } \
+  NS_IMETHOD    SetHref(const nsString& aHref) { return _to SetHref(aHref); } \
+  NS_IMETHOD    GetPathname(nsString& aPathname) { return _to GetPathname(aPathname); } \
+  NS_IMETHOD    SetPathname(const nsString& aPathname) { return _to SetPathname(aPathname); } \
+  NS_IMETHOD    GetPort(nsString& aPort) { return _to GetPort(aPort); } \
+  NS_IMETHOD    SetPort(const nsString& aPort) { return _to SetPort(aPort); } \
+  NS_IMETHOD    GetProtocol(nsString& aProtocol) { return _to GetProtocol(aProtocol); } \
+  NS_IMETHOD    SetProtocol(const nsString& aProtocol) { return _to SetProtocol(aProtocol); } \
+  NS_IMETHOD    GetSearch(nsString& aSearch) { return _to GetSearch(aSearch); } \
+  NS_IMETHOD    SetSearch(const nsString& aSearch) { return _to SetSearch(aSearch); } \
+  NS_IMETHOD    Reload(PRBool aForceget) { return _to Reload(aForceget); }  \
+  NS_IMETHOD    Replace(const nsString& aUrl) { return _to Replace(aUrl); }  \
+  NS_IMETHOD    ToString(nsString& aReturn) { return _to ToString(aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitLocationClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptLocation(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMLocation_h__

mozilla/dom/public/base/nsIDOMMimeType.h

@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMMimeType_h__
+#define nsIDOMMimeType_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMPlugin;
+
+#define NS_IDOMMIMETYPE_IID \
+ { 0xf6134682, 0xf28b, 0x11d2, { 0x83, 0x60, 0xc9, 0x08, 0x99, 0x04, 0x9c, 0x3c } } 
+
+class nsIDOMMimeType : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMMIMETYPE_IID; return iid; }
+
+  NS_IMETHOD    GetDescription(nsString& aDescription)=0;
+
+  NS_IMETHOD    GetEnabledPlugin(nsIDOMPlugin** aEnabledPlugin)=0;
+
+  NS_IMETHOD    GetSuffixes(nsString& aSuffixes)=0;
+
+  NS_IMETHOD    GetType(nsString& aType)=0;
+};
+
+
+#define NS_DECL_IDOMMIMETYPE   \
+  NS_IMETHOD    GetDescription(nsString& aDescription);  \
+  NS_IMETHOD    GetEnabledPlugin(nsIDOMPlugin** aEnabledPlugin);  \
+  NS_IMETHOD    GetSuffixes(nsString& aSuffixes);  \
+  NS_IMETHOD    GetType(nsString& aType);  \
+
+
+
+#define NS_FORWARD_IDOMMIMETYPE(_to)  \
+  NS_IMETHOD    GetDescription(nsString& aDescription) { return _to GetDescription(aDescription); } \
+  NS_IMETHOD    GetEnabledPlugin(nsIDOMPlugin** aEnabledPlugin) { return _to GetEnabledPlugin(aEnabledPlugin); } \
+  NS_IMETHOD    GetSuffixes(nsString& aSuffixes) { return _to GetSuffixes(aSuffixes); } \
+  NS_IMETHOD    GetType(nsString& aType) { return _to GetType(aType); } \
+
+
+extern "C" NS_DOM nsresult NS_InitMimeTypeClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptMimeType(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMMimeType_h__

mozilla/dom/public/base/nsIDOMMimeTypeArray.h

@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMMimeTypeArray_h__
+#define nsIDOMMimeTypeArray_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMMimeType;
+
+#define NS_IDOMMIMETYPEARRAY_IID \
+ { 0xf6134683, 0xf28b, 0x11d2, { 0x83, 0x60, 0xc9, 0x08, 0x99, 0x04, 0x9c, 0x3c } } 
+
+class nsIDOMMimeTypeArray : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMMIMETYPEARRAY_IID; return iid; }
+
+  NS_IMETHOD    GetLength(PRUint32* aLength)=0;
+
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMMimeType** aReturn)=0;
+
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMMimeType** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMMIMETYPEARRAY   \
+  NS_IMETHOD    GetLength(PRUint32* aLength);  \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMMimeType** aReturn);  \
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMMimeType** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMMIMETYPEARRAY(_to)  \
+  NS_IMETHOD    GetLength(PRUint32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMMimeType** aReturn) { return _to Item(aIndex, aReturn); }  \
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMMimeType** aReturn) { return _to NamedItem(aName, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitMimeTypeArrayClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptMimeTypeArray(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMMimeTypeArray_h__

mozilla/dom/public/base/nsIDOMNSLocation.h

@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMNSLocation_h__
+#define nsIDOMNSLocation_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "jsapi.h"
+
+
+#define NS_IDOMNSLOCATION_IID \
+ { 0xa6cf9108, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMNSLocation : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMNSLOCATION_IID; return iid; }
+
+  NS_IMETHOD    Reload(JSContext* cx, jsval* argv, PRUint32 argc)=0;
+
+  NS_IMETHOD    Replace(JSContext* cx, jsval* argv, PRUint32 argc)=0;
+};
+
+
+#define NS_DECL_IDOMNSLOCATION   \
+  NS_IMETHOD    Reload(JSContext* cx, jsval* argv, PRUint32 argc);  \
+  NS_IMETHOD    Replace(JSContext* cx, jsval* argv, PRUint32 argc);  \
+
+
+
+#define NS_FORWARD_IDOMNSLOCATION(_to)  \
+  NS_IMETHOD    Reload(JSContext* cx, jsval* argv, PRUint32 argc) { return _to Reload(cx, argv, argc); }  \
+  NS_IMETHOD    Replace(JSContext* cx, jsval* argv, PRUint32 argc) { return _to Replace(cx, argv, argc); }  \
+
+
+#endif // nsIDOMNSLocation_h__

mozilla/dom/public/base/nsIDOMNavigator.h

@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMNavigator_h__
+#define nsIDOMNavigator_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "jsapi.h"
+
+class nsIDOMPluginArray;
+class nsIDOMMimeTypeArray;
+
+#define NS_IDOMNAVIGATOR_IID \
+ { 0xa6cf906e, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMNavigator : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMNAVIGATOR_IID; return iid; }
+
+  NS_IMETHOD    GetAppCodeName(nsString& aAppCodeName)=0;
+
+  NS_IMETHOD    GetAppName(nsString& aAppName)=0;
+
+  NS_IMETHOD    GetAppVersion(nsString& aAppVersion)=0;
+
+  NS_IMETHOD    GetLanguage(nsString& aLanguage)=0;
+
+  NS_IMETHOD    GetMimeTypes(nsIDOMMimeTypeArray** aMimeTypes)=0;
+
+  NS_IMETHOD    GetPlatform(nsString& aPlatform)=0;
+
+  NS_IMETHOD    GetPlugins(nsIDOMPluginArray** aPlugins)=0;
+
+  NS_IMETHOD    GetSecurityPolicy(nsString& aSecurityPolicy)=0;
+
+  NS_IMETHOD    GetUserAgent(nsString& aUserAgent)=0;
+
+  NS_IMETHOD    JavaEnabled(PRBool* aReturn)=0;
+
+  NS_IMETHOD    TaintEnabled(PRBool* aReturn)=0;
+
+  NS_IMETHOD    Preference(JSContext* cx, jsval* argv, PRUint32 argc, jsval* aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMNAVIGATOR   \
+  NS_IMETHOD    GetAppCodeName(nsString& aAppCodeName);  \
+  NS_IMETHOD    GetAppName(nsString& aAppName);  \
+  NS_IMETHOD    GetAppVersion(nsString& aAppVersion);  \
+  NS_IMETHOD    GetLanguage(nsString& aLanguage);  \
+  NS_IMETHOD    GetMimeTypes(nsIDOMMimeTypeArray** aMimeTypes);  \
+  NS_IMETHOD    GetPlatform(nsString& aPlatform);  \
+  NS_IMETHOD    GetPlugins(nsIDOMPluginArray** aPlugins);  \
+  NS_IMETHOD    GetSecurityPolicy(nsString& aSecurityPolicy);  \
+  NS_IMETHOD    GetUserAgent(nsString& aUserAgent);  \
+  NS_IMETHOD    JavaEnabled(PRBool* aReturn);  \
+  NS_IMETHOD    TaintEnabled(PRBool* aReturn);  \
+  NS_IMETHOD    Preference(JSContext* cx, jsval* argv, PRUint32 argc, jsval* aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMNAVIGATOR(_to)  \
+  NS_IMETHOD    GetAppCodeName(nsString& aAppCodeName) { return _to GetAppCodeName(aAppCodeName); } \
+  NS_IMETHOD    GetAppName(nsString& aAppName) { return _to GetAppName(aAppName); } \
+  NS_IMETHOD    GetAppVersion(nsString& aAppVersion) { return _to GetAppVersion(aAppVersion); } \
+  NS_IMETHOD    GetLanguage(nsString& aLanguage) { return _to GetLanguage(aLanguage); } \
+  NS_IMETHOD    GetMimeTypes(nsIDOMMimeTypeArray** aMimeTypes) { return _to GetMimeTypes(aMimeTypes); } \
+  NS_IMETHOD    GetPlatform(nsString& aPlatform) { return _to GetPlatform(aPlatform); } \
+  NS_IMETHOD    GetPlugins(nsIDOMPluginArray** aPlugins) { return _to GetPlugins(aPlugins); } \
+  NS_IMETHOD    GetSecurityPolicy(nsString& aSecurityPolicy) { return _to GetSecurityPolicy(aSecurityPolicy); } \
+  NS_IMETHOD    GetUserAgent(nsString& aUserAgent) { return _to GetUserAgent(aUserAgent); } \
+  NS_IMETHOD    JavaEnabled(PRBool* aReturn) { return _to JavaEnabled(aReturn); }  \
+  NS_IMETHOD    TaintEnabled(PRBool* aReturn) { return _to TaintEnabled(aReturn); }  \
+  NS_IMETHOD    Preference(JSContext* cx, jsval* argv, PRUint32 argc, jsval* aReturn) { return _to Preference(cx, argv, argc, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitNavigatorClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptNavigator(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMNavigator_h__

mozilla/dom/public/base/nsIDOMPlugin.h

@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMPlugin_h__
+#define nsIDOMPlugin_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMMimeType;
+
+#define NS_IDOMPLUGIN_IID \
+ { 0xf6134681, 0xf28b, 0x11d2, { 0x83, 0x60, 0xc9, 0x08, 0x99, 0x04, 0x9c, 0x3c } } 
+
+class nsIDOMPlugin : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMPLUGIN_IID; return iid; }
+
+  NS_IMETHOD    GetDescription(nsString& aDescription)=0;
+
+  NS_IMETHOD    GetFilename(nsString& aFilename)=0;
+
+  NS_IMETHOD    GetName(nsString& aName)=0;
+
+  NS_IMETHOD    GetLength(PRUint32* aLength)=0;
+
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMMimeType** aReturn)=0;
+
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMMimeType** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMPLUGIN   \
+  NS_IMETHOD    GetDescription(nsString& aDescription);  \
+  NS_IMETHOD    GetFilename(nsString& aFilename);  \
+  NS_IMETHOD    GetName(nsString& aName);  \
+  NS_IMETHOD    GetLength(PRUint32* aLength);  \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMMimeType** aReturn);  \
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMMimeType** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMPLUGIN(_to)  \
+  NS_IMETHOD    GetDescription(nsString& aDescription) { return _to GetDescription(aDescription); } \
+  NS_IMETHOD    GetFilename(nsString& aFilename) { return _to GetFilename(aFilename); } \
+  NS_IMETHOD    GetName(nsString& aName) { return _to GetName(aName); } \
+  NS_IMETHOD    GetLength(PRUint32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMMimeType** aReturn) { return _to Item(aIndex, aReturn); }  \
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMMimeType** aReturn) { return _to NamedItem(aName, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitPluginClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptPlugin(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMPlugin_h__

mozilla/dom/public/base/nsIDOMPluginArray.h

@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMPluginArray_h__
+#define nsIDOMPluginArray_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMPlugin;
+
+#define NS_IDOMPLUGINARRAY_IID \
+ { 0xf6134680, 0xf28b, 0x11d2, { 0x83, 0x60, 0xc9, 0x08, 0x99, 0x04, 0x9c, 0x3c } } 
+
+class nsIDOMPluginArray : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMPLUGINARRAY_IID; return iid; }
+
+  NS_IMETHOD    GetLength(PRUint32* aLength)=0;
+
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMPlugin** aReturn)=0;
+
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMPlugin** aReturn)=0;
+
+  NS_IMETHOD    Refresh(PRBool aReloadDocuments)=0;
+};
+
+
+#define NS_DECL_IDOMPLUGINARRAY   \
+  NS_IMETHOD    GetLength(PRUint32* aLength);  \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMPlugin** aReturn);  \
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMPlugin** aReturn);  \
+  NS_IMETHOD    Refresh(PRBool aReloadDocuments);  \
+
+
+
+#define NS_FORWARD_IDOMPLUGINARRAY(_to)  \
+  NS_IMETHOD    GetLength(PRUint32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMPlugin** aReturn) { return _to Item(aIndex, aReturn); }  \
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMPlugin** aReturn) { return _to NamedItem(aName, aReturn); }  \
+  NS_IMETHOD    Refresh(PRBool aReloadDocuments) { return _to Refresh(aReloadDocuments); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitPluginArrayClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptPluginArray(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMPluginArray_h__

mozilla/dom/public/base/nsIDOMScreen.h

@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMScreen_h__
+#define nsIDOMScreen_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+
+#define NS_IDOMSCREEN_IID \
+ { 0x77947960, 0xb4af, 0x11d2, \
+  { 0xbd, 0x93, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4 } } 
+
+class nsIDOMScreen : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMSCREEN_IID; return iid; }
+
+  NS_IMETHOD    GetWidth(PRInt32* aWidth)=0;
+
+  NS_IMETHOD    GetHeight(PRInt32* aHeight)=0;
+
+  NS_IMETHOD    GetPixelDepth(PRInt32* aPixelDepth)=0;
+
+  NS_IMETHOD    GetColorDepth(PRInt32* aColorDepth)=0;
+
+  NS_IMETHOD    GetAvailWidth(PRInt32* aAvailWidth)=0;
+
+  NS_IMETHOD    GetAvailHeight(PRInt32* aAvailHeight)=0;
+
+  NS_IMETHOD    GetAvailLeft(PRInt32* aAvailLeft)=0;
+
+  NS_IMETHOD    GetAvailTop(PRInt32* aAvailTop)=0;
+};
+
+
+#define NS_DECL_IDOMSCREEN   \
+  NS_IMETHOD    GetWidth(PRInt32* aWidth);  \
+  NS_IMETHOD    GetHeight(PRInt32* aHeight);  \
+  NS_IMETHOD    GetPixelDepth(PRInt32* aPixelDepth);  \
+  NS_IMETHOD    GetColorDepth(PRInt32* aColorDepth);  \
+  NS_IMETHOD    GetAvailWidth(PRInt32* aAvailWidth);  \
+  NS_IMETHOD    GetAvailHeight(PRInt32* aAvailHeight);  \
+  NS_IMETHOD    GetAvailLeft(PRInt32* aAvailLeft);  \
+  NS_IMETHOD    GetAvailTop(PRInt32* aAvailTop);  \
+
+
+
+#define NS_FORWARD_IDOMSCREEN(_to)  \
+  NS_IMETHOD    GetWidth(PRInt32* aWidth) { return _to GetWidth(aWidth); } \
+  NS_IMETHOD    GetHeight(PRInt32* aHeight) { return _to GetHeight(aHeight); } \
+  NS_IMETHOD    GetPixelDepth(PRInt32* aPixelDepth) { return _to GetPixelDepth(aPixelDepth); } \
+  NS_IMETHOD    GetColorDepth(PRInt32* aColorDepth) { return _to GetColorDepth(aColorDepth); } \
+  NS_IMETHOD    GetAvailWidth(PRInt32* aAvailWidth) { return _to GetAvailWidth(aAvailWidth); } \
+  NS_IMETHOD    GetAvailHeight(PRInt32* aAvailHeight) { return _to GetAvailHeight(aAvailHeight); } \
+  NS_IMETHOD    GetAvailLeft(PRInt32* aAvailLeft) { return _to GetAvailLeft(aAvailLeft); } \
+  NS_IMETHOD    GetAvailTop(PRInt32* aAvailTop) { return _to GetAvailTop(aAvailTop); } \
+
+
+extern "C" NS_DOM nsresult NS_InitScreenClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptScreen(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMScreen_h__

mozilla/dom/public/base/nsIDOMWindow.h

@@ -0,0 +1,360 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMWindow_h__
+#define nsIDOMWindow_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "jsapi.h"
+
+class nsIDOMNavigator;
+class nsIDOMElement;
+class nsIDOMDocument;
+class nsIDOMBarProp;
+class nsIDOMScreen;
+class nsIDOMHistory;
+class nsIDOMWindowCollection;
+class nsIDOMEvent;
+class nsIDOMWindow;
+class nsIControllers;
+
+#define NS_IDOMWINDOW_IID \
+ { 0xa6cf906b, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMWindow : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMWINDOW_IID; return iid; }
+
+  NS_IMETHOD    GetWindow(nsIDOMWindow** aWindow)=0;
+
+  NS_IMETHOD    GetSelf(nsIDOMWindow** aSelf)=0;
+
+  NS_IMETHOD    GetDocument(nsIDOMDocument** aDocument)=0;
+
+  NS_IMETHOD    GetNavigator(nsIDOMNavigator** aNavigator)=0;
+
+  NS_IMETHOD    GetScreen(nsIDOMScreen** aScreen)=0;
+
+  NS_IMETHOD    GetHistory(nsIDOMHistory** aHistory)=0;
+
+  NS_IMETHOD    GetParent(nsIDOMWindow** aParent)=0;
+
+  NS_IMETHOD    GetTop(nsIDOMWindow** aTop)=0;
+
+  NS_IMETHOD    GetContent(nsIDOMWindow** aContent)=0;
+
+  NS_IMETHOD    GetMenubar(nsIDOMBarProp** aMenubar)=0;
+
+  NS_IMETHOD    GetToolbar(nsIDOMBarProp** aToolbar)=0;
+
+  NS_IMETHOD    GetLocationbar(nsIDOMBarProp** aLocationbar)=0;
+
+  NS_IMETHOD    GetPersonalbar(nsIDOMBarProp** aPersonalbar)=0;
+
+  NS_IMETHOD    GetStatusbar(nsIDOMBarProp** aStatusbar)=0;
+
+  NS_IMETHOD    GetScrollbars(nsIDOMBarProp** aScrollbars)=0;
+
+  NS_IMETHOD    GetDirectories(nsIDOMBarProp** aDirectories)=0;
+
+  NS_IMETHOD    GetClosed(PRBool* aClosed)=0;
+
+  NS_IMETHOD    GetFrames(nsIDOMWindowCollection** aFrames)=0;
+
+  NS_IMETHOD    GetControllers(nsIControllers** aControllers)=0;
+
+  NS_IMETHOD    GetOpener(nsIDOMWindow** aOpener)=0;
+  NS_IMETHOD    SetOpener(nsIDOMWindow* aOpener)=0;
+
+  NS_IMETHOD    GetStatus(nsString& aStatus)=0;
+  NS_IMETHOD    SetStatus(const nsString& aStatus)=0;
+
+  NS_IMETHOD    GetDefaultStatus(nsString& aDefaultStatus)=0;
+  NS_IMETHOD    SetDefaultStatus(const nsString& aDefaultStatus)=0;
+
+  NS_IMETHOD    GetName(nsString& aName)=0;
+  NS_IMETHOD    SetName(const nsString& aName)=0;
+
+  NS_IMETHOD    GetInnerWidth(PRInt32* aInnerWidth)=0;
+  NS_IMETHOD    SetInnerWidth(PRInt32 aInnerWidth)=0;
+
+  NS_IMETHOD    GetInnerHeight(PRInt32* aInnerHeight)=0;
+  NS_IMETHOD    SetInnerHeight(PRInt32 aInnerHeight)=0;
+
+  NS_IMETHOD    GetOuterWidth(PRInt32* aOuterWidth)=0;
+  NS_IMETHOD    SetOuterWidth(PRInt32 aOuterWidth)=0;
+
+  NS_IMETHOD    GetOuterHeight(PRInt32* aOuterHeight)=0;
+  NS_IMETHOD    SetOuterHeight(PRInt32 aOuterHeight)=0;
+
+  NS_IMETHOD    GetScreenX(PRInt32* aScreenX)=0;
+  NS_IMETHOD    SetScreenX(PRInt32 aScreenX)=0;
+
+  NS_IMETHOD    GetScreenY(PRInt32* aScreenY)=0;
+  NS_IMETHOD    SetScreenY(PRInt32 aScreenY)=0;
+
+  NS_IMETHOD    GetPageXOffset(PRInt32* aPageXOffset)=0;
+  NS_IMETHOD    SetPageXOffset(PRInt32 aPageXOffset)=0;
+
+  NS_IMETHOD    GetPageYOffset(PRInt32* aPageYOffset)=0;
+  NS_IMETHOD    SetPageYOffset(PRInt32 aPageYOffset)=0;
+
+  NS_IMETHOD    GetScrollX(PRInt32* aScrollX)=0;
+
+  NS_IMETHOD    GetScrollY(PRInt32* aScrollY)=0;
+
+  NS_IMETHOD    Dump(const nsString& aStr)=0;
+
+  NS_IMETHOD    Alert(JSContext* cx, jsval* argv, PRUint32 argc)=0;
+
+  NS_IMETHOD    Confirm(JSContext* cx, jsval* argv, PRUint32 argc, PRBool* aReturn)=0;
+
+  NS_IMETHOD    Prompt(JSContext* cx, jsval* argv, PRUint32 argc, nsString& aReturn)=0;
+
+  NS_IMETHOD    Focus()=0;
+
+  NS_IMETHOD    Blur()=0;
+
+  NS_IMETHOD    Back()=0;
+
+  NS_IMETHOD    Forward()=0;
+
+  NS_IMETHOD    Home()=0;
+
+  NS_IMETHOD    Stop()=0;
+
+  NS_IMETHOD    Print()=0;
+
+  NS_IMETHOD    MoveTo(PRInt32 aXPos, PRInt32 aYPos)=0;
+
+  NS_IMETHOD    MoveBy(PRInt32 aXDif, PRInt32 aYDif)=0;
+
+  NS_IMETHOD    ResizeTo(PRInt32 aWidth, PRInt32 aHeight)=0;
+
+  NS_IMETHOD    ResizeBy(PRInt32 aWidthDif, PRInt32 aHeightDif)=0;
+
+  NS_IMETHOD    SizeToContent()=0;
+
+  NS_IMETHOD    ScrollTo(PRInt32 aXScroll, PRInt32 aYScroll)=0;
+
+  NS_IMETHOD    ScrollBy(PRInt32 aXScrollDif, PRInt32 aYScrollDif)=0;
+
+  NS_IMETHOD    ClearTimeout(PRInt32 aTimerID)=0;
+
+  NS_IMETHOD    ClearInterval(PRInt32 aTimerID)=0;
+
+  NS_IMETHOD    SetTimeout(JSContext* cx, jsval* argv, PRUint32 argc, PRInt32* aReturn)=0;
+
+  NS_IMETHOD    SetInterval(JSContext* cx, jsval* argv, PRUint32 argc, PRInt32* aReturn)=0;
+
+  NS_IMETHOD    CaptureEvents(PRInt32 aEventFlags)=0;
+
+  NS_IMETHOD    ReleaseEvents(PRInt32 aEventFlags)=0;
+
+  NS_IMETHOD    RouteEvent(nsIDOMEvent* aEvt)=0;
+
+  NS_IMETHOD    EnableExternalCapture()=0;
+
+  NS_IMETHOD    DisableExternalCapture()=0;
+
+  NS_IMETHOD    CreatePopup(nsIDOMElement* aElement, nsIDOMElement* aPopupContent, PRInt32 aXPos, PRInt32 aYPos, const nsString& aPopupType, const nsString& aAnchorAlignment, const nsString& aPopupAlignment, nsIDOMWindow** aReturn)=0;
+
+  NS_IMETHOD    Open(JSContext* cx, jsval* argv, PRUint32 argc, nsIDOMWindow** aReturn)=0;
+
+  NS_IMETHOD    OpenDialog(JSContext* cx, jsval* argv, PRUint32 argc, nsIDOMWindow** aReturn)=0;
+
+  NS_IMETHOD    Close()=0;
+
+  NS_IMETHOD    Close(JSContext* cx, jsval* argv, PRUint32 argc)=0;
+};
+
+
+#define NS_DECL_IDOMWINDOW   \
+  NS_IMETHOD    GetWindow(nsIDOMWindow** aWindow);  \
+  NS_IMETHOD    GetSelf(nsIDOMWindow** aSelf);  \
+  NS_IMETHOD    GetDocument(nsIDOMDocument** aDocument);  \
+  NS_IMETHOD    GetNavigator(nsIDOMNavigator** aNavigator);  \
+  NS_IMETHOD    GetScreen(nsIDOMScreen** aScreen);  \
+  NS_IMETHOD    GetHistory(nsIDOMHistory** aHistory);  \
+  NS_IMETHOD    GetParent(nsIDOMWindow** aParent);  \
+  NS_IMETHOD    GetTop(nsIDOMWindow** aTop);  \
+  NS_IMETHOD    GetContent(nsIDOMWindow** aContent);  \
+  NS_IMETHOD    GetMenubar(nsIDOMBarProp** aMenubar);  \
+  NS_IMETHOD    GetToolbar(nsIDOMBarProp** aToolbar);  \
+  NS_IMETHOD    GetLocationbar(nsIDOMBarProp** aLocationbar);  \
+  NS_IMETHOD    GetPersonalbar(nsIDOMBarProp** aPersonalbar);  \
+  NS_IMETHOD    GetStatusbar(nsIDOMBarProp** aStatusbar);  \
+  NS_IMETHOD    GetScrollbars(nsIDOMBarProp** aScrollbars);  \
+  NS_IMETHOD    GetDirectories(nsIDOMBarProp** aDirectories);  \
+  NS_IMETHOD    GetClosed(PRBool* aClosed);  \
+  NS_IMETHOD    GetFrames(nsIDOMWindowCollection** aFrames);  \
+  NS_IMETHOD    GetControllers(nsIControllers** aControllers);  \
+  NS_IMETHOD    GetOpener(nsIDOMWindow** aOpener);  \
+  NS_IMETHOD    SetOpener(nsIDOMWindow* aOpener);  \
+  NS_IMETHOD    GetStatus(nsString& aStatus);  \
+  NS_IMETHOD    SetStatus(const nsString& aStatus);  \
+  NS_IMETHOD    GetDefaultStatus(nsString& aDefaultStatus);  \
+  NS_IMETHOD    SetDefaultStatus(const nsString& aDefaultStatus);  \
+  NS_IMETHOD    GetName(nsString& aName);  \
+  NS_IMETHOD    SetName(const nsString& aName);  \
+  NS_IMETHOD    GetInnerWidth(PRInt32* aInnerWidth);  \
+  NS_IMETHOD    SetInnerWidth(PRInt32 aInnerWidth);  \
+  NS_IMETHOD    GetInnerHeight(PRInt32* aInnerHeight);  \
+  NS_IMETHOD    SetInnerHeight(PRInt32 aInnerHeight);  \
+  NS_IMETHOD    GetOuterWidth(PRInt32* aOuterWidth);  \
+  NS_IMETHOD    SetOuterWidth(PRInt32 aOuterWidth);  \
+  NS_IMETHOD    GetOuterHeight(PRInt32* aOuterHeight);  \
+  NS_IMETHOD    SetOuterHeight(PRInt32 aOuterHeight);  \
+  NS_IMETHOD    GetScreenX(PRInt32* aScreenX);  \
+  NS_IMETHOD    SetScreenX(PRInt32 aScreenX);  \
+  NS_IMETHOD    GetScreenY(PRInt32* aScreenY);  \
+  NS_IMETHOD    SetScreenY(PRInt32 aScreenY);  \
+  NS_IMETHOD    GetPageXOffset(PRInt32* aPageXOffset);  \
+  NS_IMETHOD    SetPageXOffset(PRInt32 aPageXOffset);  \
+  NS_IMETHOD    GetPageYOffset(PRInt32* aPageYOffset);  \
+  NS_IMETHOD    SetPageYOffset(PRInt32 aPageYOffset);  \
+  NS_IMETHOD    GetScrollX(PRInt32* aScrollX);  \
+  NS_IMETHOD    GetScrollY(PRInt32* aScrollY);  \
+  NS_IMETHOD    Dump(const nsString& aStr);  \
+  NS_IMETHOD    Alert(JSContext* cx, jsval* argv, PRUint32 argc);  \
+  NS_IMETHOD    Confirm(JSContext* cx, jsval* argv, PRUint32 argc, PRBool* aReturn);  \
+  NS_IMETHOD    Prompt(JSContext* cx, jsval* argv, PRUint32 argc, nsString& aReturn);  \
+  NS_IMETHOD    Focus();  \
+  NS_IMETHOD    Blur();  \
+  NS_IMETHOD    Back();  \
+  NS_IMETHOD    Forward();  \
+  NS_IMETHOD    Home();  \
+  NS_IMETHOD    Stop();  \
+  NS_IMETHOD    Print();  \
+  NS_IMETHOD    MoveTo(PRInt32 aXPos, PRInt32 aYPos);  \
+  NS_IMETHOD    MoveBy(PRInt32 aXDif, PRInt32 aYDif);  \
+  NS_IMETHOD    ResizeTo(PRInt32 aWidth, PRInt32 aHeight);  \
+  NS_IMETHOD    ResizeBy(PRInt32 aWidthDif, PRInt32 aHeightDif);  \
+  NS_IMETHOD    SizeToContent();  \
+  NS_IMETHOD    ScrollTo(PRInt32 aXScroll, PRInt32 aYScroll);  \
+  NS_IMETHOD    ScrollBy(PRInt32 aXScrollDif, PRInt32 aYScrollDif);  \
+  NS_IMETHOD    ClearTimeout(PRInt32 aTimerID);  \
+  NS_IMETHOD    ClearInterval(PRInt32 aTimerID);  \
+  NS_IMETHOD    SetTimeout(JSContext* cx, jsval* argv, PRUint32 argc, PRInt32* aReturn);  \
+  NS_IMETHOD    SetInterval(JSContext* cx, jsval* argv, PRUint32 argc, PRInt32* aReturn);  \
+  NS_IMETHOD    CaptureEvents(PRInt32 aEventFlags);  \
+  NS_IMETHOD    ReleaseEvents(PRInt32 aEventFlags);  \
+  NS_IMETHOD    RouteEvent(nsIDOMEvent* aEvt);  \
+  NS_IMETHOD    EnableExternalCapture();  \
+  NS_IMETHOD    DisableExternalCapture();  \
+  NS_IMETHOD    CreatePopup(nsIDOMElement* aElement, nsIDOMElement* aPopupContent, PRInt32 aXPos, PRInt32 aYPos, const nsString& aPopupType, const nsString& aAnchorAlignment, const nsString& aPopupAlignment, nsIDOMWindow** aReturn);  \
+  NS_IMETHOD    Open(JSContext* cx, jsval* argv, PRUint32 argc, nsIDOMWindow** aReturn);  \
+  NS_IMETHOD    OpenDialog(JSContext* cx, jsval* argv, PRUint32 argc, nsIDOMWindow** aReturn);  \
+  NS_IMETHOD    Close();  \
+  NS_IMETHOD    Close(JSContext* cx, jsval* argv, PRUint32 argc);  \
+
+
+
+#define NS_FORWARD_IDOMWINDOW(_to)  \
+  NS_IMETHOD    GetWindow(nsIDOMWindow** aWindow) { return _to GetWindow(aWindow); } \
+  NS_IMETHOD    GetSelf(nsIDOMWindow** aSelf) { return _to GetSelf(aSelf); } \
+  NS_IMETHOD    GetDocument(nsIDOMDocument** aDocument) { return _to GetDocument(aDocument); } \
+  NS_IMETHOD    GetNavigator(nsIDOMNavigator** aNavigator) { return _to GetNavigator(aNavigator); } \
+  NS_IMETHOD    GetScreen(nsIDOMScreen** aScreen) { return _to GetScreen(aScreen); } \
+  NS_IMETHOD    GetHistory(nsIDOMHistory** aHistory) { return _to GetHistory(aHistory); } \
+  NS_IMETHOD    GetParent(nsIDOMWindow** aParent) { return _to GetParent(aParent); } \
+  NS_IMETHOD    GetTop(nsIDOMWindow** aTop) { return _to GetTop(aTop); } \
+  NS_IMETHOD    GetContent(nsIDOMWindow** aContent) { return _to GetContent(aContent); } \
+  NS_IMETHOD    GetMenubar(nsIDOMBarProp** aMenubar) { return _to GetMenubar(aMenubar); } \
+  NS_IMETHOD    GetToolbar(nsIDOMBarProp** aToolbar) { return _to GetToolbar(aToolbar); } \
+  NS_IMETHOD    GetLocationbar(nsIDOMBarProp** aLocationbar) { return _to GetLocationbar(aLocationbar); } \
+  NS_IMETHOD    GetPersonalbar(nsIDOMBarProp** aPersonalbar) { return _to GetPersonalbar(aPersonalbar); } \
+  NS_IMETHOD    GetStatusbar(nsIDOMBarProp** aStatusbar) { return _to GetStatusbar(aStatusbar); } \
+  NS_IMETHOD    GetScrollbars(nsIDOMBarProp** aScrollbars) { return _to GetScrollbars(aScrollbars); } \
+  NS_IMETHOD    GetDirectories(nsIDOMBarProp** aDirectories) { return _to GetDirectories(aDirectories); } \
+  NS_IMETHOD    GetClosed(PRBool* aClosed) { return _to GetClosed(aClosed); } \
+  NS_IMETHOD    GetFrames(nsIDOMWindowCollection** aFrames) { return _to GetFrames(aFrames); } \
+  NS_IMETHOD    GetControllers(nsIControllers** aControllers) { return _to GetControllers(aControllers); } \
+  NS_IMETHOD    GetOpener(nsIDOMWindow** aOpener) { return _to GetOpener(aOpener); } \
+  NS_IMETHOD    SetOpener(nsIDOMWindow* aOpener) { return _to SetOpener(aOpener); } \
+  NS_IMETHOD    GetStatus(nsString& aStatus) { return _to GetStatus(aStatus); } \
+  NS_IMETHOD    SetStatus(const nsString& aStatus) { return _to SetStatus(aStatus); } \
+  NS_IMETHOD    GetDefaultStatus(nsString& aDefaultStatus) { return _to GetDefaultStatus(aDefaultStatus); } \
+  NS_IMETHOD    SetDefaultStatus(const nsString& aDefaultStatus) { return _to SetDefaultStatus(aDefaultStatus); } \
+  NS_IMETHOD    GetName(nsString& aName) { return _to GetName(aName); } \
+  NS_IMETHOD    SetName(const nsString& aName) { return _to SetName(aName); } \
+  NS_IMETHOD    GetInnerWidth(PRInt32* aInnerWidth) { return _to GetInnerWidth(aInnerWidth); } \
+  NS_IMETHOD    SetInnerWidth(PRInt32 aInnerWidth) { return _to SetInnerWidth(aInnerWidth); } \
+  NS_IMETHOD    GetInnerHeight(PRInt32* aInnerHeight) { return _to GetInnerHeight(aInnerHeight); } \
+  NS_IMETHOD    SetInnerHeight(PRInt32 aInnerHeight) { return _to SetInnerHeight(aInnerHeight); } \
+  NS_IMETHOD    GetOuterWidth(PRInt32* aOuterWidth) { return _to GetOuterWidth(aOuterWidth); } \
+  NS_IMETHOD    SetOuterWidth(PRInt32 aOuterWidth) { return _to SetOuterWidth(aOuterWidth); } \
+  NS_IMETHOD    GetOuterHeight(PRInt32* aOuterHeight) { return _to GetOuterHeight(aOuterHeight); } \
+  NS_IMETHOD    SetOuterHeight(PRInt32 aOuterHeight) { return _to SetOuterHeight(aOuterHeight); } \
+  NS_IMETHOD    GetScreenX(PRInt32* aScreenX) { return _to GetScreenX(aScreenX); } \
+  NS_IMETHOD    SetScreenX(PRInt32 aScreenX) { return _to SetScreenX(aScreenX); } \
+  NS_IMETHOD    GetScreenY(PRInt32* aScreenY) { return _to GetScreenY(aScreenY); } \
+  NS_IMETHOD    SetScreenY(PRInt32 aScreenY) { return _to SetScreenY(aScreenY); } \
+  NS_IMETHOD    GetPageXOffset(PRInt32* aPageXOffset) { return _to GetPageXOffset(aPageXOffset); } \
+  NS_IMETHOD    SetPageXOffset(PRInt32 aPageXOffset) { return _to SetPageXOffset(aPageXOffset); } \
+  NS_IMETHOD    GetPageYOffset(PRInt32* aPageYOffset) { return _to GetPageYOffset(aPageYOffset); } \
+  NS_IMETHOD    SetPageYOffset(PRInt32 aPageYOffset) { return _to SetPageYOffset(aPageYOffset); } \
+  NS_IMETHOD    GetScrollX(PRInt32* aScrollX) { return _to GetScrollX(aScrollX); } \
+  NS_IMETHOD    GetScrollY(PRInt32* aScrollY) { return _to GetScrollY(aScrollY); } \
+  NS_IMETHOD    Dump(const nsString& aStr) { return _to Dump(aStr); }  \
+  NS_IMETHOD    Alert(JSContext* cx, jsval* argv, PRUint32 argc) { return _to Alert(cx, argv, argc); }  \
+  NS_IMETHOD    Confirm(JSContext* cx, jsval* argv, PRUint32 argc, PRBool* aReturn) { return _to Confirm(cx, argv, argc, aReturn); }  \
+  NS_IMETHOD    Prompt(JSContext* cx, jsval* argv, PRUint32 argc, nsString& aReturn) { return _to Prompt(cx, argv, argc, aReturn); }  \
+  NS_IMETHOD    Focus() { return _to Focus(); }  \
+  NS_IMETHOD    Blur() { return _to Blur(); }  \
+  NS_IMETHOD    Back() { return _to Back(); }  \
+  NS_IMETHOD    Forward() { return _to Forward(); }  \
+  NS_IMETHOD    Home() { return _to Home(); }  \
+  NS_IMETHOD    Stop() { return _to Stop(); }  \
+  NS_IMETHOD    Print() { return _to Print(); }  \
+  NS_IMETHOD    MoveTo(PRInt32 aXPos, PRInt32 aYPos) { return _to MoveTo(aXPos, aYPos); }  \
+  NS_IMETHOD    MoveBy(PRInt32 aXDif, PRInt32 aYDif) { return _to MoveBy(aXDif, aYDif); }  \
+  NS_IMETHOD    ResizeTo(PRInt32 aWidth, PRInt32 aHeight) { return _to ResizeTo(aWidth, aHeight); }  \
+  NS_IMETHOD    ResizeBy(PRInt32 aWidthDif, PRInt32 aHeightDif) { return _to ResizeBy(aWidthDif, aHeightDif); }  \
+  NS_IMETHOD    SizeToContent() { return _to SizeToContent(); }  \
+  NS_IMETHOD    ScrollTo(PRInt32 aXScroll, PRInt32 aYScroll) { return _to ScrollTo(aXScroll, aYScroll); }  \
+  NS_IMETHOD    ScrollBy(PRInt32 aXScrollDif, PRInt32 aYScrollDif) { return _to ScrollBy(aXScrollDif, aYScrollDif); }  \
+  NS_IMETHOD    ClearTimeout(PRInt32 aTimerID) { return _to ClearTimeout(aTimerID); }  \
+  NS_IMETHOD    ClearInterval(PRInt32 aTimerID) { return _to ClearInterval(aTimerID); }  \
+  NS_IMETHOD    SetTimeout(JSContext* cx, jsval* argv, PRUint32 argc, PRInt32* aReturn) { return _to SetTimeout(cx, argv, argc, aReturn); }  \
+  NS_IMETHOD    SetInterval(JSContext* cx, jsval* argv, PRUint32 argc, PRInt32* aReturn) { return _to SetInterval(cx, argv, argc, aReturn); }  \
+  NS_IMETHOD    CaptureEvents(PRInt32 aEventFlags) { return _to CaptureEvents(aEventFlags); }  \
+  NS_IMETHOD    ReleaseEvents(PRInt32 aEventFlags) { return _to ReleaseEvents(aEventFlags); }  \
+  NS_IMETHOD    RouteEvent(nsIDOMEvent* aEvt) { return _to RouteEvent(aEvt); }  \
+  NS_IMETHOD    EnableExternalCapture() { return _to EnableExternalCapture(); }  \
+  NS_IMETHOD    DisableExternalCapture() { return _to DisableExternalCapture(); }  \
+  NS_IMETHOD    CreatePopup(nsIDOMElement* aElement, nsIDOMElement* aPopupContent, PRInt32 aXPos, PRInt32 aYPos, const nsString& aPopupType, const nsString& aAnchorAlignment, const nsString& aPopupAlignment, nsIDOMWindow** aReturn) { return _to CreatePopup(aElement, aPopupContent, aXPos, aYPos, aPopupType, aAnchorAlignment, aPopupAlignment, aReturn); }  \
+  NS_IMETHOD    Open(JSContext* cx, jsval* argv, PRUint32 argc, nsIDOMWindow** aReturn) { return _to Open(cx, argv, argc, aReturn); }  \
+  NS_IMETHOD    OpenDialog(JSContext* cx, jsval* argv, PRUint32 argc, nsIDOMWindow** aReturn) { return _to OpenDialog(cx, argv, argc, aReturn); }  \
+  NS_IMETHOD    Close() { return _to Close(); }  \
+  NS_IMETHOD    Close(JSContext* cx, jsval* argv, PRUint32 argc) { return _to Close(cx, argv, argc); }  \
+
+
+extern nsresult NS_InitWindowClass(nsIScriptContext *aContext, nsIScriptGlobalObject *aGlobal);
+
+extern "C" NS_DOM nsresult NS_NewScriptWindow(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMWindow_h__

mozilla/dom/public/base/nsIDOMWindowCollection.h

@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMWindowCollection_h__
+#define nsIDOMWindowCollection_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMWindow;
+
+#define NS_IDOMWINDOWCOLLECTION_IID \
+ { 0xa6cf906f, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMWindowCollection : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMWINDOWCOLLECTION_IID; return iid; }
+
+  NS_IMETHOD    GetLength(PRUint32* aLength)=0;
+
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMWindow** aReturn)=0;
+
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMWindow** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMWINDOWCOLLECTION   \
+  NS_IMETHOD    GetLength(PRUint32* aLength);  \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMWindow** aReturn);  \
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMWindow** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMWINDOWCOLLECTION(_to)  \
+  NS_IMETHOD    GetLength(PRUint32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMWindow** aReturn) { return _to Item(aIndex, aReturn); }  \
+  NS_IMETHOD    NamedItem(const nsString& aName, nsIDOMWindow** aReturn) { return _to NamedItem(aName, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitWindowCollectionClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptWindowCollection(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMWindowCollection_h__

mozilla/dom/public/base/nsPIDOMWindow.h

@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsPIDOMWindow_h__
+#define nsPIDOMWindow_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+
+#define NS_PIDOMWINDOW_IID \
+{ 0x3aa80781, 0x7e6a, 0x11d3, { 0xbf, 0x87, 0x0, 0x10, 0x5a, 0x1b, 0x6, 0x27 } }
+
+
+class nsPIDOMWindow : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_PIDOMWINDOW_IID; return iid; }
+
+  NS_IMETHOD GetPrivateParent(nsPIDOMWindow** aResult)=0;
+};
+
+#endif // nsPIDOMWindow_h__

mozilla/dom/public/coreDom/MANIFEST

@@ -0,0 +1,42 @@
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+# This is a list of local files which get copied to the mozilla:dist:dom directory
+#
+
+nsIDOMAttr.h
+nsIDOMCDATASection.h
+nsIDOMCharacterData.h
+nsIDOMComment.h
+nsIDOMDOMImplementation.h
+nsIDOMDocument.h
+nsIDOMDocumentType.h
+nsIDOMDocumentFragment.h
+nsIDOMElement.h
+nsIDOMEntity.h
+nsIDOMNotation.h
+nsIDOMEntityReference.h
+nsIDOMNode.h
+nsIDOMNamedNodeMap.h
+nsIDOMNodeList.h
+nsIDOMProcessingInstruction.h
+nsIDOMText.h
+nsIDOMStyleSheet.h
+nsIDOMStyleSheetCollection.h
+nsIDOMNSDocument.h

mozilla/dom/public/coreDom/Makefile.in

@@ -0,0 +1,57 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= dom
+
+EXPORTS		= \
+		nsIDOMAttr.h \
+		nsIDOMCDATASection.h \
+		nsIDOMCharacterData.h \
+		nsIDOMComment.h \
+		nsIDOMDOMImplementation.h \
+		nsIDOMDocument.h \
+		nsIDOMDocumentType.h \
+		nsIDOMDocumentFragment.h \
+		nsIDOMElement.h \
+		nsIDOMEntity.h \
+		nsIDOMNotation.h \
+		nsIDOMEntityReference.h \
+		nsIDOMNode.h \
+		nsIDOMNamedNodeMap.h \
+		nsIDOMNodeList.h \
+		nsIDOMProcessingInstruction.h \
+		nsIDOMText.h \
+		nsIDOMStyleSheet.h \
+		nsIDOMStyleSheetCollection.h \
+		nsIDOMNSDocument.h \
+		$(NULL)
+
+EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/dom/public/coreDom/makefile.win

@@ -0,0 +1,53 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+
+DEPTH=..\..\..
+
+
+DEFINES=-D_IMPL_NS_DOM 
+EXPORTS = \
+	nsIDOMAttr.h							\
+	nsIDOMCDATASection.h			\
+	nsIDOMCharacterData.h 		\
+	nsIDOMComment.h						\
+	nsIDOMDOMImplementation.h	\
+	nsIDOMDocument.h					\
+	nsIDOMDocumentType.h			\
+	nsIDOMDocumentFragment.h	\
+	nsIDOMElement.h						\
+	nsIDOMEntity.h						\
+	nsIDOMNotation.h \
+	nsIDOMEntityReference.h		\
+	nsIDOMNode.h 							\
+	nsIDOMNamedNodeMap.h			\
+	nsIDOMNodeList.h					\
+	nsIDOMProcessingInstruction.h \
+	nsIDOMText.h							\
+	nsIDOMStyleSheet.h				\
+	nsIDOMStyleSheetCollection.h \
+	nsIDOMNSDocument.h				\
+	$(NULL)
+
+
+MODULE=dom 
+
+include <$(DEPTH)\config\rules.mak>
+

mozilla/dom/public/coreDom/nsIDOMAttr.h

@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMAttr_h__
+#define nsIDOMAttr_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+
+#define NS_IDOMATTR_IID \
+ { 0xa6cf9070, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMAttr : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMATTR_IID; return iid; }
+
+  NS_IMETHOD    GetName(nsString& aName)=0;
+
+  NS_IMETHOD    GetSpecified(PRBool* aSpecified)=0;
+
+  NS_IMETHOD    GetValue(nsString& aValue)=0;
+  NS_IMETHOD    SetValue(const nsString& aValue)=0;
+};
+
+
+#define NS_DECL_IDOMATTR   \
+  NS_IMETHOD    GetName(nsString& aName);  \
+  NS_IMETHOD    GetSpecified(PRBool* aSpecified);  \
+  NS_IMETHOD    GetValue(nsString& aValue);  \
+  NS_IMETHOD    SetValue(const nsString& aValue);  \
+
+
+
+#define NS_FORWARD_IDOMATTR(_to)  \
+  NS_IMETHOD    GetName(nsString& aName) { return _to GetName(aName); } \
+  NS_IMETHOD    GetSpecified(PRBool* aSpecified) { return _to GetSpecified(aSpecified); } \
+  NS_IMETHOD    GetValue(nsString& aValue) { return _to GetValue(aValue); } \
+  NS_IMETHOD    SetValue(const nsString& aValue) { return _to SetValue(aValue); } \
+
+
+extern "C" NS_DOM nsresult NS_InitAttrClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptAttr(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMAttr_h__

mozilla/dom/public/coreDom/nsIDOMCDATASection.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMCDATASection_h__
+#define nsIDOMCDATASection_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMText.h"
+
+
+#define NS_IDOMCDATASECTION_IID \
+ { 0xa6cf9071, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMCDATASection : public nsIDOMText {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMCDATASECTION_IID; return iid; }
+};
+
+
+#define NS_DECL_IDOMCDATASECTION   \
+
+
+
+#define NS_FORWARD_IDOMCDATASECTION(_to)  \
+
+
+extern "C" NS_DOM nsresult NS_InitCDATASectionClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptCDATASection(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMCDATASection_h__

mozilla/dom/public/coreDom/nsIDOMCharacterData.h

@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMCharacterData_h__
+#define nsIDOMCharacterData_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+
+#define NS_IDOMCHARACTERDATA_IID \
+ { 0xa6cf9072, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMCharacterData : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMCHARACTERDATA_IID; return iid; }
+
+  NS_IMETHOD    GetData(nsString& aData)=0;
+  NS_IMETHOD    SetData(const nsString& aData)=0;
+
+  NS_IMETHOD    GetLength(PRUint32* aLength)=0;
+
+  NS_IMETHOD    SubstringData(PRUint32 aOffset, PRUint32 aCount, nsString& aReturn)=0;
+
+  NS_IMETHOD    AppendData(const nsString& aArg)=0;
+
+  NS_IMETHOD    InsertData(PRUint32 aOffset, const nsString& aArg)=0;
+
+  NS_IMETHOD    DeleteData(PRUint32 aOffset, PRUint32 aCount)=0;
+
+  NS_IMETHOD    ReplaceData(PRUint32 aOffset, PRUint32 aCount, const nsString& aArg)=0;
+};
+
+
+#define NS_DECL_IDOMCHARACTERDATA   \
+  NS_IMETHOD    GetData(nsString& aData);  \
+  NS_IMETHOD    SetData(const nsString& aData);  \
+  NS_IMETHOD    GetLength(PRUint32* aLength);  \
+  NS_IMETHOD    SubstringData(PRUint32 aOffset, PRUint32 aCount, nsString& aReturn);  \
+  NS_IMETHOD    AppendData(const nsString& aArg);  \
+  NS_IMETHOD    InsertData(PRUint32 aOffset, const nsString& aArg);  \
+  NS_IMETHOD    DeleteData(PRUint32 aOffset, PRUint32 aCount);  \
+  NS_IMETHOD    ReplaceData(PRUint32 aOffset, PRUint32 aCount, const nsString& aArg);  \
+
+
+
+#define NS_FORWARD_IDOMCHARACTERDATA(_to)  \
+  NS_IMETHOD    GetData(nsString& aData) { return _to GetData(aData); } \
+  NS_IMETHOD    SetData(const nsString& aData) { return _to SetData(aData); } \
+  NS_IMETHOD    GetLength(PRUint32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    SubstringData(PRUint32 aOffset, PRUint32 aCount, nsString& aReturn) { return _to SubstringData(aOffset, aCount, aReturn); }  \
+  NS_IMETHOD    AppendData(const nsString& aArg) { return _to AppendData(aArg); }  \
+  NS_IMETHOD    InsertData(PRUint32 aOffset, const nsString& aArg) { return _to InsertData(aOffset, aArg); }  \
+  NS_IMETHOD    DeleteData(PRUint32 aOffset, PRUint32 aCount) { return _to DeleteData(aOffset, aCount); }  \
+  NS_IMETHOD    ReplaceData(PRUint32 aOffset, PRUint32 aCount, const nsString& aArg) { return _to ReplaceData(aOffset, aCount, aArg); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitCharacterDataClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptCharacterData(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMCharacterData_h__

mozilla/dom/public/coreDom/nsIDOMComment.h

@@ -19,45 +19,36 @@
  *
  * Contributor(s): 
  */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
 
-#ifndef nsIButton_h__
-#define nsIButton_h__
+#ifndef nsIDOMComment_h__
+#define nsIDOMComment_h__
 
-#include "nsIWidget.h"
+#include "nsISupports.h"
 #include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMCharacterData.h"
 
-// {18032AD0-B265-11d1-AA2A-000000000000}
-#define NS_IBUTTON_IID      \
-{ 0x18032ad0, 0xb265, 0x11d1, \
-    { 0xaa, 0x2a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }
 
-/**
- * Push button widget.
- * Automatically shows itself as depressed when clicked on.
- */
-class nsIButton : public nsISupports {
+#define NS_IDOMCOMMENT_IID \
+ { 0xa6cf9073, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
 
+class nsIDOMComment : public nsIDOMCharacterData {
 public:
-   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IBUTTON_IID) 
- 
-   /**
-    * Set the label
-    *
-    * @param  Set the label to aText
-    * @result NS_Ok if no errors
-    */
-  
-    NS_IMETHOD SetLabel(const nsString &aText) = 0;
-    
-   /**
-    * Get the button label
-    *
-    * @param aBuffer contains label upon return
-    * @result NS_Ok if no errors
-    */
- 
-    NS_IMETHOD GetLabel(nsString &aBuffer) = 0;
-
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMCOMMENT_IID; return iid; }
 };
 
-#endif
+
+#define NS_DECL_IDOMCOMMENT   \
+
+
+
+#define NS_FORWARD_IDOMCOMMENT(_to)  \
+
+
+extern "C" NS_DOM nsresult NS_InitCommentClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptComment(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMComment_h__

mozilla/dom/public/coreDom/nsIDOMDOMImplementation.h

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMDOMImplementation_h__
+#define nsIDOMDOMImplementation_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+
+#define NS_IDOMDOMIMPLEMENTATION_IID \
+ { 0xa6cf9074, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMDOMImplementation : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMDOMIMPLEMENTATION_IID; return iid; }
+
+  NS_IMETHOD    HasFeature(const nsString& aFeature, const nsString& aVersion, PRBool* aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMDOMIMPLEMENTATION   \
+  NS_IMETHOD    HasFeature(const nsString& aFeature, const nsString& aVersion, PRBool* aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMDOMIMPLEMENTATION(_to)  \
+  NS_IMETHOD    HasFeature(const nsString& aFeature, const nsString& aVersion, PRBool* aReturn) { return _to HasFeature(aFeature, aVersion, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitDOMImplementationClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptDOMImplementation(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMDOMImplementation_h__

mozilla/dom/public/coreDom/nsIDOMDocument.h

@@ -0,0 +1,113 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMDocument_h__
+#define nsIDOMDocument_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+class nsIDOMElement;
+class nsIDOMProcessingInstruction;
+class nsIDOMAttr;
+class nsIDOMCDATASection;
+class nsIDOMText;
+class nsIDOMDOMImplementation;
+class nsIDOMDocumentType;
+class nsIDOMEntityReference;
+class nsIDOMDocumentFragment;
+class nsIDOMComment;
+class nsIDOMNodeList;
+
+#define NS_IDOMDOCUMENT_IID \
+ { 0xa6cf9075, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMDocument : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMDOCUMENT_IID; return iid; }
+
+  NS_IMETHOD    GetDoctype(nsIDOMDocumentType** aDoctype)=0;
+
+  NS_IMETHOD    GetImplementation(nsIDOMDOMImplementation** aImplementation)=0;
+
+  NS_IMETHOD    GetDocumentElement(nsIDOMElement** aDocumentElement)=0;
+
+  NS_IMETHOD    CreateElement(const nsString& aTagName, nsIDOMElement** aReturn)=0;
+
+  NS_IMETHOD    CreateDocumentFragment(nsIDOMDocumentFragment** aReturn)=0;
+
+  NS_IMETHOD    CreateTextNode(const nsString& aData, nsIDOMText** aReturn)=0;
+
+  NS_IMETHOD    CreateComment(const nsString& aData, nsIDOMComment** aReturn)=0;
+
+  NS_IMETHOD    CreateCDATASection(const nsString& aData, nsIDOMCDATASection** aReturn)=0;
+
+  NS_IMETHOD    CreateProcessingInstruction(const nsString& aTarget, const nsString& aData, nsIDOMProcessingInstruction** aReturn)=0;
+
+  NS_IMETHOD    CreateAttribute(const nsString& aName, nsIDOMAttr** aReturn)=0;
+
+  NS_IMETHOD    CreateEntityReference(const nsString& aName, nsIDOMEntityReference** aReturn)=0;
+
+  NS_IMETHOD    GetElementsByTagName(const nsString& aTagname, nsIDOMNodeList** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMDOCUMENT   \
+  NS_IMETHOD    GetDoctype(nsIDOMDocumentType** aDoctype);  \
+  NS_IMETHOD    GetImplementation(nsIDOMDOMImplementation** aImplementation);  \
+  NS_IMETHOD    GetDocumentElement(nsIDOMElement** aDocumentElement);  \
+  NS_IMETHOD    CreateElement(const nsString& aTagName, nsIDOMElement** aReturn);  \
+  NS_IMETHOD    CreateDocumentFragment(nsIDOMDocumentFragment** aReturn);  \
+  NS_IMETHOD    CreateTextNode(const nsString& aData, nsIDOMText** aReturn);  \
+  NS_IMETHOD    CreateComment(const nsString& aData, nsIDOMComment** aReturn);  \
+  NS_IMETHOD    CreateCDATASection(const nsString& aData, nsIDOMCDATASection** aReturn);  \
+  NS_IMETHOD    CreateProcessingInstruction(const nsString& aTarget, const nsString& aData, nsIDOMProcessingInstruction** aReturn);  \
+  NS_IMETHOD    CreateAttribute(const nsString& aName, nsIDOMAttr** aReturn);  \
+  NS_IMETHOD    CreateEntityReference(const nsString& aName, nsIDOMEntityReference** aReturn);  \
+  NS_IMETHOD    GetElementsByTagName(const nsString& aTagname, nsIDOMNodeList** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMDOCUMENT(_to)  \
+  NS_IMETHOD    GetDoctype(nsIDOMDocumentType** aDoctype) { return _to GetDoctype(aDoctype); } \
+  NS_IMETHOD    GetImplementation(nsIDOMDOMImplementation** aImplementation) { return _to GetImplementation(aImplementation); } \
+  NS_IMETHOD    GetDocumentElement(nsIDOMElement** aDocumentElement) { return _to GetDocumentElement(aDocumentElement); } \
+  NS_IMETHOD    CreateElement(const nsString& aTagName, nsIDOMElement** aReturn) { return _to CreateElement(aTagName, aReturn); }  \
+  NS_IMETHOD    CreateDocumentFragment(nsIDOMDocumentFragment** aReturn) { return _to CreateDocumentFragment(aReturn); }  \
+  NS_IMETHOD    CreateTextNode(const nsString& aData, nsIDOMText** aReturn) { return _to CreateTextNode(aData, aReturn); }  \
+  NS_IMETHOD    CreateComment(const nsString& aData, nsIDOMComment** aReturn) { return _to CreateComment(aData, aReturn); }  \
+  NS_IMETHOD    CreateCDATASection(const nsString& aData, nsIDOMCDATASection** aReturn) { return _to CreateCDATASection(aData, aReturn); }  \
+  NS_IMETHOD    CreateProcessingInstruction(const nsString& aTarget, const nsString& aData, nsIDOMProcessingInstruction** aReturn) { return _to CreateProcessingInstruction(aTarget, aData, aReturn); }  \
+  NS_IMETHOD    CreateAttribute(const nsString& aName, nsIDOMAttr** aReturn) { return _to CreateAttribute(aName, aReturn); }  \
+  NS_IMETHOD    CreateEntityReference(const nsString& aName, nsIDOMEntityReference** aReturn) { return _to CreateEntityReference(aName, aReturn); }  \
+  NS_IMETHOD    GetElementsByTagName(const nsString& aTagname, nsIDOMNodeList** aReturn) { return _to GetElementsByTagName(aTagname, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitDocumentClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptDocument(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMDocument_h__

mozilla/dom/public/coreDom/nsIDOMDocumentFragment.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMDocumentFragment_h__
+#define nsIDOMDocumentFragment_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+
+#define NS_IDOMDOCUMENTFRAGMENT_IID \
+ { 0xa6cf9076, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMDocumentFragment : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMDOCUMENTFRAGMENT_IID; return iid; }
+};
+
+
+#define NS_DECL_IDOMDOCUMENTFRAGMENT   \
+
+
+
+#define NS_FORWARD_IDOMDOCUMENTFRAGMENT(_to)  \
+
+
+extern "C" NS_DOM nsresult NS_InitDocumentFragmentClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptDocumentFragment(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMDocumentFragment_h__

mozilla/dom/public/coreDom/nsIDOMDocumentType.h

@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMDocumentType_h__
+#define nsIDOMDocumentType_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+class nsIDOMNamedNodeMap;
+
+#define NS_IDOMDOCUMENTTYPE_IID \
+ { 0xa6cf9077, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMDocumentType : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMDOCUMENTTYPE_IID; return iid; }
+
+  NS_IMETHOD    GetName(nsString& aName)=0;
+
+  NS_IMETHOD    GetEntities(nsIDOMNamedNodeMap** aEntities)=0;
+
+  NS_IMETHOD    GetNotations(nsIDOMNamedNodeMap** aNotations)=0;
+};
+
+
+#define NS_DECL_IDOMDOCUMENTTYPE   \
+  NS_IMETHOD    GetName(nsString& aName);  \
+  NS_IMETHOD    GetEntities(nsIDOMNamedNodeMap** aEntities);  \
+  NS_IMETHOD    GetNotations(nsIDOMNamedNodeMap** aNotations);  \
+
+
+
+#define NS_FORWARD_IDOMDOCUMENTTYPE(_to)  \
+  NS_IMETHOD    GetName(nsString& aName) { return _to GetName(aName); } \
+  NS_IMETHOD    GetEntities(nsIDOMNamedNodeMap** aEntities) { return _to GetEntities(aEntities); } \
+  NS_IMETHOD    GetNotations(nsIDOMNamedNodeMap** aNotations) { return _to GetNotations(aNotations); } \
+
+
+extern "C" NS_DOM nsresult NS_InitDocumentTypeClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptDocumentType(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMDocumentType_h__

mozilla/dom/public/coreDom/nsIDOMElement.h

@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMElement_h__
+#define nsIDOMElement_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+class nsIDOMAttr;
+class nsIDOMNodeList;
+
+#define NS_IDOMELEMENT_IID \
+ { 0xa6cf9078, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMElement : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMELEMENT_IID; return iid; }
+
+  NS_IMETHOD    GetTagName(nsString& aTagName)=0;
+
+  NS_IMETHOD    GetAttribute(const nsString& aName, nsString& aReturn)=0;
+
+  NS_IMETHOD    SetAttribute(const nsString& aName, const nsString& aValue)=0;
+
+  NS_IMETHOD    RemoveAttribute(const nsString& aName)=0;
+
+  NS_IMETHOD    GetAttributeNode(const nsString& aName, nsIDOMAttr** aReturn)=0;
+
+  NS_IMETHOD    SetAttributeNode(nsIDOMAttr* aNewAttr, nsIDOMAttr** aReturn)=0;
+
+  NS_IMETHOD    RemoveAttributeNode(nsIDOMAttr* aOldAttr, nsIDOMAttr** aReturn)=0;
+
+  NS_IMETHOD    GetElementsByTagName(const nsString& aName, nsIDOMNodeList** aReturn)=0;
+
+  NS_IMETHOD    Normalize()=0;
+};
+
+
+#define NS_DECL_IDOMELEMENT   \
+  NS_IMETHOD    GetTagName(nsString& aTagName);  \
+  NS_IMETHOD    GetAttribute(const nsString& aName, nsString& aReturn);  \
+  NS_IMETHOD    SetAttribute(const nsString& aName, const nsString& aValue);  \
+  NS_IMETHOD    RemoveAttribute(const nsString& aName);  \
+  NS_IMETHOD    GetAttributeNode(const nsString& aName, nsIDOMAttr** aReturn);  \
+  NS_IMETHOD    SetAttributeNode(nsIDOMAttr* aNewAttr, nsIDOMAttr** aReturn);  \
+  NS_IMETHOD    RemoveAttributeNode(nsIDOMAttr* aOldAttr, nsIDOMAttr** aReturn);  \
+  NS_IMETHOD    GetElementsByTagName(const nsString& aName, nsIDOMNodeList** aReturn);  \
+  NS_IMETHOD    Normalize();  \
+
+
+
+#define NS_FORWARD_IDOMELEMENT(_to)  \
+  NS_IMETHOD    GetTagName(nsString& aTagName) { return _to GetTagName(aTagName); } \
+  NS_IMETHOD    GetAttribute(const nsString& aName, nsString& aReturn) { return _to GetAttribute(aName, aReturn); }  \
+  NS_IMETHOD    SetAttribute(const nsString& aName, const nsString& aValue) { return _to SetAttribute(aName, aValue); }  \
+  NS_IMETHOD    RemoveAttribute(const nsString& aName) { return _to RemoveAttribute(aName); }  \
+  NS_IMETHOD    GetAttributeNode(const nsString& aName, nsIDOMAttr** aReturn) { return _to GetAttributeNode(aName, aReturn); }  \
+  NS_IMETHOD    SetAttributeNode(nsIDOMAttr* aNewAttr, nsIDOMAttr** aReturn) { return _to SetAttributeNode(aNewAttr, aReturn); }  \
+  NS_IMETHOD    RemoveAttributeNode(nsIDOMAttr* aOldAttr, nsIDOMAttr** aReturn) { return _to RemoveAttributeNode(aOldAttr, aReturn); }  \
+  NS_IMETHOD    GetElementsByTagName(const nsString& aName, nsIDOMNodeList** aReturn) { return _to GetElementsByTagName(aName, aReturn); }  \
+  NS_IMETHOD    Normalize() { return _to Normalize(); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitElementClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptElement(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMElement_h__

mozilla/dom/public/coreDom/nsIDOMEntity.h

@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMEntity_h__
+#define nsIDOMEntity_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+
+#define NS_IDOMENTITY_IID \
+ { 0xa6cf9079, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMEntity : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMENTITY_IID; return iid; }
+
+  NS_IMETHOD    GetPublicId(nsString& aPublicId)=0;
+
+  NS_IMETHOD    GetSystemId(nsString& aSystemId)=0;
+
+  NS_IMETHOD    GetNotationName(nsString& aNotationName)=0;
+};
+
+
+#define NS_DECL_IDOMENTITY   \
+  NS_IMETHOD    GetPublicId(nsString& aPublicId);  \
+  NS_IMETHOD    GetSystemId(nsString& aSystemId);  \
+  NS_IMETHOD    GetNotationName(nsString& aNotationName);  \
+
+
+
+#define NS_FORWARD_IDOMENTITY(_to)  \
+  NS_IMETHOD    GetPublicId(nsString& aPublicId) { return _to GetPublicId(aPublicId); } \
+  NS_IMETHOD    GetSystemId(nsString& aSystemId) { return _to GetSystemId(aSystemId); } \
+  NS_IMETHOD    GetNotationName(nsString& aNotationName) { return _to GetNotationName(aNotationName); } \
+
+
+extern "C" NS_DOM nsresult NS_InitEntityClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptEntity(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMEntity_h__

mozilla/dom/public/coreDom/nsIDOMEntityReference.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMEntityReference_h__
+#define nsIDOMEntityReference_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+
+#define NS_IDOMENTITYREFERENCE_IID \
+ { 0xa6cf907a, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMEntityReference : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMENTITYREFERENCE_IID; return iid; }
+};
+
+
+#define NS_DECL_IDOMENTITYREFERENCE   \
+
+
+
+#define NS_FORWARD_IDOMENTITYREFERENCE(_to)  \
+
+
+extern "C" NS_DOM nsresult NS_InitEntityReferenceClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptEntityReference(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMEntityReference_h__

mozilla/dom/public/coreDom/nsIDOMNSDocument.h

@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMNSDocument_h__
+#define nsIDOMNSDocument_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMElement;
+class nsIDOMStyleSheetCollection;
+class nsIDOMRange;
+
+#define NS_IDOMNSDOCUMENT_IID \
+ { 0xa6cf90cd, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32} } 
+
+class nsIDOMNSDocument : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMNSDOCUMENT_IID; return iid; }
+
+  NS_IMETHOD    GetWidth(PRInt32* aWidth)=0;
+
+  NS_IMETHOD    GetHeight(PRInt32* aHeight)=0;
+
+  NS_IMETHOD    GetStyleSheets(nsIDOMStyleSheetCollection** aStyleSheets)=0;
+
+  NS_IMETHOD    CreateElementWithNameSpace(const nsString& aTagName, const nsString& aNameSpace, nsIDOMElement** aReturn)=0;
+
+  NS_IMETHOD    CreateRange(nsIDOMRange** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMNSDOCUMENT   \
+  NS_IMETHOD    GetWidth(PRInt32* aWidth);  \
+  NS_IMETHOD    GetHeight(PRInt32* aHeight);  \
+  NS_IMETHOD    GetStyleSheets(nsIDOMStyleSheetCollection** aStyleSheets);  \
+  NS_IMETHOD    CreateElementWithNameSpace(const nsString& aTagName, const nsString& aNameSpace, nsIDOMElement** aReturn);  \
+  NS_IMETHOD    CreateRange(nsIDOMRange** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMNSDOCUMENT(_to)  \
+  NS_IMETHOD    GetWidth(PRInt32* aWidth) { return _to GetWidth(aWidth); } \
+  NS_IMETHOD    GetHeight(PRInt32* aHeight) { return _to GetHeight(aHeight); } \
+  NS_IMETHOD    GetStyleSheets(nsIDOMStyleSheetCollection** aStyleSheets) { return _to GetStyleSheets(aStyleSheets); } \
+  NS_IMETHOD    CreateElementWithNameSpace(const nsString& aTagName, const nsString& aNameSpace, nsIDOMElement** aReturn) { return _to CreateElementWithNameSpace(aTagName, aNameSpace, aReturn); }  \
+  NS_IMETHOD    CreateRange(nsIDOMRange** aReturn) { return _to CreateRange(aReturn); }  \
+
+
+#endif // nsIDOMNSDocument_h__

mozilla/dom/public/coreDom/nsIDOMNamedNodeMap.h

@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMNamedNodeMap_h__
+#define nsIDOMNamedNodeMap_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMNode;
+
+#define NS_IDOMNAMEDNODEMAP_IID \
+ { 0xa6cf907b, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMNamedNodeMap : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMNAMEDNODEMAP_IID; return iid; }
+
+  NS_IMETHOD    GetLength(PRUint32* aLength)=0;
+
+  NS_IMETHOD    GetNamedItem(const nsString& aName, nsIDOMNode** aReturn)=0;
+
+  NS_IMETHOD    SetNamedItem(nsIDOMNode* aArg, nsIDOMNode** aReturn)=0;
+
+  NS_IMETHOD    RemoveNamedItem(const nsString& aName, nsIDOMNode** aReturn)=0;
+
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMNode** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMNAMEDNODEMAP   \
+  NS_IMETHOD    GetLength(PRUint32* aLength);  \
+  NS_IMETHOD    GetNamedItem(const nsString& aName, nsIDOMNode** aReturn);  \
+  NS_IMETHOD    SetNamedItem(nsIDOMNode* aArg, nsIDOMNode** aReturn);  \
+  NS_IMETHOD    RemoveNamedItem(const nsString& aName, nsIDOMNode** aReturn);  \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMNode** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMNAMEDNODEMAP(_to)  \
+  NS_IMETHOD    GetLength(PRUint32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    GetNamedItem(const nsString& aName, nsIDOMNode** aReturn) { return _to GetNamedItem(aName, aReturn); }  \
+  NS_IMETHOD    SetNamedItem(nsIDOMNode* aArg, nsIDOMNode** aReturn) { return _to SetNamedItem(aArg, aReturn); }  \
+  NS_IMETHOD    RemoveNamedItem(const nsString& aName, nsIDOMNode** aReturn) { return _to RemoveNamedItem(aName, aReturn); }  \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMNode** aReturn) { return _to Item(aIndex, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitNamedNodeMapClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptNamedNodeMap(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMNamedNodeMap_h__

mozilla/dom/public/coreDom/nsIDOMNode.h

@@ -0,0 +1,142 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMNode_h__
+#define nsIDOMNode_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMDocument;
+class nsIDOMNamedNodeMap;
+class nsIDOMNode;
+class nsIDOMNodeList;
+
+#define NS_IDOMNODE_IID \
+ { 0xa6cf907c, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMNode : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMNODE_IID; return iid; }
+  enum {
+    ELEMENT_NODE = 1,
+    ATTRIBUTE_NODE = 2,
+    TEXT_NODE = 3,
+    CDATA_SECTION_NODE = 4,
+    ENTITY_REFERENCE_NODE = 5,
+    ENTITY_NODE = 6,
+    PROCESSING_INSTRUCTION_NODE = 7,
+    COMMENT_NODE = 8,
+    DOCUMENT_NODE = 9,
+    DOCUMENT_TYPE_NODE = 10,
+    DOCUMENT_FRAGMENT_NODE = 11,
+    NOTATION_NODE = 12
+  };
+
+  NS_IMETHOD    GetNodeName(nsString& aNodeName)=0;
+
+  NS_IMETHOD    GetNodeValue(nsString& aNodeValue)=0;
+  NS_IMETHOD    SetNodeValue(const nsString& aNodeValue)=0;
+
+  NS_IMETHOD    GetNodeType(PRUint16* aNodeType)=0;
+
+  NS_IMETHOD    GetParentNode(nsIDOMNode** aParentNode)=0;
+
+  NS_IMETHOD    GetChildNodes(nsIDOMNodeList** aChildNodes)=0;
+
+  NS_IMETHOD    GetFirstChild(nsIDOMNode** aFirstChild)=0;
+
+  NS_IMETHOD    GetLastChild(nsIDOMNode** aLastChild)=0;
+
+  NS_IMETHOD    GetPreviousSibling(nsIDOMNode** aPreviousSibling)=0;
+
+  NS_IMETHOD    GetNextSibling(nsIDOMNode** aNextSibling)=0;
+
+  NS_IMETHOD    GetAttributes(nsIDOMNamedNodeMap** aAttributes)=0;
+
+  NS_IMETHOD    GetOwnerDocument(nsIDOMDocument** aOwnerDocument)=0;
+
+  NS_IMETHOD    InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aReturn)=0;
+
+  NS_IMETHOD    ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aReturn)=0;
+
+  NS_IMETHOD    RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn)=0;
+
+  NS_IMETHOD    AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aReturn)=0;
+
+  NS_IMETHOD    HasChildNodes(PRBool* aReturn)=0;
+
+  NS_IMETHOD    CloneNode(PRBool aDeep, nsIDOMNode** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMNODE   \
+  NS_IMETHOD    GetNodeName(nsString& aNodeName);  \
+  NS_IMETHOD    GetNodeValue(nsString& aNodeValue);  \
+  NS_IMETHOD    SetNodeValue(const nsString& aNodeValue);  \
+  NS_IMETHOD    GetNodeType(PRUint16* aNodeType);  \
+  NS_IMETHOD    GetParentNode(nsIDOMNode** aParentNode);  \
+  NS_IMETHOD    GetChildNodes(nsIDOMNodeList** aChildNodes);  \
+  NS_IMETHOD    GetFirstChild(nsIDOMNode** aFirstChild);  \
+  NS_IMETHOD    GetLastChild(nsIDOMNode** aLastChild);  \
+  NS_IMETHOD    GetPreviousSibling(nsIDOMNode** aPreviousSibling);  \
+  NS_IMETHOD    GetNextSibling(nsIDOMNode** aNextSibling);  \
+  NS_IMETHOD    GetAttributes(nsIDOMNamedNodeMap** aAttributes);  \
+  NS_IMETHOD    GetOwnerDocument(nsIDOMDocument** aOwnerDocument);  \
+  NS_IMETHOD    InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aReturn);  \
+  NS_IMETHOD    ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aReturn);  \
+  NS_IMETHOD    RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn);  \
+  NS_IMETHOD    AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aReturn);  \
+  NS_IMETHOD    HasChildNodes(PRBool* aReturn);  \
+  NS_IMETHOD    CloneNode(PRBool aDeep, nsIDOMNode** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMNODE(_to)  \
+  NS_IMETHOD    GetNodeName(nsString& aNodeName) { return _to GetNodeName(aNodeName); } \
+  NS_IMETHOD    GetNodeValue(nsString& aNodeValue) { return _to GetNodeValue(aNodeValue); } \
+  NS_IMETHOD    SetNodeValue(const nsString& aNodeValue) { return _to SetNodeValue(aNodeValue); } \
+  NS_IMETHOD    GetNodeType(PRUint16* aNodeType) { return _to GetNodeType(aNodeType); } \
+  NS_IMETHOD    GetParentNode(nsIDOMNode** aParentNode) { return _to GetParentNode(aParentNode); } \
+  NS_IMETHOD    GetChildNodes(nsIDOMNodeList** aChildNodes) { return _to GetChildNodes(aChildNodes); } \
+  NS_IMETHOD    GetFirstChild(nsIDOMNode** aFirstChild) { return _to GetFirstChild(aFirstChild); } \
+  NS_IMETHOD    GetLastChild(nsIDOMNode** aLastChild) { return _to GetLastChild(aLastChild); } \
+  NS_IMETHOD    GetPreviousSibling(nsIDOMNode** aPreviousSibling) { return _to GetPreviousSibling(aPreviousSibling); } \
+  NS_IMETHOD    GetNextSibling(nsIDOMNode** aNextSibling) { return _to GetNextSibling(aNextSibling); } \
+  NS_IMETHOD    GetAttributes(nsIDOMNamedNodeMap** aAttributes) { return _to GetAttributes(aAttributes); } \
+  NS_IMETHOD    GetOwnerDocument(nsIDOMDocument** aOwnerDocument) { return _to GetOwnerDocument(aOwnerDocument); } \
+  NS_IMETHOD    InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aReturn) { return _to InsertBefore(aNewChild, aRefChild, aReturn); }  \
+  NS_IMETHOD    ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aReturn) { return _to ReplaceChild(aNewChild, aOldChild, aReturn); }  \
+  NS_IMETHOD    RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn) { return _to RemoveChild(aOldChild, aReturn); }  \
+  NS_IMETHOD    AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aReturn) { return _to AppendChild(aNewChild, aReturn); }  \
+  NS_IMETHOD    HasChildNodes(PRBool* aReturn) { return _to HasChildNodes(aReturn); }  \
+  NS_IMETHOD    CloneNode(PRBool aDeep, nsIDOMNode** aReturn) { return _to CloneNode(aDeep, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitNodeClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptNode(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMNode_h__

mozilla/dom/public/coreDom/nsIDOMNodeList.h

@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMNodeList_h__
+#define nsIDOMNodeList_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMNode;
+
+#define NS_IDOMNODELIST_IID \
+ { 0xa6cf907d, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMNodeList : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMNODELIST_IID; return iid; }
+
+  NS_IMETHOD    GetLength(PRUint32* aLength)=0;
+
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMNode** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMNODELIST   \
+  NS_IMETHOD    GetLength(PRUint32* aLength);  \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMNode** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMNODELIST(_to)  \
+  NS_IMETHOD    GetLength(PRUint32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMNode** aReturn) { return _to Item(aIndex, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitNodeListClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptNodeList(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMNodeList_h__

mozilla/dom/public/coreDom/nsIDOMNotation.h

@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMNotation_h__
+#define nsIDOMNotation_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+
+#define NS_IDOMNOTATION_IID \
+ { 0xa6cf907e, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMNotation : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMNOTATION_IID; return iid; }
+
+  NS_IMETHOD    GetPublicId(nsString& aPublicId)=0;
+
+  NS_IMETHOD    GetSystemId(nsString& aSystemId)=0;
+};
+
+
+#define NS_DECL_IDOMNOTATION   \
+  NS_IMETHOD    GetPublicId(nsString& aPublicId);  \
+  NS_IMETHOD    GetSystemId(nsString& aSystemId);  \
+
+
+
+#define NS_FORWARD_IDOMNOTATION(_to)  \
+  NS_IMETHOD    GetPublicId(nsString& aPublicId) { return _to GetPublicId(aPublicId); } \
+  NS_IMETHOD    GetSystemId(nsString& aSystemId) { return _to GetSystemId(aSystemId); } \
+
+
+extern "C" NS_DOM nsresult NS_InitNotationClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptNotation(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMNotation_h__

mozilla/dom/public/coreDom/nsIDOMProcessingInstruction.h

@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMProcessingInstruction_h__
+#define nsIDOMProcessingInstruction_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMNode.h"
+
+
+#define NS_IDOMPROCESSINGINSTRUCTION_IID \
+ { 0xa6cf907f, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMProcessingInstruction : public nsIDOMNode {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMPROCESSINGINSTRUCTION_IID; return iid; }
+
+  NS_IMETHOD    GetTarget(nsString& aTarget)=0;
+
+  NS_IMETHOD    GetData(nsString& aData)=0;
+  NS_IMETHOD    SetData(const nsString& aData)=0;
+};
+
+
+#define NS_DECL_IDOMPROCESSINGINSTRUCTION   \
+  NS_IMETHOD    GetTarget(nsString& aTarget);  \
+  NS_IMETHOD    GetData(nsString& aData);  \
+  NS_IMETHOD    SetData(const nsString& aData);  \
+
+
+
+#define NS_FORWARD_IDOMPROCESSINGINSTRUCTION(_to)  \
+  NS_IMETHOD    GetTarget(nsString& aTarget) { return _to GetTarget(aTarget); } \
+  NS_IMETHOD    GetData(nsString& aData) { return _to GetData(aData); } \
+  NS_IMETHOD    SetData(const nsString& aData) { return _to SetData(aData); } \
+
+
+extern "C" NS_DOM nsresult NS_InitProcessingInstructionClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptProcessingInstruction(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMProcessingInstruction_h__

mozilla/dom/public/coreDom/nsIDOMStyleSheet.h

@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMStyleSheet_h__
+#define nsIDOMStyleSheet_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+
+#define NS_IDOMSTYLESHEET_IID \
+ { 0xa6cf9080, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMStyleSheet : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMSTYLESHEET_IID; return iid; }
+
+  NS_IMETHOD    GetType(nsString& aType)=0;
+
+  NS_IMETHOD    GetDisabled(PRBool* aDisabled)=0;
+  NS_IMETHOD    SetDisabled(PRBool aDisabled)=0;
+
+  NS_IMETHOD    GetReadOnly(PRBool* aReadOnly)=0;
+};
+
+
+#define NS_DECL_IDOMSTYLESHEET   \
+  NS_IMETHOD    GetType(nsString& aType);  \
+  NS_IMETHOD    GetDisabled(PRBool* aDisabled);  \
+  NS_IMETHOD    SetDisabled(PRBool aDisabled);  \
+  NS_IMETHOD    GetReadOnly(PRBool* aReadOnly);  \
+
+
+
+#define NS_FORWARD_IDOMSTYLESHEET(_to)  \
+  NS_IMETHOD    GetType(nsString& aType) { return _to GetType(aType); } \
+  NS_IMETHOD    GetDisabled(PRBool* aDisabled) { return _to GetDisabled(aDisabled); } \
+  NS_IMETHOD    SetDisabled(PRBool aDisabled) { return _to SetDisabled(aDisabled); } \
+  NS_IMETHOD    GetReadOnly(PRBool* aReadOnly) { return _to GetReadOnly(aReadOnly); } \
+
+
+extern "C" NS_DOM nsresult NS_InitStyleSheetClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptStyleSheet(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMStyleSheet_h__

mozilla/dom/public/coreDom/nsIDOMStyleSheetCollection.h

@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMStyleSheetCollection_h__
+#define nsIDOMStyleSheetCollection_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMStyleSheet;
+
+#define NS_IDOMSTYLESHEETCOLLECTION_IID \
+ { 0xa6cf9081, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMStyleSheetCollection : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMSTYLESHEETCOLLECTION_IID; return iid; }
+
+  NS_IMETHOD    GetLength(PRUint32* aLength)=0;
+
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMStyleSheet** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMSTYLESHEETCOLLECTION   \
+  NS_IMETHOD    GetLength(PRUint32* aLength);  \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMStyleSheet** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMSTYLESHEETCOLLECTION(_to)  \
+  NS_IMETHOD    GetLength(PRUint32* aLength) { return _to GetLength(aLength); } \
+  NS_IMETHOD    Item(PRUint32 aIndex, nsIDOMStyleSheet** aReturn) { return _to Item(aIndex, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitStyleSheetCollectionClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptStyleSheetCollection(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMStyleSheetCollection_h__

mozilla/dom/public/coreDom/nsIDOMText.h

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMText_h__
+#define nsIDOMText_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMCharacterData.h"
+
+class nsIDOMText;
+
+#define NS_IDOMTEXT_IID \
+ { 0xa6cf9082, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMText : public nsIDOMCharacterData {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMTEXT_IID; return iid; }
+
+  NS_IMETHOD    SplitText(PRUint32 aOffset, nsIDOMText** aReturn)=0;
+};
+
+
+#define NS_DECL_IDOMTEXT   \
+  NS_IMETHOD    SplitText(PRUint32 aOffset, nsIDOMText** aReturn);  \
+
+
+
+#define NS_FORWARD_IDOMTEXT(_to)  \
+  NS_IMETHOD    SplitText(PRUint32 aOffset, nsIDOMText** aReturn) { return _to SplitText(aOffset, aReturn); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitTextClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptText(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMText_h__

mozilla/dom/public/coreEvents/MANIFEST

@@ -0,0 +1,26 @@
+#
+# This is a list of local files which get copied to the mozilla:dist:dom directory
+#
+
+nsIDOMEvent.h
+nsIDOMUIEvent.h
+nsIDOMKeyEvent.h
+nsIDOMMouseEvent.h
+nsIDOMNSUIEvent.h
+nsIDOMEventListener.h
+nsIDOMEventCapturer.h
+nsIDOMEventReceiver.h
+nsIDOMFocusListener.h
+nsIDOMFormListener.h
+nsIDOMKeyListener.h
+nsIDOMLoadListener.h
+nsIDOMMouseListener.h
+nsIDOMMouseMotionListener.h
+nsIDOMDragListener.h
+nsIDOMPaintListener.h
+nsIDOMEventTarget.h
+nsIDOMTextListener.h
+nsIDOMCompositionListener.h
+nsIDOMMenuListener.h
+
+

mozilla/dom/public/coreEvents/Makefile.in

@@ -0,0 +1,57 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= dom
+
+EXPORTS		= \
+		nsIDOMEvent.h \
+		nsIDOMUIEvent.h \
+		nsIDOMKeyEvent.h \
+		nsIDOMMouseEvent.h \
+		nsIDOMEventListener.h \
+		nsIDOMEventCapturer.h \
+		nsIDOMEventReceiver.h \
+		nsIDOMFocusListener.h \
+		nsIDOMFormListener.h \
+		nsIDOMKeyListener.h \
+		nsIDOMLoadListener.h \
+		nsIDOMMouseListener.h \
+		nsIDOMMouseMotionListener.h \
+		nsIDOMPaintListener.h \
+		nsIDOMDragListener.h \
+		nsIDOMNSUIEvent.h \
+		nsIDOMEventTarget.h \
+		nsIDOMTextListener.h \
+		nsIDOMCompositionListener.h \
+		nsIDOMMenuListener.h \
+		$(NULL)
+
+EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/dom/public/coreEvents/makefile.win

@@ -0,0 +1,53 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+
+DEPTH=..\..\..
+
+
+DEFINES=-D_IMPL_NS_DOM 
+
+EXPORTS =				\
+	nsIDOMEvent.h			\
+	nsIDOMUIEvent.h			\
+	nsIDOMKeyEvent.h			\
+	nsIDOMMouseEvent.h			\
+	nsIDOMEventListener.h		\
+	nsIDOMEventCapturer.h		\
+	nsIDOMEventReceiver.h		\
+	nsIDOMFocusListener.h		\
+	nsIDOMFormListener.h		\
+	nsIDOMKeyListener.h		\
+	nsIDOMLoadListener.h		\
+	nsIDOMMouseListener.h		\
+	nsIDOMMouseMotionListener.h	\
+	nsIDOMPaintListener.h		\
+	nsIDOMDragListener.h		\
+	nsIDOMNSUIEvent.h			\
+	nsIDOMEventTarget.h		\
+	nsIDOMTextListener.h		\
+	nsIDOMCompositionListener.h	\
+	nsIDOMMenuListener.h        \
+	$(NULL)
+
+MODULE=dom
+
+include <$(DEPTH)\config\rules.mak>
+

mozilla/dom/public/coreEvents/nsIDOMCompositionListener.h

@@ -20,40 +20,29 @@
  * Contributor(s): 
  */
 
-#ifndef nsBaseDragService_h__
-#define nsBaseDragService_h__
+#ifndef nsIDOMCompositionListener_h__
+#define nsIDOMCompositionListener_h__
 
-#include "nsIDragService.h"
-#include "nsIDragSession.h"
-#include "nsITransferable.h"
-#include "nsISupportsArray.h"
-#include "nsCOMPtr.h"
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
 
-/**
- * XP DragService wrapper base class
+/*
+ * Key pressed / released / typed listener interface.
  */
+// {F14B6491-E95B-11d2-9E85-0060089FE59B}
+#define NS_IDOMCOMPOSITIONLISTENER_IID	\
+{ 0xf14b6491, 0xe95b, 0x11d2, \
+{ 0x9e, 0x85, 0x0, 0x60, 0x8, 0x9f, 0xe5, 0x9b } }
 
-class nsBaseDragService : public nsIDragService, public nsIDragSession
-{
+
+class nsIDOMCompositionListener : public nsIDOMEventListener {
 
 public:
-  nsBaseDragService();
-  virtual ~nsBaseDragService();
 
-  //nsISupports
-  NS_DECL_ISUPPORTS
-  
-  //nsIDragSession and nsIDragService
-  NS_DECL_NSIDRAGSERVICE
-  NS_DECL_NSIDRAGSESSION
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMCOMPOSITIONLISTENER_IID)
 
-protected:
+  virtual nsresult HandleStartComposition(nsIDOMEvent* aCompositionEvent) = 0;
+  virtual nsresult HandleEndComposition(nsIDOMEvent* aCompositionEvent) = 0;
 
-  nsCOMPtr<nsISupportsArray> mTransArray;
-  PRBool             mCanDrop;
-  PRBool             mDoingDrag;
-  nsSize             mTargetSize;
-  PRUint32           mDragAction;
 };
-
-#endif // nsBaseDragService_h__
+#endif // nsIDOMCompositionListener_h__

mozilla/dom/public/coreEvents/nsIDOMDragListener.h

@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+#ifndef nsIDOMDragListener_h__
+#define nsIDOMDragListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/*
+ * Mouse up/down/move event listener
+ *
+ */
+#define NS_IDOMDRAGLISTENER_IID \
+{ /* 6b8b25d0-ded5-11d1-bd85-00805f8ae3f4 */ \
+0x6b8b25d0, 0xded5, 0x11d1, \
+{0xbd, 0x85, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMDragListener : public nsIDOMEventListener {
+
+public:
+
+   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDRAGLISTENER_IID)
+
+  /**
+  * Processes a drag enter event
+  * @param aMouseEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult DragEnter(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+  * Processes a drag over event
+  * @param aMouseEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult DragOver(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+  * Processes a drag Exit event
+  * @param aMouseEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult DragExit(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+   * Processes a drag drop event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult DragDrop(nsIDOMEvent* aMouseEvent) = 0;
+  
+  /**
+   * Processes a drag gesture event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult DragGesture(nsIDOMEvent* aMouseEvent) = 0;
+
+};
+
+#endif // nsIDOMDragListener_h__

mozilla/dom/public/coreEvents/nsIDOMEvent.h

@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMEvent_h__
+#define nsIDOMEvent_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMNode;
+
+#define NS_IDOMEVENT_IID \
+ { 0xa66b7b80, 0xff46, 0xbd97, \
+  { 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMEvent : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMEVENT_IID; return iid; }
+  enum {
+    BUBBLING_PHASE = 1,
+    CAPTURING_PHASE = 2,
+    AT_TARGET = 3
+  };
+
+  NS_IMETHOD    GetType(nsString& aType)=0;
+
+  NS_IMETHOD    GetTarget(nsIDOMNode** aTarget)=0;
+
+  NS_IMETHOD    GetCurrentNode(nsIDOMNode** aCurrentNode)=0;
+
+  NS_IMETHOD    GetEventPhase(PRUint16* aEventPhase)=0;
+
+  NS_IMETHOD    GetBubbles(PRBool* aBubbles)=0;
+
+  NS_IMETHOD    GetCancelable(PRBool* aCancelable)=0;
+
+  NS_IMETHOD    PreventBubble()=0;
+
+  NS_IMETHOD    PreventCapture()=0;
+
+  NS_IMETHOD    PreventDefault()=0;
+
+  NS_IMETHOD    InitEvent(const nsString& aEventTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg)=0;
+};
+
+
+#define NS_DECL_IDOMEVENT   \
+  NS_IMETHOD    GetType(nsString& aType);  \
+  NS_IMETHOD    GetTarget(nsIDOMNode** aTarget);  \
+  NS_IMETHOD    GetCurrentNode(nsIDOMNode** aCurrentNode);  \
+  NS_IMETHOD    GetEventPhase(PRUint16* aEventPhase);  \
+  NS_IMETHOD    GetBubbles(PRBool* aBubbles);  \
+  NS_IMETHOD    GetCancelable(PRBool* aCancelable);  \
+  NS_IMETHOD    PreventBubble();  \
+  NS_IMETHOD    PreventCapture();  \
+  NS_IMETHOD    PreventDefault();  \
+  NS_IMETHOD    InitEvent(const nsString& aEventTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg);  \
+
+
+
+#define NS_FORWARD_IDOMEVENT(_to)  \
+  NS_IMETHOD    GetType(nsString& aType) { return _to GetType(aType); } \
+  NS_IMETHOD    GetTarget(nsIDOMNode** aTarget) { return _to GetTarget(aTarget); } \
+  NS_IMETHOD    GetCurrentNode(nsIDOMNode** aCurrentNode) { return _to GetCurrentNode(aCurrentNode); } \
+  NS_IMETHOD    GetEventPhase(PRUint16* aEventPhase) { return _to GetEventPhase(aEventPhase); } \
+  NS_IMETHOD    GetBubbles(PRBool* aBubbles) { return _to GetBubbles(aBubbles); } \
+  NS_IMETHOD    GetCancelable(PRBool* aCancelable) { return _to GetCancelable(aCancelable); } \
+  NS_IMETHOD    PreventBubble() { return _to PreventBubble(); }  \
+  NS_IMETHOD    PreventCapture() { return _to PreventCapture(); }  \
+  NS_IMETHOD    PreventDefault() { return _to PreventDefault(); }  \
+  NS_IMETHOD    InitEvent(const nsString& aEventTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg) { return _to InitEvent(aEventTypeArg, aCanBubbleArg, aCancelableArg); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitEventClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptEvent(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMEvent_h__

mozilla/dom/public/coreEvents/nsIDOMEventCapturer.h

@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMEventCapturer_h__
+#define nsIDOMEventCapturer_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMEventReceiver.h"
+
+
+#define NS_IDOMEVENTCAPTURER_IID \
+ { 0xa6cf906c, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMEventCapturer : public nsIDOMEventReceiver {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMEVENTCAPTURER_IID; return iid; }
+
+  NS_IMETHOD    CaptureEvent(const nsString& aType)=0;
+
+  NS_IMETHOD    ReleaseEvent(const nsString& aType)=0;
+};
+
+
+#define NS_DECL_IDOMEVENTCAPTURER   \
+  NS_IMETHOD    CaptureEvent(const nsString& aType);  \
+  NS_IMETHOD    ReleaseEvent(const nsString& aType);  \
+
+
+
+#define NS_FORWARD_IDOMEVENTCAPTURER(_to)  \
+  NS_IMETHOD    CaptureEvent(const nsString& aType) { return _to CaptureEvent(aType); }  \
+  NS_IMETHOD    ReleaseEvent(const nsString& aType) { return _to ReleaseEvent(aType); }  \
+
+
+#endif // nsIDOMEventCapturer_h__

mozilla/dom/public/coreEvents/nsIDOMEventListener.h

@@ -20,33 +20,34 @@
  * Contributor(s): 
  */
 
-#ifndef nsIEventListener_h__
-#define nsIEventListener_h__
+#ifndef nsIDOMEventListener_h__
+#define nsIDOMEventListener_h__
 
+#include "nsIDOMEvent.h"
 #include "nsISupports.h"
-#include "nsGUIEvent.h"
 
-/**
+/*
  * Event listener interface.
- * Alternative to a callback for recieving events.
  */
 
-// {c83f6b80-d7ce-11d2-8360-c4c894c4917c}
-#define NS_IEVENTLISTENER_IID \
-{ 0xc83f6b80, 0xd7ce, 0x11d2, { 0x83, 0x60, 0xc4, 0xc8, 0x94, 0xc4, 0x91, 0x7c } }
+#define NS_IDOMEVENTLISTENER_IID \
+{ /* df31c120-ded6-11d1-bd85-00805f8ae3f4 */ \
+0xdf31c120, 0xded6, 0x11d1, \
+{0xbd, 0x85, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMEventListener : public nsISupports {
 
-class nsIEventListener : public nsISupports {
 public:
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IEVENTLISTENER_IID)
-  
+
+   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMEVENTLISTENER_IID)
+
  /**
-  * Processes all events. 
-  * If a mouse listener is registered this method will not process mouse events. 
-  * @param anEvent the event to process. See nsGUIEvent.h for event types.
+  * Processes all events excepting mouse and key events. 
+  * @param anEvent the event to process. @see nsIDOMEvent.h for event types.
   */
 
-  virtual nsEventStatus ProcessEvent(const nsGUIEvent & anEvent) = 0;
+  virtual nsresult HandleEvent(nsIDOMEvent* aEvent) = 0;
 
 };
 
-#endif // nsIEventListener_h__
+#endif // nsIDOMEventListener_h__

mozilla/dom/public/coreEvents/nsIDOMEventReceiver.h

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsIDOMEventReceiver_h__
+#define nsIDOMEventReceiver_h__
+
+#include "nsIDOMEventTarget.h"
+
+class nsIDOMEventListener;
+class nsIDOMMouseListener;
+class nsIDOMMouseMotionListener;
+class nsIDOMKeyListener;
+class nsIDOMFocusListener;
+class nsIDOMLoadListener;
+class nsIDOMDragListener;
+class nsIEventListenerManager;
+
+/*
+ * DOM event source class.  Object that allow event registration and distribution 
+ * from themselves implement this interface.
+ */
+#define NS_IDOMEVENTRECEIVER_IID \
+{ /* e1dbcba0-fb38-11d1-bd87-00805f8ae3f4 */ \
+0xe1dbcba0, 0xfb38, 0x11d1, \
+{0xbd, 0x87, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMEventReceiver : public nsIDOMEventTarget {
+
+public:
+   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMEVENTRECEIVER_IID)
+
+  NS_IMETHOD AddEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID) = 0;
+  NS_IMETHOD RemoveEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID) = 0;
+  NS_IMETHOD GetListenerManager(nsIEventListenerManager** aInstancePtrResult) = 0;
+  NS_IMETHOD GetNewListenerManager(nsIEventListenerManager **aInstancePtrResult) = 0;
+
+};
+#endif // nsIDOMEventReceiver_h__

mozilla/dom/public/coreEvents/nsIDOMEventTarget.h

@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMEventTarget_h__
+#define nsIDOMEventTarget_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMEventListener;
+
+#define NS_IDOMEVENTTARGET_IID \
+ { 0x1c773b30, 0xd1cf, 0x11d2, \
+  { 0xbd, 0x95, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4 } } 
+
+class nsIDOMEventTarget : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMEVENTTARGET_IID; return iid; }
+
+  NS_IMETHOD    AddEventListener(const nsString& aType, nsIDOMEventListener* aListener, PRBool aUseCapture)=0;
+
+  NS_IMETHOD    RemoveEventListener(const nsString& aType, nsIDOMEventListener* aListener, PRBool aUseCapture)=0;
+};
+
+
+#define NS_DECL_IDOMEVENTTARGET   \
+  NS_IMETHOD    AddEventListener(const nsString& aType, nsIDOMEventListener* aListener, PRBool aUseCapture);  \
+  NS_IMETHOD    RemoveEventListener(const nsString& aType, nsIDOMEventListener* aListener, PRBool aUseCapture);  \
+
+
+
+#define NS_FORWARD_IDOMEVENTTARGET(_to)  \
+  NS_IMETHOD    AddEventListener(const nsString& aType, nsIDOMEventListener* aListener, PRBool aUseCapture) { return _to AddEventListener(aType, aListener, aUseCapture); }  \
+  NS_IMETHOD    RemoveEventListener(const nsString& aType, nsIDOMEventListener* aListener, PRBool aUseCapture) { return _to RemoveEventListener(aType, aListener, aUseCapture); }  \
+
+
+#endif // nsIDOMEventTarget_h__

mozilla/dom/public/coreEvents/nsIDOMFocusListener.h

@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+#ifndef nsIDOMFocusListener_h__
+#define nsIDOMFocusListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/*
+ * Mouse up/down/move event listener
+ *
+ */
+#define NS_IDOMFOCUSLISTENER_IID \
+{ /* 80974670-ded6-11d1-bd85-00805f8ae3f4 */ \
+0x80974670, 0xded6, 0x11d1, \
+{0xbd, 0x85, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMFocusListener : public nsIDOMEventListener {
+
+public:
+
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMFOCUSLISTENER_IID)
+
+  /**
+  * Processes a focus event
+  * @param aMouseEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult Focus(nsIDOMEvent* aEvent) = 0;
+
+  /**
+   * Processes a blur event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult Blur(nsIDOMEvent* aEvent) = 0;
+
+};
+
+#endif // nsIDOMFocusListener_h__

mozilla/dom/public/coreEvents/nsIDOMFormListener.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+#ifndef nsIDOMFormListener_h__
+#define nsIDOMFormListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/*
+ * Form submit/reset listener
+ *
+ */
+#define NS_IDOMFORMLISTENER_IID \
+{ /* 566c3f80-28ab-11d2-bd89-00805f8ae3f4 */ \
+0x566c3f80, 0x28ab, 0x11d2, \
+{0xbd, 0x89, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMFormListener : public nsIDOMEventListener {
+
+public:
+   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMFORMLISTENER_IID)
+  /**
+  * Processes a form submit event
+  * @param aEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult Submit(nsIDOMEvent* aEvent) = 0;
+
+  /**
+   * Processes a form reset event
+   * @param aEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult Reset(nsIDOMEvent* aEvent) = 0;
+
+  /**
+   * Processes a form change event
+   * @param aEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult Change(nsIDOMEvent* aEvent) = 0;
+
+  /**
+   * Processes a form select event
+   * @param aEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult Select(nsIDOMEvent* aEvent) = 0;
+  
+  /**
+   * Processes a form input event
+   * @param aEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult Input(nsIDOMEvent* aEvent) = 0;
+
+};
+
+#endif // nsIDOMFormListener_h__

mozilla/dom/public/coreEvents/nsIDOMKeyEvent.h

@@ -0,0 +1,197 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMKeyEvent_h__
+#define nsIDOMKeyEvent_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMUIEvent.h"
+
+class nsIDOMAbstractView;
+
+#define NS_IDOMKEYEVENT_IID \
+ { 0x028e0e6e, 0x8b01, 0x11d3, \
+  { 0xaa, 0xe7, 0x00, 0x10, 0x83, 0x8a, 0x31, 0x23 } } 
+
+class nsIDOMKeyEvent : public nsIDOMUIEvent {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMKEYEVENT_IID; return iid; }
+  enum {
+    DOM_VK_CANCEL = 3,
+    DOM_VK_BACK_SPACE = 8,
+    DOM_VK_TAB = 9,
+    DOM_VK_CLEAR = 12,
+    DOM_VK_RETURN = 13,
+    DOM_VK_ENTER = 14,
+    DOM_VK_SHIFT = 16,
+    DOM_VK_CONTROL = 17,
+    DOM_VK_ALT = 18,
+    DOM_VK_PAUSE = 19,
+    DOM_VK_CAPS_LOCK = 20,
+    DOM_VK_ESCAPE = 27,
+    DOM_VK_SPACE = 32,
+    DOM_VK_PAGE_UP = 33,
+    DOM_VK_PAGE_DOWN = 34,
+    DOM_VK_END = 35,
+    DOM_VK_HOME = 36,
+    DOM_VK_LEFT = 37,
+    DOM_VK_UP = 38,
+    DOM_VK_RIGHT = 39,
+    DOM_VK_DOWN = 40,
+    DOM_VK_PRINTSCREEN = 44,
+    DOM_VK_INSERT = 45,
+    DOM_VK_DELETE = 46,
+    DOM_VK_0 = 48,
+    DOM_VK_1 = 49,
+    DOM_VK_2 = 50,
+    DOM_VK_3 = 51,
+    DOM_VK_4 = 52,
+    DOM_VK_5 = 53,
+    DOM_VK_6 = 54,
+    DOM_VK_7 = 55,
+    DOM_VK_8 = 56,
+    DOM_VK_9 = 57,
+    DOM_VK_SEMICOLON = 59,
+    DOM_VK_EQUALS = 61,
+    DOM_VK_A = 65,
+    DOM_VK_B = 66,
+    DOM_VK_C = 67,
+    DOM_VK_D = 68,
+    DOM_VK_E = 69,
+    DOM_VK_F = 70,
+    DOM_VK_G = 71,
+    DOM_VK_H = 72,
+    DOM_VK_I = 73,
+    DOM_VK_J = 74,
+    DOM_VK_K = 75,
+    DOM_VK_L = 76,
+    DOM_VK_M = 77,
+    DOM_VK_N = 78,
+    DOM_VK_O = 79,
+    DOM_VK_P = 80,
+    DOM_VK_Q = 81,
+    DOM_VK_R = 82,
+    DOM_VK_S = 83,
+    DOM_VK_T = 84,
+    DOM_VK_U = 85,
+    DOM_VK_V = 86,
+    DOM_VK_W = 87,
+    DOM_VK_X = 88,
+    DOM_VK_Y = 89,
+    DOM_VK_Z = 90,
+    DOM_VK_NUMPAD0 = 96,
+    DOM_VK_NUMPAD1 = 97,
+    DOM_VK_NUMPAD2 = 98,
+    DOM_VK_NUMPAD3 = 99,
+    DOM_VK_NUMPAD4 = 100,
+    DOM_VK_NUMPAD5 = 101,
+    DOM_VK_NUMPAD6 = 102,
+    DOM_VK_NUMPAD7 = 103,
+    DOM_VK_NUMPAD8 = 104,
+    DOM_VK_NUMPAD9 = 105,
+    DOM_VK_MULTIPLY = 106,
+    DOM_VK_ADD = 107,
+    DOM_VK_SEPARATOR = 108,
+    DOM_VK_SUBTRACT = 109,
+    DOM_VK_DECIMAL = 110,
+    DOM_VK_DIVIDE = 111,
+    DOM_VK_F1 = 112,
+    DOM_VK_F2 = 113,
+    DOM_VK_F3 = 114,
+    DOM_VK_F4 = 115,
+    DOM_VK_F5 = 116,
+    DOM_VK_F6 = 117,
+    DOM_VK_F7 = 118,
+    DOM_VK_F8 = 119,
+    DOM_VK_F9 = 120,
+    DOM_VK_F10 = 121,
+    DOM_VK_F11 = 122,
+    DOM_VK_F12 = 123,
+    DOM_VK_F13 = 124,
+    DOM_VK_F14 = 125,
+    DOM_VK_F15 = 126,
+    DOM_VK_F16 = 127,
+    DOM_VK_F17 = 128,
+    DOM_VK_F18 = 129,
+    DOM_VK_F19 = 130,
+    DOM_VK_F20 = 131,
+    DOM_VK_F21 = 132,
+    DOM_VK_F22 = 133,
+    DOM_VK_F23 = 134,
+    DOM_VK_F24 = 135,
+    DOM_VK_NUM_LOCK = 144,
+    DOM_VK_SCROLL_LOCK = 145,
+    DOM_VK_COMMA = 188,
+    DOM_VK_PERIOD = 190,
+    DOM_VK_SLASH = 191,
+    DOM_VK_BACK_QUOTE = 192,
+    DOM_VK_OPEN_BRACKET = 219,
+    DOM_VK_BACK_SLASH = 220,
+    DOM_VK_CLOSE_BRACKET = 221,
+    DOM_VK_QUOTE = 222
+  };
+
+  NS_IMETHOD    GetCharCode(PRUint32* aCharCode)=0;
+
+  NS_IMETHOD    GetKeyCode(PRUint32* aKeyCode)=0;
+
+  NS_IMETHOD    GetAltKey(PRBool* aAltKey)=0;
+
+  NS_IMETHOD    GetCtrlKey(PRBool* aCtrlKey)=0;
+
+  NS_IMETHOD    GetShiftKey(PRBool* aShiftKey)=0;
+
+  NS_IMETHOD    GetMetaKey(PRBool* aMetaKey)=0;
+
+  NS_IMETHOD    InitKeyEvent(const nsString& aTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg, PRBool aCtrlKeyArg, PRBool aAltKeyArg, PRBool aShiftKeyArg, PRBool aMetaKeyArg, PRUint32 aKeyCodeArg, PRUint32 aCharCodeArg, nsIDOMAbstractView* aViewArg)=0;
+};
+
+
+#define NS_DECL_IDOMKEYEVENT   \
+  NS_IMETHOD    GetCharCode(PRUint32* aCharCode);  \
+  NS_IMETHOD    GetKeyCode(PRUint32* aKeyCode);  \
+  NS_IMETHOD    GetAltKey(PRBool* aAltKey);  \
+  NS_IMETHOD    GetCtrlKey(PRBool* aCtrlKey);  \
+  NS_IMETHOD    GetShiftKey(PRBool* aShiftKey);  \
+  NS_IMETHOD    GetMetaKey(PRBool* aMetaKey);  \
+  NS_IMETHOD    InitKeyEvent(const nsString& aTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg, PRBool aCtrlKeyArg, PRBool aAltKeyArg, PRBool aShiftKeyArg, PRBool aMetaKeyArg, PRUint32 aKeyCodeArg, PRUint32 aCharCodeArg, nsIDOMAbstractView* aViewArg);  \
+
+
+
+#define NS_FORWARD_IDOMKEYEVENT(_to)  \
+  NS_IMETHOD    GetCharCode(PRUint32* aCharCode) { return _to GetCharCode(aCharCode); } \
+  NS_IMETHOD    GetKeyCode(PRUint32* aKeyCode) { return _to GetKeyCode(aKeyCode); } \
+  NS_IMETHOD    GetAltKey(PRBool* aAltKey) { return _to GetAltKey(aAltKey); } \
+  NS_IMETHOD    GetCtrlKey(PRBool* aCtrlKey) { return _to GetCtrlKey(aCtrlKey); } \
+  NS_IMETHOD    GetShiftKey(PRBool* aShiftKey) { return _to GetShiftKey(aShiftKey); } \
+  NS_IMETHOD    GetMetaKey(PRBool* aMetaKey) { return _to GetMetaKey(aMetaKey); } \
+  NS_IMETHOD    InitKeyEvent(const nsString& aTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg, PRBool aCtrlKeyArg, PRBool aAltKeyArg, PRBool aShiftKeyArg, PRBool aMetaKeyArg, PRUint32 aKeyCodeArg, PRUint32 aCharCodeArg, nsIDOMAbstractView* aViewArg) { return _to InitKeyEvent(aTypeArg, aCanBubbleArg, aCancelableArg, aCtrlKeyArg, aAltKeyArg, aShiftKeyArg, aMetaKeyArg, aKeyCodeArg, aCharCodeArg, aViewArg); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitKeyEventClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptKeyEvent(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMKeyEvent_h__

mozilla/dom/public/coreEvents/nsIDOMKeyListener.h

@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsIDOMKeyListener_h__
+#define nsIDOMKeyListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/*
+ * Key pressed / released / typed listener interface.
+ */
+#define NS_IDOMKEYLISTENER_IID \
+{ /* 35f0d080-da38-11d1-bd85-00805f8ae3f4 */ \
+0x35f0d080, 0xda38, 0x11d1, \
+{0xbd, 0x85, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMKeyListener : public nsIDOMEventListener {
+
+public:
+
+     NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMKEYLISTENER_IID)
+    
+    /**
+     * Processes a key pressed event
+     * @param aKeyEvent @see nsIDOMEvent.h 
+     * @returns whether the event was consumed or ignored. @see nsresult
+     */
+    virtual nsresult KeyDown(nsIDOMEvent* aKeyEvent) = 0;
+
+    /**
+     * Processes a key release event
+     * @param aKeyEvent @see nsIDOMEvent.h 
+     * @returns whether the event was consumed or ignored. @see nsresult
+     */
+    virtual nsresult KeyUp(nsIDOMEvent* aKeyEvent) = 0;
+
+    /**
+     * Processes a key typed event
+     * @param aKeyEvent @see nsIDOMEvent.h 
+     * @returns whether the event was consumed or ignored. @see nsresult
+     *
+     */
+    virtual nsresult KeyPress(nsIDOMEvent* aKeyEvent) = 0;
+
+};
+#endif // nsIDOMKeyListener_h__

mozilla/dom/public/coreEvents/nsIDOMLoadListener.h

@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+#ifndef nsIDOMLoadListener_h__
+#define nsIDOMLoadListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/*
+ * Mouse up/down/move event listener
+ *
+ */
+#define NS_IDOMLOADLISTENER_IID \
+{ /* f2b05200-ded5-11d1-bd85-00805f8ae3f4 */ \
+0xf2b05200, 0xded5, 0x11d1, \
+{0xbd, 0x85, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMLoadListener : public nsIDOMEventListener {
+
+public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMLOADLISTENER_IID)
+  /**
+  * Processes a page or image load event
+  * @param aMouseEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult Load(nsIDOMEvent* aEvent) = 0;
+
+  /**
+   * Processes a page unload event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult Unload(nsIDOMEvent* aEvent) = 0;
+
+  /**
+   * Processes a load abort event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   *
+   */
+  virtual nsresult Abort(nsIDOMEvent* aEvent) = 0;
+
+  /**
+   * Processes an load error event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult Error(nsIDOMEvent* aEvent) = 0;
+
+};
+
+#endif // nsIDOMLoadListener_h__

mozilla/dom/public/coreEvents/nsIDOMMenuListener.h

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+#ifndef nsIDOMMenuListener_h__
+#define nsIDOMMenuListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+// {0730C841-42F3-11d3-97FA-00400553EEF0}
+#define NS_IDOMMENULISTENER_IID \
+{ 0x730c841, 0x42f3, 0x11d3, { 0x97, 0xfa, 0x0, 0x40, 0x5, 0x53, 0xee, 0xf0 } }
+
+class nsIDOMMenuListener : public nsIDOMEventListener {
+
+public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMMENULISTENER_IID)
+
+  NS_IMETHOD Create(nsIDOMEvent* aEvent) = 0;
+  NS_IMETHOD Destroy(nsIDOMEvent* aEvent) = 0;
+  NS_IMETHOD Action(nsIDOMEvent* aEvent) = 0;
+  NS_IMETHOD Broadcast(nsIDOMEvent* aEvent) = 0;
+  NS_IMETHOD CommandUpdate(nsIDOMEvent* aEvent) = 0;
+};
+
+#endif // nsIDOMMenuListener_h__

mozilla/dom/public/coreEvents/nsIDOMMouseEvent.h

@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMMouseEvent_h__
+#define nsIDOMMouseEvent_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMUIEvent.h"
+
+class nsIDOMNode;
+
+#define NS_IDOMMOUSEEVENT_IID \
+ { 0xff751edc, 0x8b02, 0xaae7, \
+  { 0x00, 0x10, 0x83, 0x01, 0x83, 0x8a, 0x31, 0x23 } } 
+
+class nsIDOMMouseEvent : public nsIDOMUIEvent {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMMOUSEEVENT_IID; return iid; }
+
+  NS_IMETHOD    GetScreenX(PRInt32* aScreenX)=0;
+
+  NS_IMETHOD    GetScreenY(PRInt32* aScreenY)=0;
+
+  NS_IMETHOD    GetClientX(PRInt32* aClientX)=0;
+
+  NS_IMETHOD    GetClientY(PRInt32* aClientY)=0;
+
+  NS_IMETHOD    GetAltKey(PRBool* aAltKey)=0;
+
+  NS_IMETHOD    GetCtrlKey(PRBool* aCtrlKey)=0;
+
+  NS_IMETHOD    GetShiftKey(PRBool* aShiftKey)=0;
+
+  NS_IMETHOD    GetMetaKey(PRBool* aMetaKey)=0;
+
+  NS_IMETHOD    GetButton(PRUint16* aButton)=0;
+
+  NS_IMETHOD    GetClickCount(PRUint16* aClickCount)=0;
+
+  NS_IMETHOD    GetRelatedNode(nsIDOMNode** aRelatedNode)=0;
+
+  NS_IMETHOD    InitMouseEvent(const nsString& aTypeArg, PRBool aCtrlKeyArg, PRBool aAltKeyArg, PRBool aShiftKeyArg, PRBool aMetaKeyArg, PRInt32 aScreenXArg, PRInt32 aScreenYArg, PRInt32 aClientXArg, PRInt32 aClientYArg, PRUint16 aButtonArg, PRUint16 aDetailArg)=0;
+};
+
+
+#define NS_DECL_IDOMMOUSEEVENT   \
+  NS_IMETHOD    GetScreenX(PRInt32* aScreenX);  \
+  NS_IMETHOD    GetScreenY(PRInt32* aScreenY);  \
+  NS_IMETHOD    GetClientX(PRInt32* aClientX);  \
+  NS_IMETHOD    GetClientY(PRInt32* aClientY);  \
+  NS_IMETHOD    GetAltKey(PRBool* aAltKey);  \
+  NS_IMETHOD    GetCtrlKey(PRBool* aCtrlKey);  \
+  NS_IMETHOD    GetShiftKey(PRBool* aShiftKey);  \
+  NS_IMETHOD    GetMetaKey(PRBool* aMetaKey);  \
+  NS_IMETHOD    GetButton(PRUint16* aButton);  \
+  NS_IMETHOD    GetClickCount(PRUint16* aClickCount);  \
+  NS_IMETHOD    GetRelatedNode(nsIDOMNode** aRelatedNode);  \
+  NS_IMETHOD    InitMouseEvent(const nsString& aTypeArg, PRBool aCtrlKeyArg, PRBool aAltKeyArg, PRBool aShiftKeyArg, PRBool aMetaKeyArg, PRInt32 aScreenXArg, PRInt32 aScreenYArg, PRInt32 aClientXArg, PRInt32 aClientYArg, PRUint16 aButtonArg, PRUint16 aDetailArg);  \
+
+
+
+#define NS_FORWARD_IDOMMOUSEEVENT(_to)  \
+  NS_IMETHOD    GetScreenX(PRInt32* aScreenX) { return _to GetScreenX(aScreenX); } \
+  NS_IMETHOD    GetScreenY(PRInt32* aScreenY) { return _to GetScreenY(aScreenY); } \
+  NS_IMETHOD    GetClientX(PRInt32* aClientX) { return _to GetClientX(aClientX); } \
+  NS_IMETHOD    GetClientY(PRInt32* aClientY) { return _to GetClientY(aClientY); } \
+  NS_IMETHOD    GetAltKey(PRBool* aAltKey) { return _to GetAltKey(aAltKey); } \
+  NS_IMETHOD    GetCtrlKey(PRBool* aCtrlKey) { return _to GetCtrlKey(aCtrlKey); } \
+  NS_IMETHOD    GetShiftKey(PRBool* aShiftKey) { return _to GetShiftKey(aShiftKey); } \
+  NS_IMETHOD    GetMetaKey(PRBool* aMetaKey) { return _to GetMetaKey(aMetaKey); } \
+  NS_IMETHOD    GetButton(PRUint16* aButton) { return _to GetButton(aButton); } \
+  NS_IMETHOD    GetClickCount(PRUint16* aClickCount) { return _to GetClickCount(aClickCount); } \
+  NS_IMETHOD    GetRelatedNode(nsIDOMNode** aRelatedNode) { return _to GetRelatedNode(aRelatedNode); } \
+  NS_IMETHOD    InitMouseEvent(const nsString& aTypeArg, PRBool aCtrlKeyArg, PRBool aAltKeyArg, PRBool aShiftKeyArg, PRBool aMetaKeyArg, PRInt32 aScreenXArg, PRInt32 aScreenYArg, PRInt32 aClientXArg, PRInt32 aClientYArg, PRUint16 aButtonArg, PRUint16 aDetailArg) { return _to InitMouseEvent(aTypeArg, aCtrlKeyArg, aAltKeyArg, aShiftKeyArg, aMetaKeyArg, aScreenXArg, aScreenYArg, aClientXArg, aClientYArg, aButtonArg, aDetailArg); }  \
+
+
+#endif // nsIDOMMouseEvent_h__

mozilla/dom/public/coreEvents/nsIDOMMouseListener.h

@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+#ifndef nsIDOMMouseListener_h__
+#define nsIDOMMouseListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/*
+ * Mouse up/down/move event listener
+ *
+ */
+#define NS_IDOMMOUSELISTENER_IID \
+{ /* ccd7fa30-da37-11d1-bd85-00805f8ae3f4 */ \
+0xccd7fa30, 0xda37, 0x11d1, \
+{0xbd, 0x85, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMMouseListener : public nsIDOMEventListener {
+
+public:
+
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMMOUSELISTENER_IID)
+
+  /**
+  * Processes a mouse down event
+  * @param aMouseEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult MouseDown(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+   * Processes a mouse up event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult MouseUp(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+   * Processes a mouse click event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   *
+   */
+  virtual nsresult MouseClick(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+   * Processes a mouse click event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   *
+   */
+  virtual nsresult MouseDblClick(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+   * Processes a mouse enter event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult MouseOver(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+   * Processes a mouse leave event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult MouseOut(nsIDOMEvent* aMouseEvent) = 0;
+
+};
+
+#endif // nsIDOMMouseListener_h__

mozilla/dom/public/coreEvents/nsIDOMMouseMotionListener.h

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+
+#ifndef nsIDOMMouseMotionListener_h__
+#define nsIDOMMouseMotionListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/*
+ * Mouse motion event listener
+ *
+ */
+#define NS_IDOMMOUSEMOTIONLISTENER_IID \
+{ /* 162b3480-ded6-11d1-bd85-00805f8ae3f4 */ \
+0x162b3480, 0xded6, 0x11d1, \
+{0xbd, 0x85, 0x00, 0x80, 0x5f, 0x8a, 0xe3, 0xf4} }
+
+class nsIDOMMouseMotionListener : public nsIDOMEventListener {
+
+public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMMOUSEMOTIONLISTENER_IID)
+  /**
+  * Processes a mouse move event
+  * @param aMouseEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult MouseMove(nsIDOMEvent* aMouseEvent) = 0;
+
+  /**
+   * Processes a drag move event
+   * @param aMouseEvent @see nsIDOMEvent.h 
+   * @returns whether the event was consumed or ignored. @see nsresult
+   */
+  virtual nsresult DragMove(nsIDOMEvent* aMouseEvent) = 0;
+
+};
+
+#endif // nsIDOMMouseMotionListener_h__

mozilla/dom/public/coreEvents/nsIDOMNSUIEvent.h

@@ -0,0 +1,126 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMNSUIEvent_h__
+#define nsIDOMNSUIEvent_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+
+class nsIDOMNode;
+
+#define NS_IDOMNSUIEVENT_IID \
+ { 0xa6cf90c4, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMNSUIEvent : public nsISupports {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMNSUIEVENT_IID; return iid; }
+  enum {
+    MOUSEDOWN = 1,
+    MOUSEUP = 2,
+    MOUSEOVER = 4,
+    MOUSEOUT = 8,
+    MOUSEMOVE = 16,
+    MOUSEDRAG = 32,
+    CLICK = 64,
+    DBLCLICK = 128,
+    KEYDOWN = 256,
+    KEYUP = 512,
+    KEYPRESS = 1024,
+    DRAGDROP = 2048,
+    FOCUS = 4096,
+    BLUR = 8192,
+    SELECT = 16384,
+    CHANGE = 32768,
+    RESET = 65536,
+    SUBMIT = 131072,
+    SCROLL = 262144,
+    LOAD = 524288,
+    UNLOAD = 1048576,
+    XFER_DONE = 2097152,
+    ABORT = 4194304,
+    ERROR = 8388608,
+    LOCATE = 16777216,
+    MOVE = 33554432,
+    RESIZE = 67108864,
+    FORWARD = 134217728,
+    HELP = 268435456,
+    BACK = 536870912,
+    TEXT = 1073741824,
+    ALT_MASK = 1,
+    CONTROL_MASK = 2,
+    SHIFT_MASK = 4,
+    META_MASK = 8
+  };
+
+  NS_IMETHOD    GetLayerX(PRInt32* aLayerX)=0;
+
+  NS_IMETHOD    GetLayerY(PRInt32* aLayerY)=0;
+
+  NS_IMETHOD    GetPageX(PRInt32* aPageX)=0;
+
+  NS_IMETHOD    GetPageY(PRInt32* aPageY)=0;
+
+  NS_IMETHOD    GetWhich(PRUint32* aWhich)=0;
+
+  NS_IMETHOD    GetRangeParent(nsIDOMNode** aRangeParent)=0;
+
+  NS_IMETHOD    GetRangeOffset(PRInt32* aRangeOffset)=0;
+
+  NS_IMETHOD    GetCancelBubble(PRBool* aCancelBubble)=0;
+  NS_IMETHOD    SetCancelBubble(PRBool aCancelBubble)=0;
+
+  NS_IMETHOD    GetIsChar(PRBool* aIsChar)=0;
+};
+
+
+#define NS_DECL_IDOMNSUIEVENT   \
+  NS_IMETHOD    GetLayerX(PRInt32* aLayerX);  \
+  NS_IMETHOD    GetLayerY(PRInt32* aLayerY);  \
+  NS_IMETHOD    GetPageX(PRInt32* aPageX);  \
+  NS_IMETHOD    GetPageY(PRInt32* aPageY);  \
+  NS_IMETHOD    GetWhich(PRUint32* aWhich);  \
+  NS_IMETHOD    GetRangeParent(nsIDOMNode** aRangeParent);  \
+  NS_IMETHOD    GetRangeOffset(PRInt32* aRangeOffset);  \
+  NS_IMETHOD    GetCancelBubble(PRBool* aCancelBubble);  \
+  NS_IMETHOD    SetCancelBubble(PRBool aCancelBubble);  \
+  NS_IMETHOD    GetIsChar(PRBool* aIsChar);  \
+
+
+
+#define NS_FORWARD_IDOMNSUIEVENT(_to)  \
+  NS_IMETHOD    GetLayerX(PRInt32* aLayerX) { return _to GetLayerX(aLayerX); } \
+  NS_IMETHOD    GetLayerY(PRInt32* aLayerY) { return _to GetLayerY(aLayerY); } \
+  NS_IMETHOD    GetPageX(PRInt32* aPageX) { return _to GetPageX(aPageX); } \
+  NS_IMETHOD    GetPageY(PRInt32* aPageY) { return _to GetPageY(aPageY); } \
+  NS_IMETHOD    GetWhich(PRUint32* aWhich) { return _to GetWhich(aWhich); } \
+  NS_IMETHOD    GetRangeParent(nsIDOMNode** aRangeParent) { return _to GetRangeParent(aRangeParent); } \
+  NS_IMETHOD    GetRangeOffset(PRInt32* aRangeOffset) { return _to GetRangeOffset(aRangeOffset); } \
+  NS_IMETHOD    GetCancelBubble(PRBool* aCancelBubble) { return _to GetCancelBubble(aCancelBubble); } \
+  NS_IMETHOD    SetCancelBubble(PRBool aCancelBubble) { return _to SetCancelBubble(aCancelBubble); } \
+  NS_IMETHOD    GetIsChar(PRBool* aIsChar) { return _to GetIsChar(aIsChar); } \
+
+
+#endif // nsIDOMNSUIEvent_h__

mozilla/dom/public/coreEvents/nsIDOMPaintListener.h

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+#ifndef nsIDOMPaintListener_h__
+#define nsIDOMPaintListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/* a6cf906a-15b3-11d2-932e-00805f8add32 */
+#define NS_IDOMPAINTLISTENER_IID \
+ {0xa6cf906a, 0x15b3, 0x11d2, {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}
+
+/*
+ * Paint event listener
+ */
+class nsIDOMPaintListener : public nsIDOMEventListener {
+public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMPAINTLISTENER_IID)
+  /**
+  * Processes a paint event
+  * @param aEvent @see nsIDOMEvent.h 
+  * @returns whether the event was consumed or ignored. @see nsresult
+  */
+  virtual nsresult Paint(nsIDOMEvent* aEvent) = 0;
+};
+
+#endif /* nsIDOMPaintListener_h__ */

mozilla/dom/public/coreEvents/nsIDOMTextListener.h

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsIDOMTextListener_h__
+#define nsIDOMTextListener_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+
+/*
+ * Key pressed / released / typed listener interface.
+ */
+// {C6296E81-D823-11d2-9E7F-0060089FE59B}
+#define NS_IDOMTEXTLISTENER_IID \
+{ 0xc6296e81, 0xd823, 0x11d2, { 0x9e, 0x7f, 0x0, 0x60, 0x8, 0x9f, 0xe5, 0x9b } }
+
+
+class nsIDOMTextListener : public nsIDOMEventListener {
+
+public:
+
+      NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMTEXTLISTENER_IID)
+
+    virtual nsresult HandleText(nsIDOMEvent* aTextEvent) = 0;
+
+};
+#endif // nsIDOMTextListener_h__

mozilla/dom/public/coreEvents/nsIDOMUIEvent.h

@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMUIEvent_h__
+#define nsIDOMUIEvent_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMEvent.h"
+
+class nsIDOMAbstractView;
+
+#define NS_IDOMUIEVENT_IID \
+ { 0xa6cf90c3, 0x15b3, 0x11d2, \
+  { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMUIEvent : public nsIDOMEvent {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMUIEVENT_IID; return iid; }
+
+  NS_IMETHOD    GetView(nsIDOMAbstractView** aView)=0;
+
+  NS_IMETHOD    GetDetail(PRInt32* aDetail)=0;
+
+  NS_IMETHOD    InitUIEvent(const nsString& aTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg, nsIDOMAbstractView* aViewArg, PRInt32 aDetailArg)=0;
+};
+
+
+#define NS_DECL_IDOMUIEVENT   \
+  NS_IMETHOD    GetView(nsIDOMAbstractView** aView);  \
+  NS_IMETHOD    GetDetail(PRInt32* aDetail);  \
+  NS_IMETHOD    InitUIEvent(const nsString& aTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg, nsIDOMAbstractView* aViewArg, PRInt32 aDetailArg);  \
+
+
+
+#define NS_FORWARD_IDOMUIEVENT(_to)  \
+  NS_IMETHOD    GetView(nsIDOMAbstractView** aView) { return _to GetView(aView); } \
+  NS_IMETHOD    GetDetail(PRInt32* aDetail) { return _to GetDetail(aDetail); } \
+  NS_IMETHOD    InitUIEvent(const nsString& aTypeArg, PRBool aCanBubbleArg, PRBool aCancelableArg, nsIDOMAbstractView* aViewArg, PRInt32 aDetailArg) { return _to InitUIEvent(aTypeArg, aCanBubbleArg, aCancelableArg, aViewArg, aDetailArg); }  \
+
+
+extern "C" NS_DOM nsresult NS_InitUIEventClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptUIEvent(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMUIEvent_h__

mozilla/dom/public/css/MANIFEST

@@ -0,0 +1,33 @@
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+# This is a list of local files which get copied to the mozilla:dist:dom directory
+#
+
+nsIDOMCSS2Properties.h
+nsIDOMCSSFontFaceRule.h
+nsIDOMCSSImportRule.h
+nsIDOMCSSMediaRule.h
+nsIDOMCSSPageRule.h
+nsIDOMCSSRule.h
+nsIDOMCSSStyleDeclaration.h
+nsIDOMCSSStyleRule.h
+nsIDOMCSSStyleRuleCollection.h
+nsIDOMCSSStyleSheet.h
+nsIDOMCSSUnknownRule.h

mozilla/dom/public/css/Makefile.in

@@ -0,0 +1,48 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= dom
+
+EXPORTS		= \
+		nsIDOMCSS2Properties.h \
+		nsIDOMCSSFontFaceRule.h \
+		nsIDOMCSSImportRule.h \
+		nsIDOMCSSMediaRule.h \
+		nsIDOMCSSPageRule.h \
+		nsIDOMCSSRule.h \
+		nsIDOMCSSStyleDeclaration.h \
+		nsIDOMCSSStyleRule.h \
+		nsIDOMCSSStyleRuleCollection.h \
+		nsIDOMCSSStyleSheet.h \
+		nsIDOMCSSUnknownRule.h \
+		$(NULL)
+
+EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/dom/public/css/makefile.win

@@ -0,0 +1,41 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+
+DEPTH=..\..\..
+
+
+DEFINES=-D_IMPL_NS_DOM 
+EXPORTS= \
+  nsIDOMCSS2Properties.h \
+  nsIDOMCSSFontFaceRule.h \
+  nsIDOMCSSImportRule.h \
+  nsIDOMCSSMediaRule.h \
+  nsIDOMCSSPageRule.h \
+  nsIDOMCSSRule.h \
+  nsIDOMCSSStyleDeclaration.h \
+  nsIDOMCSSStyleRule.h \
+  nsIDOMCSSStyleRuleCollection.h \
+  nsIDOMCSSStyleSheet.h \
+  nsIDOMCSSUnknownRule.h
+
+MODULE=dom 
+
+include <$(DEPTH)\config\rules.mak>

mozilla/dom/public/css/nsIDOMCSS2Properties.h

@@ -0,0 +1,915 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMCSS2Properties_h__
+#define nsIDOMCSS2Properties_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMCSSStyleDeclaration.h"
+
+
+#define NS_IDOMCSS2PROPERTIES_IID \
+ { 0xa6cf90d1, 0x15b3, 0x11d2, \
+    {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMCSS2Properties : public nsIDOMCSSStyleDeclaration {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMCSS2PROPERTIES_IID; return iid; }
+
+  NS_IMETHOD    GetAzimuth(nsString& aAzimuth)=0;
+  NS_IMETHOD    SetAzimuth(const nsString& aAzimuth)=0;
+
+  NS_IMETHOD    GetBackground(nsString& aBackground)=0;
+  NS_IMETHOD    SetBackground(const nsString& aBackground)=0;
+
+  NS_IMETHOD    GetBackgroundAttachment(nsString& aBackgroundAttachment)=0;
+  NS_IMETHOD    SetBackgroundAttachment(const nsString& aBackgroundAttachment)=0;
+
+  NS_IMETHOD    GetBackgroundColor(nsString& aBackgroundColor)=0;
+  NS_IMETHOD    SetBackgroundColor(const nsString& aBackgroundColor)=0;
+
+  NS_IMETHOD    GetBackgroundImage(nsString& aBackgroundImage)=0;
+  NS_IMETHOD    SetBackgroundImage(const nsString& aBackgroundImage)=0;
+
+  NS_IMETHOD    GetBackgroundPosition(nsString& aBackgroundPosition)=0;
+  NS_IMETHOD    SetBackgroundPosition(const nsString& aBackgroundPosition)=0;
+
+  NS_IMETHOD    GetBackgroundRepeat(nsString& aBackgroundRepeat)=0;
+  NS_IMETHOD    SetBackgroundRepeat(const nsString& aBackgroundRepeat)=0;
+
+  NS_IMETHOD    GetBorder(nsString& aBorder)=0;
+  NS_IMETHOD    SetBorder(const nsString& aBorder)=0;
+
+  NS_IMETHOD    GetBorderCollapse(nsString& aBorderCollapse)=0;
+  NS_IMETHOD    SetBorderCollapse(const nsString& aBorderCollapse)=0;
+
+  NS_IMETHOD    GetBorderColor(nsString& aBorderColor)=0;
+  NS_IMETHOD    SetBorderColor(const nsString& aBorderColor)=0;
+
+  NS_IMETHOD    GetBorderSpacing(nsString& aBorderSpacing)=0;
+  NS_IMETHOD    SetBorderSpacing(const nsString& aBorderSpacing)=0;
+
+  NS_IMETHOD    GetBorderStyle(nsString& aBorderStyle)=0;
+  NS_IMETHOD    SetBorderStyle(const nsString& aBorderStyle)=0;
+
+  NS_IMETHOD    GetBorderTop(nsString& aBorderTop)=0;
+  NS_IMETHOD    SetBorderTop(const nsString& aBorderTop)=0;
+
+  NS_IMETHOD    GetBorderRight(nsString& aBorderRight)=0;
+  NS_IMETHOD    SetBorderRight(const nsString& aBorderRight)=0;
+
+  NS_IMETHOD    GetBorderBottom(nsString& aBorderBottom)=0;
+  NS_IMETHOD    SetBorderBottom(const nsString& aBorderBottom)=0;
+
+  NS_IMETHOD    GetBorderLeft(nsString& aBorderLeft)=0;
+  NS_IMETHOD    SetBorderLeft(const nsString& aBorderLeft)=0;
+
+  NS_IMETHOD    GetBorderTopColor(nsString& aBorderTopColor)=0;
+  NS_IMETHOD    SetBorderTopColor(const nsString& aBorderTopColor)=0;
+
+  NS_IMETHOD    GetBorderRightColor(nsString& aBorderRightColor)=0;
+  NS_IMETHOD    SetBorderRightColor(const nsString& aBorderRightColor)=0;
+
+  NS_IMETHOD    GetBorderBottomColor(nsString& aBorderBottomColor)=0;
+  NS_IMETHOD    SetBorderBottomColor(const nsString& aBorderBottomColor)=0;
+
+  NS_IMETHOD    GetBorderLeftColor(nsString& aBorderLeftColor)=0;
+  NS_IMETHOD    SetBorderLeftColor(const nsString& aBorderLeftColor)=0;
+
+  NS_IMETHOD    GetBorderTopStyle(nsString& aBorderTopStyle)=0;
+  NS_IMETHOD    SetBorderTopStyle(const nsString& aBorderTopStyle)=0;
+
+  NS_IMETHOD    GetBorderRightStyle(nsString& aBorderRightStyle)=0;
+  NS_IMETHOD    SetBorderRightStyle(const nsString& aBorderRightStyle)=0;
+
+  NS_IMETHOD    GetBorderBottomStyle(nsString& aBorderBottomStyle)=0;
+  NS_IMETHOD    SetBorderBottomStyle(const nsString& aBorderBottomStyle)=0;
+
+  NS_IMETHOD    GetBorderLeftStyle(nsString& aBorderLeftStyle)=0;
+  NS_IMETHOD    SetBorderLeftStyle(const nsString& aBorderLeftStyle)=0;
+
+  NS_IMETHOD    GetBorderTopWidth(nsString& aBorderTopWidth)=0;
+  NS_IMETHOD    SetBorderTopWidth(const nsString& aBorderTopWidth)=0;
+
+  NS_IMETHOD    GetBorderRightWidth(nsString& aBorderRightWidth)=0;
+  NS_IMETHOD    SetBorderRightWidth(const nsString& aBorderRightWidth)=0;
+
+  NS_IMETHOD    GetBorderBottomWidth(nsString& aBorderBottomWidth)=0;
+  NS_IMETHOD    SetBorderBottomWidth(const nsString& aBorderBottomWidth)=0;
+
+  NS_IMETHOD    GetBorderLeftWidth(nsString& aBorderLeftWidth)=0;
+  NS_IMETHOD    SetBorderLeftWidth(const nsString& aBorderLeftWidth)=0;
+
+  NS_IMETHOD    GetBorderWidth(nsString& aBorderWidth)=0;
+  NS_IMETHOD    SetBorderWidth(const nsString& aBorderWidth)=0;
+
+  NS_IMETHOD    GetBottom(nsString& aBottom)=0;
+  NS_IMETHOD    SetBottom(const nsString& aBottom)=0;
+
+  NS_IMETHOD    GetCaptionSide(nsString& aCaptionSide)=0;
+  NS_IMETHOD    SetCaptionSide(const nsString& aCaptionSide)=0;
+
+  NS_IMETHOD    GetClear(nsString& aClear)=0;
+  NS_IMETHOD    SetClear(const nsString& aClear)=0;
+
+  NS_IMETHOD    GetClip(nsString& aClip)=0;
+  NS_IMETHOD    SetClip(const nsString& aClip)=0;
+
+  NS_IMETHOD    GetColor(nsString& aColor)=0;
+  NS_IMETHOD    SetColor(const nsString& aColor)=0;
+
+  NS_IMETHOD    GetContent(nsString& aContent)=0;
+  NS_IMETHOD    SetContent(const nsString& aContent)=0;
+
+  NS_IMETHOD    GetCounterIncrement(nsString& aCounterIncrement)=0;
+  NS_IMETHOD    SetCounterIncrement(const nsString& aCounterIncrement)=0;
+
+  NS_IMETHOD    GetCounterReset(nsString& aCounterReset)=0;
+  NS_IMETHOD    SetCounterReset(const nsString& aCounterReset)=0;
+
+  NS_IMETHOD    GetCue(nsString& aCue)=0;
+  NS_IMETHOD    SetCue(const nsString& aCue)=0;
+
+  NS_IMETHOD    GetCueAfter(nsString& aCueAfter)=0;
+  NS_IMETHOD    SetCueAfter(const nsString& aCueAfter)=0;
+
+  NS_IMETHOD    GetCueBefore(nsString& aCueBefore)=0;
+  NS_IMETHOD    SetCueBefore(const nsString& aCueBefore)=0;
+
+  NS_IMETHOD    GetCursor(nsString& aCursor)=0;
+  NS_IMETHOD    SetCursor(const nsString& aCursor)=0;
+
+  NS_IMETHOD    GetDirection(nsString& aDirection)=0;
+  NS_IMETHOD    SetDirection(const nsString& aDirection)=0;
+
+  NS_IMETHOD    GetDisplay(nsString& aDisplay)=0;
+  NS_IMETHOD    SetDisplay(const nsString& aDisplay)=0;
+
+  NS_IMETHOD    GetElevation(nsString& aElevation)=0;
+  NS_IMETHOD    SetElevation(const nsString& aElevation)=0;
+
+  NS_IMETHOD    GetEmptyCells(nsString& aEmptyCells)=0;
+  NS_IMETHOD    SetEmptyCells(const nsString& aEmptyCells)=0;
+
+  NS_IMETHOD    GetCssFloat(nsString& aCssFloat)=0;
+  NS_IMETHOD    SetCssFloat(const nsString& aCssFloat)=0;
+
+  NS_IMETHOD    GetFont(nsString& aFont)=0;
+  NS_IMETHOD    SetFont(const nsString& aFont)=0;
+
+  NS_IMETHOD    GetFontFamily(nsString& aFontFamily)=0;
+  NS_IMETHOD    SetFontFamily(const nsString& aFontFamily)=0;
+
+  NS_IMETHOD    GetFontSize(nsString& aFontSize)=0;
+  NS_IMETHOD    SetFontSize(const nsString& aFontSize)=0;
+
+  NS_IMETHOD    GetFontSizeAdjust(nsString& aFontSizeAdjust)=0;
+  NS_IMETHOD    SetFontSizeAdjust(const nsString& aFontSizeAdjust)=0;
+
+  NS_IMETHOD    GetFontStretch(nsString& aFontStretch)=0;
+  NS_IMETHOD    SetFontStretch(const nsString& aFontStretch)=0;
+
+  NS_IMETHOD    GetFontStyle(nsString& aFontStyle)=0;
+  NS_IMETHOD    SetFontStyle(const nsString& aFontStyle)=0;
+
+  NS_IMETHOD    GetFontVariant(nsString& aFontVariant)=0;
+  NS_IMETHOD    SetFontVariant(const nsString& aFontVariant)=0;
+
+  NS_IMETHOD    GetFontWeight(nsString& aFontWeight)=0;
+  NS_IMETHOD    SetFontWeight(const nsString& aFontWeight)=0;
+
+  NS_IMETHOD    GetHeight(nsString& aHeight)=0;
+  NS_IMETHOD    SetHeight(const nsString& aHeight)=0;
+
+  NS_IMETHOD    GetLeft(nsString& aLeft)=0;
+  NS_IMETHOD    SetLeft(const nsString& aLeft)=0;
+
+  NS_IMETHOD    GetLetterSpacing(nsString& aLetterSpacing)=0;
+  NS_IMETHOD    SetLetterSpacing(const nsString& aLetterSpacing)=0;
+
+  NS_IMETHOD    GetLineHeight(nsString& aLineHeight)=0;
+  NS_IMETHOD    SetLineHeight(const nsString& aLineHeight)=0;
+
+  NS_IMETHOD    GetListStyle(nsString& aListStyle)=0;
+  NS_IMETHOD    SetListStyle(const nsString& aListStyle)=0;
+
+  NS_IMETHOD    GetListStyleImage(nsString& aListStyleImage)=0;
+  NS_IMETHOD    SetListStyleImage(const nsString& aListStyleImage)=0;
+
+  NS_IMETHOD    GetListStylePosition(nsString& aListStylePosition)=0;
+  NS_IMETHOD    SetListStylePosition(const nsString& aListStylePosition)=0;
+
+  NS_IMETHOD    GetListStyleType(nsString& aListStyleType)=0;
+  NS_IMETHOD    SetListStyleType(const nsString& aListStyleType)=0;
+
+  NS_IMETHOD    GetMargin(nsString& aMargin)=0;
+  NS_IMETHOD    SetMargin(const nsString& aMargin)=0;
+
+  NS_IMETHOD    GetMarginTop(nsString& aMarginTop)=0;
+  NS_IMETHOD    SetMarginTop(const nsString& aMarginTop)=0;
+
+  NS_IMETHOD    GetMarginRight(nsString& aMarginRight)=0;
+  NS_IMETHOD    SetMarginRight(const nsString& aMarginRight)=0;
+
+  NS_IMETHOD    GetMarginBottom(nsString& aMarginBottom)=0;
+  NS_IMETHOD    SetMarginBottom(const nsString& aMarginBottom)=0;
+
+  NS_IMETHOD    GetMarginLeft(nsString& aMarginLeft)=0;
+  NS_IMETHOD    SetMarginLeft(const nsString& aMarginLeft)=0;
+
+  NS_IMETHOD    GetMarkerOffset(nsString& aMarkerOffset)=0;
+  NS_IMETHOD    SetMarkerOffset(const nsString& aMarkerOffset)=0;
+
+  NS_IMETHOD    GetMarks(nsString& aMarks)=0;
+  NS_IMETHOD    SetMarks(const nsString& aMarks)=0;
+
+  NS_IMETHOD    GetMaxHeight(nsString& aMaxHeight)=0;
+  NS_IMETHOD    SetMaxHeight(const nsString& aMaxHeight)=0;
+
+  NS_IMETHOD    GetMaxWidth(nsString& aMaxWidth)=0;
+  NS_IMETHOD    SetMaxWidth(const nsString& aMaxWidth)=0;
+
+  NS_IMETHOD    GetMinHeight(nsString& aMinHeight)=0;
+  NS_IMETHOD    SetMinHeight(const nsString& aMinHeight)=0;
+
+  NS_IMETHOD    GetMinWidth(nsString& aMinWidth)=0;
+  NS_IMETHOD    SetMinWidth(const nsString& aMinWidth)=0;
+
+  NS_IMETHOD    GetOrphans(nsString& aOrphans)=0;
+  NS_IMETHOD    SetOrphans(const nsString& aOrphans)=0;
+
+  NS_IMETHOD    GetOutline(nsString& aOutline)=0;
+  NS_IMETHOD    SetOutline(const nsString& aOutline)=0;
+
+  NS_IMETHOD    GetOutlineColor(nsString& aOutlineColor)=0;
+  NS_IMETHOD    SetOutlineColor(const nsString& aOutlineColor)=0;
+
+  NS_IMETHOD    GetOutlineStyle(nsString& aOutlineStyle)=0;
+  NS_IMETHOD    SetOutlineStyle(const nsString& aOutlineStyle)=0;
+
+  NS_IMETHOD    GetOutlineWidth(nsString& aOutlineWidth)=0;
+  NS_IMETHOD    SetOutlineWidth(const nsString& aOutlineWidth)=0;
+
+  NS_IMETHOD    GetOverflow(nsString& aOverflow)=0;
+  NS_IMETHOD    SetOverflow(const nsString& aOverflow)=0;
+
+  NS_IMETHOD    GetPadding(nsString& aPadding)=0;
+  NS_IMETHOD    SetPadding(const nsString& aPadding)=0;
+
+  NS_IMETHOD    GetPaddingTop(nsString& aPaddingTop)=0;
+  NS_IMETHOD    SetPaddingTop(const nsString& aPaddingTop)=0;
+
+  NS_IMETHOD    GetPaddingRight(nsString& aPaddingRight)=0;
+  NS_IMETHOD    SetPaddingRight(const nsString& aPaddingRight)=0;
+
+  NS_IMETHOD    GetPaddingBottom(nsString& aPaddingBottom)=0;
+  NS_IMETHOD    SetPaddingBottom(const nsString& aPaddingBottom)=0;
+
+  NS_IMETHOD    GetPaddingLeft(nsString& aPaddingLeft)=0;
+  NS_IMETHOD    SetPaddingLeft(const nsString& aPaddingLeft)=0;
+
+  NS_IMETHOD    GetPage(nsString& aPage)=0;
+  NS_IMETHOD    SetPage(const nsString& aPage)=0;
+
+  NS_IMETHOD    GetPageBreakAfter(nsString& aPageBreakAfter)=0;
+  NS_IMETHOD    SetPageBreakAfter(const nsString& aPageBreakAfter)=0;
+
+  NS_IMETHOD    GetPageBreakBefore(nsString& aPageBreakBefore)=0;
+  NS_IMETHOD    SetPageBreakBefore(const nsString& aPageBreakBefore)=0;
+
+  NS_IMETHOD    GetPageBreakInside(nsString& aPageBreakInside)=0;
+  NS_IMETHOD    SetPageBreakInside(const nsString& aPageBreakInside)=0;
+
+  NS_IMETHOD    GetPause(nsString& aPause)=0;
+  NS_IMETHOD    SetPause(const nsString& aPause)=0;
+
+  NS_IMETHOD    GetPauseAfter(nsString& aPauseAfter)=0;
+  NS_IMETHOD    SetPauseAfter(const nsString& aPauseAfter)=0;
+
+  NS_IMETHOD    GetPauseBefore(nsString& aPauseBefore)=0;
+  NS_IMETHOD    SetPauseBefore(const nsString& aPauseBefore)=0;
+
+  NS_IMETHOD    GetPitch(nsString& aPitch)=0;
+  NS_IMETHOD    SetPitch(const nsString& aPitch)=0;
+
+  NS_IMETHOD    GetPitchRange(nsString& aPitchRange)=0;
+  NS_IMETHOD    SetPitchRange(const nsString& aPitchRange)=0;
+
+  NS_IMETHOD    GetPlayDuring(nsString& aPlayDuring)=0;
+  NS_IMETHOD    SetPlayDuring(const nsString& aPlayDuring)=0;
+
+  NS_IMETHOD    GetPosition(nsString& aPosition)=0;
+  NS_IMETHOD    SetPosition(const nsString& aPosition)=0;
+
+  NS_IMETHOD    GetQuotes(nsString& aQuotes)=0;
+  NS_IMETHOD    SetQuotes(const nsString& aQuotes)=0;
+
+  NS_IMETHOD    GetRichness(nsString& aRichness)=0;
+  NS_IMETHOD    SetRichness(const nsString& aRichness)=0;
+
+  NS_IMETHOD    GetRight(nsString& aRight)=0;
+  NS_IMETHOD    SetRight(const nsString& aRight)=0;
+
+  NS_IMETHOD    GetSize(nsString& aSize)=0;
+  NS_IMETHOD    SetSize(const nsString& aSize)=0;
+
+  NS_IMETHOD    GetSpeak(nsString& aSpeak)=0;
+  NS_IMETHOD    SetSpeak(const nsString& aSpeak)=0;
+
+  NS_IMETHOD    GetSpeakHeader(nsString& aSpeakHeader)=0;
+  NS_IMETHOD    SetSpeakHeader(const nsString& aSpeakHeader)=0;
+
+  NS_IMETHOD    GetSpeakNumeral(nsString& aSpeakNumeral)=0;
+  NS_IMETHOD    SetSpeakNumeral(const nsString& aSpeakNumeral)=0;
+
+  NS_IMETHOD    GetSpeakPunctuation(nsString& aSpeakPunctuation)=0;
+  NS_IMETHOD    SetSpeakPunctuation(const nsString& aSpeakPunctuation)=0;
+
+  NS_IMETHOD    GetSpeechRate(nsString& aSpeechRate)=0;
+  NS_IMETHOD    SetSpeechRate(const nsString& aSpeechRate)=0;
+
+  NS_IMETHOD    GetStress(nsString& aStress)=0;
+  NS_IMETHOD    SetStress(const nsString& aStress)=0;
+
+  NS_IMETHOD    GetTableLayout(nsString& aTableLayout)=0;
+  NS_IMETHOD    SetTableLayout(const nsString& aTableLayout)=0;
+
+  NS_IMETHOD    GetTextAlign(nsString& aTextAlign)=0;
+  NS_IMETHOD    SetTextAlign(const nsString& aTextAlign)=0;
+
+  NS_IMETHOD    GetTextDecoration(nsString& aTextDecoration)=0;
+  NS_IMETHOD    SetTextDecoration(const nsString& aTextDecoration)=0;
+
+  NS_IMETHOD    GetTextIndent(nsString& aTextIndent)=0;
+  NS_IMETHOD    SetTextIndent(const nsString& aTextIndent)=0;
+
+  NS_IMETHOD    GetTextShadow(nsString& aTextShadow)=0;
+  NS_IMETHOD    SetTextShadow(const nsString& aTextShadow)=0;
+
+  NS_IMETHOD    GetTextTransform(nsString& aTextTransform)=0;
+  NS_IMETHOD    SetTextTransform(const nsString& aTextTransform)=0;
+
+  NS_IMETHOD    GetTop(nsString& aTop)=0;
+  NS_IMETHOD    SetTop(const nsString& aTop)=0;
+
+  NS_IMETHOD    GetUnicodeBidi(nsString& aUnicodeBidi)=0;
+  NS_IMETHOD    SetUnicodeBidi(const nsString& aUnicodeBidi)=0;
+
+  NS_IMETHOD    GetVerticalAlign(nsString& aVerticalAlign)=0;
+  NS_IMETHOD    SetVerticalAlign(const nsString& aVerticalAlign)=0;
+
+  NS_IMETHOD    GetVisibility(nsString& aVisibility)=0;
+  NS_IMETHOD    SetVisibility(const nsString& aVisibility)=0;
+
+  NS_IMETHOD    GetVoiceFamily(nsString& aVoiceFamily)=0;
+  NS_IMETHOD    SetVoiceFamily(const nsString& aVoiceFamily)=0;
+
+  NS_IMETHOD    GetVolume(nsString& aVolume)=0;
+  NS_IMETHOD    SetVolume(const nsString& aVolume)=0;
+
+  NS_IMETHOD    GetWhiteSpace(nsString& aWhiteSpace)=0;
+  NS_IMETHOD    SetWhiteSpace(const nsString& aWhiteSpace)=0;
+
+  NS_IMETHOD    GetWidows(nsString& aWidows)=0;
+  NS_IMETHOD    SetWidows(const nsString& aWidows)=0;
+
+  NS_IMETHOD    GetWidth(nsString& aWidth)=0;
+  NS_IMETHOD    SetWidth(const nsString& aWidth)=0;
+
+  NS_IMETHOD    GetWordSpacing(nsString& aWordSpacing)=0;
+  NS_IMETHOD    SetWordSpacing(const nsString& aWordSpacing)=0;
+
+  NS_IMETHOD    GetZIndex(nsString& aZIndex)=0;
+  NS_IMETHOD    SetZIndex(const nsString& aZIndex)=0;
+
+  NS_IMETHOD    GetOpacity(nsString& aOpacity)=0;
+  NS_IMETHOD    SetOpacity(const nsString& aOpacity)=0;
+};
+
+
+#define NS_DECL_IDOMCSS2PROPERTIES   \
+  NS_IMETHOD    GetAzimuth(nsString& aAzimuth);  \
+  NS_IMETHOD    SetAzimuth(const nsString& aAzimuth);  \
+  NS_IMETHOD    GetBackground(nsString& aBackground);  \
+  NS_IMETHOD    SetBackground(const nsString& aBackground);  \
+  NS_IMETHOD    GetBackgroundAttachment(nsString& aBackgroundAttachment);  \
+  NS_IMETHOD    SetBackgroundAttachment(const nsString& aBackgroundAttachment);  \
+  NS_IMETHOD    GetBackgroundColor(nsString& aBackgroundColor);  \
+  NS_IMETHOD    SetBackgroundColor(const nsString& aBackgroundColor);  \
+  NS_IMETHOD    GetBackgroundImage(nsString& aBackgroundImage);  \
+  NS_IMETHOD    SetBackgroundImage(const nsString& aBackgroundImage);  \
+  NS_IMETHOD    GetBackgroundPosition(nsString& aBackgroundPosition);  \
+  NS_IMETHOD    SetBackgroundPosition(const nsString& aBackgroundPosition);  \
+  NS_IMETHOD    GetBackgroundRepeat(nsString& aBackgroundRepeat);  \
+  NS_IMETHOD    SetBackgroundRepeat(const nsString& aBackgroundRepeat);  \
+  NS_IMETHOD    GetBorder(nsString& aBorder);  \
+  NS_IMETHOD    SetBorder(const nsString& aBorder);  \
+  NS_IMETHOD    GetBorderCollapse(nsString& aBorderCollapse);  \
+  NS_IMETHOD    SetBorderCollapse(const nsString& aBorderCollapse);  \
+  NS_IMETHOD    GetBorderColor(nsString& aBorderColor);  \
+  NS_IMETHOD    SetBorderColor(const nsString& aBorderColor);  \
+  NS_IMETHOD    GetBorderSpacing(nsString& aBorderSpacing);  \
+  NS_IMETHOD    SetBorderSpacing(const nsString& aBorderSpacing);  \
+  NS_IMETHOD    GetBorderStyle(nsString& aBorderStyle);  \
+  NS_IMETHOD    SetBorderStyle(const nsString& aBorderStyle);  \
+  NS_IMETHOD    GetBorderTop(nsString& aBorderTop);  \
+  NS_IMETHOD    SetBorderTop(const nsString& aBorderTop);  \
+  NS_IMETHOD    GetBorderRight(nsString& aBorderRight);  \
+  NS_IMETHOD    SetBorderRight(const nsString& aBorderRight);  \
+  NS_IMETHOD    GetBorderBottom(nsString& aBorderBottom);  \
+  NS_IMETHOD    SetBorderBottom(const nsString& aBorderBottom);  \
+  NS_IMETHOD    GetBorderLeft(nsString& aBorderLeft);  \
+  NS_IMETHOD    SetBorderLeft(const nsString& aBorderLeft);  \
+  NS_IMETHOD    GetBorderTopColor(nsString& aBorderTopColor);  \
+  NS_IMETHOD    SetBorderTopColor(const nsString& aBorderTopColor);  \
+  NS_IMETHOD    GetBorderRightColor(nsString& aBorderRightColor);  \
+  NS_IMETHOD    SetBorderRightColor(const nsString& aBorderRightColor);  \
+  NS_IMETHOD    GetBorderBottomColor(nsString& aBorderBottomColor);  \
+  NS_IMETHOD    SetBorderBottomColor(const nsString& aBorderBottomColor);  \
+  NS_IMETHOD    GetBorderLeftColor(nsString& aBorderLeftColor);  \
+  NS_IMETHOD    SetBorderLeftColor(const nsString& aBorderLeftColor);  \
+  NS_IMETHOD    GetBorderTopStyle(nsString& aBorderTopStyle);  \
+  NS_IMETHOD    SetBorderTopStyle(const nsString& aBorderTopStyle);  \
+  NS_IMETHOD    GetBorderRightStyle(nsString& aBorderRightStyle);  \
+  NS_IMETHOD    SetBorderRightStyle(const nsString& aBorderRightStyle);  \
+  NS_IMETHOD    GetBorderBottomStyle(nsString& aBorderBottomStyle);  \
+  NS_IMETHOD    SetBorderBottomStyle(const nsString& aBorderBottomStyle);  \
+  NS_IMETHOD    GetBorderLeftStyle(nsString& aBorderLeftStyle);  \
+  NS_IMETHOD    SetBorderLeftStyle(const nsString& aBorderLeftStyle);  \
+  NS_IMETHOD    GetBorderTopWidth(nsString& aBorderTopWidth);  \
+  NS_IMETHOD    SetBorderTopWidth(const nsString& aBorderTopWidth);  \
+  NS_IMETHOD    GetBorderRightWidth(nsString& aBorderRightWidth);  \
+  NS_IMETHOD    SetBorderRightWidth(const nsString& aBorderRightWidth);  \
+  NS_IMETHOD    GetBorderBottomWidth(nsString& aBorderBottomWidth);  \
+  NS_IMETHOD    SetBorderBottomWidth(const nsString& aBorderBottomWidth);  \
+  NS_IMETHOD    GetBorderLeftWidth(nsString& aBorderLeftWidth);  \
+  NS_IMETHOD    SetBorderLeftWidth(const nsString& aBorderLeftWidth);  \
+  NS_IMETHOD    GetBorderWidth(nsString& aBorderWidth);  \
+  NS_IMETHOD    SetBorderWidth(const nsString& aBorderWidth);  \
+  NS_IMETHOD    GetBottom(nsString& aBottom);  \
+  NS_IMETHOD    SetBottom(const nsString& aBottom);  \
+  NS_IMETHOD    GetCaptionSide(nsString& aCaptionSide);  \
+  NS_IMETHOD    SetCaptionSide(const nsString& aCaptionSide);  \
+  NS_IMETHOD    GetClear(nsString& aClear);  \
+  NS_IMETHOD    SetClear(const nsString& aClear);  \
+  NS_IMETHOD    GetClip(nsString& aClip);  \
+  NS_IMETHOD    SetClip(const nsString& aClip);  \
+  NS_IMETHOD    GetColor(nsString& aColor);  \
+  NS_IMETHOD    SetColor(const nsString& aColor);  \
+  NS_IMETHOD    GetContent(nsString& aContent);  \
+  NS_IMETHOD    SetContent(const nsString& aContent);  \
+  NS_IMETHOD    GetCounterIncrement(nsString& aCounterIncrement);  \
+  NS_IMETHOD    SetCounterIncrement(const nsString& aCounterIncrement);  \
+  NS_IMETHOD    GetCounterReset(nsString& aCounterReset);  \
+  NS_IMETHOD    SetCounterReset(const nsString& aCounterReset);  \
+  NS_IMETHOD    GetCue(nsString& aCue);  \
+  NS_IMETHOD    SetCue(const nsString& aCue);  \
+  NS_IMETHOD    GetCueAfter(nsString& aCueAfter);  \
+  NS_IMETHOD    SetCueAfter(const nsString& aCueAfter);  \
+  NS_IMETHOD    GetCueBefore(nsString& aCueBefore);  \
+  NS_IMETHOD    SetCueBefore(const nsString& aCueBefore);  \
+  NS_IMETHOD    GetCursor(nsString& aCursor);  \
+  NS_IMETHOD    SetCursor(const nsString& aCursor);  \
+  NS_IMETHOD    GetDirection(nsString& aDirection);  \
+  NS_IMETHOD    SetDirection(const nsString& aDirection);  \
+  NS_IMETHOD    GetDisplay(nsString& aDisplay);  \
+  NS_IMETHOD    SetDisplay(const nsString& aDisplay);  \
+  NS_IMETHOD    GetElevation(nsString& aElevation);  \
+  NS_IMETHOD    SetElevation(const nsString& aElevation);  \
+  NS_IMETHOD    GetEmptyCells(nsString& aEmptyCells);  \
+  NS_IMETHOD    SetEmptyCells(const nsString& aEmptyCells);  \
+  NS_IMETHOD    GetCssFloat(nsString& aCssFloat);  \
+  NS_IMETHOD    SetCssFloat(const nsString& aCssFloat);  \
+  NS_IMETHOD    GetFont(nsString& aFont);  \
+  NS_IMETHOD    SetFont(const nsString& aFont);  \
+  NS_IMETHOD    GetFontFamily(nsString& aFontFamily);  \
+  NS_IMETHOD    SetFontFamily(const nsString& aFontFamily);  \
+  NS_IMETHOD    GetFontSize(nsString& aFontSize);  \
+  NS_IMETHOD    SetFontSize(const nsString& aFontSize);  \
+  NS_IMETHOD    GetFontSizeAdjust(nsString& aFontSizeAdjust);  \
+  NS_IMETHOD    SetFontSizeAdjust(const nsString& aFontSizeAdjust);  \
+  NS_IMETHOD    GetFontStretch(nsString& aFontStretch);  \
+  NS_IMETHOD    SetFontStretch(const nsString& aFontStretch);  \
+  NS_IMETHOD    GetFontStyle(nsString& aFontStyle);  \
+  NS_IMETHOD    SetFontStyle(const nsString& aFontStyle);  \
+  NS_IMETHOD    GetFontVariant(nsString& aFontVariant);  \
+  NS_IMETHOD    SetFontVariant(const nsString& aFontVariant);  \
+  NS_IMETHOD    GetFontWeight(nsString& aFontWeight);  \
+  NS_IMETHOD    SetFontWeight(const nsString& aFontWeight);  \
+  NS_IMETHOD    GetHeight(nsString& aHeight);  \
+  NS_IMETHOD    SetHeight(const nsString& aHeight);  \
+  NS_IMETHOD    GetLeft(nsString& aLeft);  \
+  NS_IMETHOD    SetLeft(const nsString& aLeft);  \
+  NS_IMETHOD    GetLetterSpacing(nsString& aLetterSpacing);  \
+  NS_IMETHOD    SetLetterSpacing(const nsString& aLetterSpacing);  \
+  NS_IMETHOD    GetLineHeight(nsString& aLineHeight);  \
+  NS_IMETHOD    SetLineHeight(const nsString& aLineHeight);  \
+  NS_IMETHOD    GetListStyle(nsString& aListStyle);  \
+  NS_IMETHOD    SetListStyle(const nsString& aListStyle);  \
+  NS_IMETHOD    GetListStyleImage(nsString& aListStyleImage);  \
+  NS_IMETHOD    SetListStyleImage(const nsString& aListStyleImage);  \
+  NS_IMETHOD    GetListStylePosition(nsString& aListStylePosition);  \
+  NS_IMETHOD    SetListStylePosition(const nsString& aListStylePosition);  \
+  NS_IMETHOD    GetListStyleType(nsString& aListStyleType);  \
+  NS_IMETHOD    SetListStyleType(const nsString& aListStyleType);  \
+  NS_IMETHOD    GetMargin(nsString& aMargin);  \
+  NS_IMETHOD    SetMargin(const nsString& aMargin);  \
+  NS_IMETHOD    GetMarginTop(nsString& aMarginTop);  \
+  NS_IMETHOD    SetMarginTop(const nsString& aMarginTop);  \
+  NS_IMETHOD    GetMarginRight(nsString& aMarginRight);  \
+  NS_IMETHOD    SetMarginRight(const nsString& aMarginRight);  \
+  NS_IMETHOD    GetMarginBottom(nsString& aMarginBottom);  \
+  NS_IMETHOD    SetMarginBottom(const nsString& aMarginBottom);  \
+  NS_IMETHOD    GetMarginLeft(nsString& aMarginLeft);  \
+  NS_IMETHOD    SetMarginLeft(const nsString& aMarginLeft);  \
+  NS_IMETHOD    GetMarkerOffset(nsString& aMarkerOffset);  \
+  NS_IMETHOD    SetMarkerOffset(const nsString& aMarkerOffset);  \
+  NS_IMETHOD    GetMarks(nsString& aMarks);  \
+  NS_IMETHOD    SetMarks(const nsString& aMarks);  \
+  NS_IMETHOD    GetMaxHeight(nsString& aMaxHeight);  \
+  NS_IMETHOD    SetMaxHeight(const nsString& aMaxHeight);  \
+  NS_IMETHOD    GetMaxWidth(nsString& aMaxWidth);  \
+  NS_IMETHOD    SetMaxWidth(const nsString& aMaxWidth);  \
+  NS_IMETHOD    GetMinHeight(nsString& aMinHeight);  \
+  NS_IMETHOD    SetMinHeight(const nsString& aMinHeight);  \
+  NS_IMETHOD    GetMinWidth(nsString& aMinWidth);  \
+  NS_IMETHOD    SetMinWidth(const nsString& aMinWidth);  \
+  NS_IMETHOD    GetOrphans(nsString& aOrphans);  \
+  NS_IMETHOD    SetOrphans(const nsString& aOrphans);  \
+  NS_IMETHOD    GetOutline(nsString& aOutline);  \
+  NS_IMETHOD    SetOutline(const nsString& aOutline);  \
+  NS_IMETHOD    GetOutlineColor(nsString& aOutlineColor);  \
+  NS_IMETHOD    SetOutlineColor(const nsString& aOutlineColor);  \
+  NS_IMETHOD    GetOutlineStyle(nsString& aOutlineStyle);  \
+  NS_IMETHOD    SetOutlineStyle(const nsString& aOutlineStyle);  \
+  NS_IMETHOD    GetOutlineWidth(nsString& aOutlineWidth);  \
+  NS_IMETHOD    SetOutlineWidth(const nsString& aOutlineWidth);  \
+  NS_IMETHOD    GetOverflow(nsString& aOverflow);  \
+  NS_IMETHOD    SetOverflow(const nsString& aOverflow);  \
+  NS_IMETHOD    GetPadding(nsString& aPadding);  \
+  NS_IMETHOD    SetPadding(const nsString& aPadding);  \
+  NS_IMETHOD    GetPaddingTop(nsString& aPaddingTop);  \
+  NS_IMETHOD    SetPaddingTop(const nsString& aPaddingTop);  \
+  NS_IMETHOD    GetPaddingRight(nsString& aPaddingRight);  \
+  NS_IMETHOD    SetPaddingRight(const nsString& aPaddingRight);  \
+  NS_IMETHOD    GetPaddingBottom(nsString& aPaddingBottom);  \
+  NS_IMETHOD    SetPaddingBottom(const nsString& aPaddingBottom);  \
+  NS_IMETHOD    GetPaddingLeft(nsString& aPaddingLeft);  \
+  NS_IMETHOD    SetPaddingLeft(const nsString& aPaddingLeft);  \
+  NS_IMETHOD    GetPage(nsString& aPage);  \
+  NS_IMETHOD    SetPage(const nsString& aPage);  \
+  NS_IMETHOD    GetPageBreakAfter(nsString& aPageBreakAfter);  \
+  NS_IMETHOD    SetPageBreakAfter(const nsString& aPageBreakAfter);  \
+  NS_IMETHOD    GetPageBreakBefore(nsString& aPageBreakBefore);  \
+  NS_IMETHOD    SetPageBreakBefore(const nsString& aPageBreakBefore);  \
+  NS_IMETHOD    GetPageBreakInside(nsString& aPageBreakInside);  \
+  NS_IMETHOD    SetPageBreakInside(const nsString& aPageBreakInside);  \
+  NS_IMETHOD    GetPause(nsString& aPause);  \
+  NS_IMETHOD    SetPause(const nsString& aPause);  \
+  NS_IMETHOD    GetPauseAfter(nsString& aPauseAfter);  \
+  NS_IMETHOD    SetPauseAfter(const nsString& aPauseAfter);  \
+  NS_IMETHOD    GetPauseBefore(nsString& aPauseBefore);  \
+  NS_IMETHOD    SetPauseBefore(const nsString& aPauseBefore);  \
+  NS_IMETHOD    GetPitch(nsString& aPitch);  \
+  NS_IMETHOD    SetPitch(const nsString& aPitch);  \
+  NS_IMETHOD    GetPitchRange(nsString& aPitchRange);  \
+  NS_IMETHOD    SetPitchRange(const nsString& aPitchRange);  \
+  NS_IMETHOD    GetPlayDuring(nsString& aPlayDuring);  \
+  NS_IMETHOD    SetPlayDuring(const nsString& aPlayDuring);  \
+  NS_IMETHOD    GetPosition(nsString& aPosition);  \
+  NS_IMETHOD    SetPosition(const nsString& aPosition);  \
+  NS_IMETHOD    GetQuotes(nsString& aQuotes);  \
+  NS_IMETHOD    SetQuotes(const nsString& aQuotes);  \
+  NS_IMETHOD    GetRichness(nsString& aRichness);  \
+  NS_IMETHOD    SetRichness(const nsString& aRichness);  \
+  NS_IMETHOD    GetRight(nsString& aRight);  \
+  NS_IMETHOD    SetRight(const nsString& aRight);  \
+  NS_IMETHOD    GetSize(nsString& aSize);  \
+  NS_IMETHOD    SetSize(const nsString& aSize);  \
+  NS_IMETHOD    GetSpeak(nsString& aSpeak);  \
+  NS_IMETHOD    SetSpeak(const nsString& aSpeak);  \
+  NS_IMETHOD    GetSpeakHeader(nsString& aSpeakHeader);  \
+  NS_IMETHOD    SetSpeakHeader(const nsString& aSpeakHeader);  \
+  NS_IMETHOD    GetSpeakNumeral(nsString& aSpeakNumeral);  \
+  NS_IMETHOD    SetSpeakNumeral(const nsString& aSpeakNumeral);  \
+  NS_IMETHOD    GetSpeakPunctuation(nsString& aSpeakPunctuation);  \
+  NS_IMETHOD    SetSpeakPunctuation(const nsString& aSpeakPunctuation);  \
+  NS_IMETHOD    GetSpeechRate(nsString& aSpeechRate);  \
+  NS_IMETHOD    SetSpeechRate(const nsString& aSpeechRate);  \
+  NS_IMETHOD    GetStress(nsString& aStress);  \
+  NS_IMETHOD    SetStress(const nsString& aStress);  \
+  NS_IMETHOD    GetTableLayout(nsString& aTableLayout);  \
+  NS_IMETHOD    SetTableLayout(const nsString& aTableLayout);  \
+  NS_IMETHOD    GetTextAlign(nsString& aTextAlign);  \
+  NS_IMETHOD    SetTextAlign(const nsString& aTextAlign);  \
+  NS_IMETHOD    GetTextDecoration(nsString& aTextDecoration);  \
+  NS_IMETHOD    SetTextDecoration(const nsString& aTextDecoration);  \
+  NS_IMETHOD    GetTextIndent(nsString& aTextIndent);  \
+  NS_IMETHOD    SetTextIndent(const nsString& aTextIndent);  \
+  NS_IMETHOD    GetTextShadow(nsString& aTextShadow);  \
+  NS_IMETHOD    SetTextShadow(const nsString& aTextShadow);  \
+  NS_IMETHOD    GetTextTransform(nsString& aTextTransform);  \
+  NS_IMETHOD    SetTextTransform(const nsString& aTextTransform);  \
+  NS_IMETHOD    GetTop(nsString& aTop);  \
+  NS_IMETHOD    SetTop(const nsString& aTop);  \
+  NS_IMETHOD    GetUnicodeBidi(nsString& aUnicodeBidi);  \
+  NS_IMETHOD    SetUnicodeBidi(const nsString& aUnicodeBidi);  \
+  NS_IMETHOD    GetVerticalAlign(nsString& aVerticalAlign);  \
+  NS_IMETHOD    SetVerticalAlign(const nsString& aVerticalAlign);  \
+  NS_IMETHOD    GetVisibility(nsString& aVisibility);  \
+  NS_IMETHOD    SetVisibility(const nsString& aVisibility);  \
+  NS_IMETHOD    GetVoiceFamily(nsString& aVoiceFamily);  \
+  NS_IMETHOD    SetVoiceFamily(const nsString& aVoiceFamily);  \
+  NS_IMETHOD    GetVolume(nsString& aVolume);  \
+  NS_IMETHOD    SetVolume(const nsString& aVolume);  \
+  NS_IMETHOD    GetWhiteSpace(nsString& aWhiteSpace);  \
+  NS_IMETHOD    SetWhiteSpace(const nsString& aWhiteSpace);  \
+  NS_IMETHOD    GetWidows(nsString& aWidows);  \
+  NS_IMETHOD    SetWidows(const nsString& aWidows);  \
+  NS_IMETHOD    GetWidth(nsString& aWidth);  \
+  NS_IMETHOD    SetWidth(const nsString& aWidth);  \
+  NS_IMETHOD    GetWordSpacing(nsString& aWordSpacing);  \
+  NS_IMETHOD    SetWordSpacing(const nsString& aWordSpacing);  \
+  NS_IMETHOD    GetZIndex(nsString& aZIndex);  \
+  NS_IMETHOD    SetZIndex(const nsString& aZIndex);  \
+  NS_IMETHOD    GetOpacity(nsString& aOpacity);  \
+  NS_IMETHOD    SetOpacity(const nsString& aOpacity);  \
+
+
+
+#define NS_FORWARD_IDOMCSS2PROPERTIES(_to)  \
+  NS_IMETHOD    GetAzimuth(nsString& aAzimuth) { return _to GetAzimuth(aAzimuth); } \
+  NS_IMETHOD    SetAzimuth(const nsString& aAzimuth) { return _to SetAzimuth(aAzimuth); } \
+  NS_IMETHOD    GetBackground(nsString& aBackground) { return _to GetBackground(aBackground); } \
+  NS_IMETHOD    SetBackground(const nsString& aBackground) { return _to SetBackground(aBackground); } \
+  NS_IMETHOD    GetBackgroundAttachment(nsString& aBackgroundAttachment) { return _to GetBackgroundAttachment(aBackgroundAttachment); } \
+  NS_IMETHOD    SetBackgroundAttachment(const nsString& aBackgroundAttachment) { return _to SetBackgroundAttachment(aBackgroundAttachment); } \
+  NS_IMETHOD    GetBackgroundColor(nsString& aBackgroundColor) { return _to GetBackgroundColor(aBackgroundColor); } \
+  NS_IMETHOD    SetBackgroundColor(const nsString& aBackgroundColor) { return _to SetBackgroundColor(aBackgroundColor); } \
+  NS_IMETHOD    GetBackgroundImage(nsString& aBackgroundImage) { return _to GetBackgroundImage(aBackgroundImage); } \
+  NS_IMETHOD    SetBackgroundImage(const nsString& aBackgroundImage) { return _to SetBackgroundImage(aBackgroundImage); } \
+  NS_IMETHOD    GetBackgroundPosition(nsString& aBackgroundPosition) { return _to GetBackgroundPosition(aBackgroundPosition); } \
+  NS_IMETHOD    SetBackgroundPosition(const nsString& aBackgroundPosition) { return _to SetBackgroundPosition(aBackgroundPosition); } \
+  NS_IMETHOD    GetBackgroundRepeat(nsString& aBackgroundRepeat) { return _to GetBackgroundRepeat(aBackgroundRepeat); } \
+  NS_IMETHOD    SetBackgroundRepeat(const nsString& aBackgroundRepeat) { return _to SetBackgroundRepeat(aBackgroundRepeat); } \
+  NS_IMETHOD    GetBorder(nsString& aBorder) { return _to GetBorder(aBorder); } \
+  NS_IMETHOD    SetBorder(const nsString& aBorder) { return _to SetBorder(aBorder); } \
+  NS_IMETHOD    GetBorderCollapse(nsString& aBorderCollapse) { return _to GetBorderCollapse(aBorderCollapse); } \
+  NS_IMETHOD    SetBorderCollapse(const nsString& aBorderCollapse) { return _to SetBorderCollapse(aBorderCollapse); } \
+  NS_IMETHOD    GetBorderColor(nsString& aBorderColor) { return _to GetBorderColor(aBorderColor); } \
+  NS_IMETHOD    SetBorderColor(const nsString& aBorderColor) { return _to SetBorderColor(aBorderColor); } \
+  NS_IMETHOD    GetBorderSpacing(nsString& aBorderSpacing) { return _to GetBorderSpacing(aBorderSpacing); } \
+  NS_IMETHOD    SetBorderSpacing(const nsString& aBorderSpacing) { return _to SetBorderSpacing(aBorderSpacing); } \
+  NS_IMETHOD    GetBorderStyle(nsString& aBorderStyle) { return _to GetBorderStyle(aBorderStyle); } \
+  NS_IMETHOD    SetBorderStyle(const nsString& aBorderStyle) { return _to SetBorderStyle(aBorderStyle); } \
+  NS_IMETHOD    GetBorderTop(nsString& aBorderTop) { return _to GetBorderTop(aBorderTop); } \
+  NS_IMETHOD    SetBorderTop(const nsString& aBorderTop) { return _to SetBorderTop(aBorderTop); } \
+  NS_IMETHOD    GetBorderRight(nsString& aBorderRight) { return _to GetBorderRight(aBorderRight); } \
+  NS_IMETHOD    SetBorderRight(const nsString& aBorderRight) { return _to SetBorderRight(aBorderRight); } \
+  NS_IMETHOD    GetBorderBottom(nsString& aBorderBottom) { return _to GetBorderBottom(aBorderBottom); } \
+  NS_IMETHOD    SetBorderBottom(const nsString& aBorderBottom) { return _to SetBorderBottom(aBorderBottom); } \
+  NS_IMETHOD    GetBorderLeft(nsString& aBorderLeft) { return _to GetBorderLeft(aBorderLeft); } \
+  NS_IMETHOD    SetBorderLeft(const nsString& aBorderLeft) { return _to SetBorderLeft(aBorderLeft); } \
+  NS_IMETHOD    GetBorderTopColor(nsString& aBorderTopColor) { return _to GetBorderTopColor(aBorderTopColor); } \
+  NS_IMETHOD    SetBorderTopColor(const nsString& aBorderTopColor) { return _to SetBorderTopColor(aBorderTopColor); } \
+  NS_IMETHOD    GetBorderRightColor(nsString& aBorderRightColor) { return _to GetBorderRightColor(aBorderRightColor); } \
+  NS_IMETHOD    SetBorderRightColor(const nsString& aBorderRightColor) { return _to SetBorderRightColor(aBorderRightColor); } \
+  NS_IMETHOD    GetBorderBottomColor(nsString& aBorderBottomColor) { return _to GetBorderBottomColor(aBorderBottomColor); } \
+  NS_IMETHOD    SetBorderBottomColor(const nsString& aBorderBottomColor) { return _to SetBorderBottomColor(aBorderBottomColor); } \
+  NS_IMETHOD    GetBorderLeftColor(nsString& aBorderLeftColor) { return _to GetBorderLeftColor(aBorderLeftColor); } \
+  NS_IMETHOD    SetBorderLeftColor(const nsString& aBorderLeftColor) { return _to SetBorderLeftColor(aBorderLeftColor); } \
+  NS_IMETHOD    GetBorderTopStyle(nsString& aBorderTopStyle) { return _to GetBorderTopStyle(aBorderTopStyle); } \
+  NS_IMETHOD    SetBorderTopStyle(const nsString& aBorderTopStyle) { return _to SetBorderTopStyle(aBorderTopStyle); } \
+  NS_IMETHOD    GetBorderRightStyle(nsString& aBorderRightStyle) { return _to GetBorderRightStyle(aBorderRightStyle); } \
+  NS_IMETHOD    SetBorderRightStyle(const nsString& aBorderRightStyle) { return _to SetBorderRightStyle(aBorderRightStyle); } \
+  NS_IMETHOD    GetBorderBottomStyle(nsString& aBorderBottomStyle) { return _to GetBorderBottomStyle(aBorderBottomStyle); } \
+  NS_IMETHOD    SetBorderBottomStyle(const nsString& aBorderBottomStyle) { return _to SetBorderBottomStyle(aBorderBottomStyle); } \
+  NS_IMETHOD    GetBorderLeftStyle(nsString& aBorderLeftStyle) { return _to GetBorderLeftStyle(aBorderLeftStyle); } \
+  NS_IMETHOD    SetBorderLeftStyle(const nsString& aBorderLeftStyle) { return _to SetBorderLeftStyle(aBorderLeftStyle); } \
+  NS_IMETHOD    GetBorderTopWidth(nsString& aBorderTopWidth) { return _to GetBorderTopWidth(aBorderTopWidth); } \
+  NS_IMETHOD    SetBorderTopWidth(const nsString& aBorderTopWidth) { return _to SetBorderTopWidth(aBorderTopWidth); } \
+  NS_IMETHOD    GetBorderRightWidth(nsString& aBorderRightWidth) { return _to GetBorderRightWidth(aBorderRightWidth); } \
+  NS_IMETHOD    SetBorderRightWidth(const nsString& aBorderRightWidth) { return _to SetBorderRightWidth(aBorderRightWidth); } \
+  NS_IMETHOD    GetBorderBottomWidth(nsString& aBorderBottomWidth) { return _to GetBorderBottomWidth(aBorderBottomWidth); } \
+  NS_IMETHOD    SetBorderBottomWidth(const nsString& aBorderBottomWidth) { return _to SetBorderBottomWidth(aBorderBottomWidth); } \
+  NS_IMETHOD    GetBorderLeftWidth(nsString& aBorderLeftWidth) { return _to GetBorderLeftWidth(aBorderLeftWidth); } \
+  NS_IMETHOD    SetBorderLeftWidth(const nsString& aBorderLeftWidth) { return _to SetBorderLeftWidth(aBorderLeftWidth); } \
+  NS_IMETHOD    GetBorderWidth(nsString& aBorderWidth) { return _to GetBorderWidth(aBorderWidth); } \
+  NS_IMETHOD    SetBorderWidth(const nsString& aBorderWidth) { return _to SetBorderWidth(aBorderWidth); } \
+  NS_IMETHOD    GetBottom(nsString& aBottom) { return _to GetBottom(aBottom); } \
+  NS_IMETHOD    SetBottom(const nsString& aBottom) { return _to SetBottom(aBottom); } \
+  NS_IMETHOD    GetCaptionSide(nsString& aCaptionSide) { return _to GetCaptionSide(aCaptionSide); } \
+  NS_IMETHOD    SetCaptionSide(const nsString& aCaptionSide) { return _to SetCaptionSide(aCaptionSide); } \
+  NS_IMETHOD    GetClear(nsString& aClear) { return _to GetClear(aClear); } \
+  NS_IMETHOD    SetClear(const nsString& aClear) { return _to SetClear(aClear); } \
+  NS_IMETHOD    GetClip(nsString& aClip) { return _to GetClip(aClip); } \
+  NS_IMETHOD    SetClip(const nsString& aClip) { return _to SetClip(aClip); } \
+  NS_IMETHOD    GetColor(nsString& aColor) { return _to GetColor(aColor); } \
+  NS_IMETHOD    SetColor(const nsString& aColor) { return _to SetColor(aColor); } \
+  NS_IMETHOD    GetContent(nsString& aContent) { return _to GetContent(aContent); } \
+  NS_IMETHOD    SetContent(const nsString& aContent) { return _to SetContent(aContent); } \
+  NS_IMETHOD    GetCounterIncrement(nsString& aCounterIncrement) { return _to GetCounterIncrement(aCounterIncrement); } \
+  NS_IMETHOD    SetCounterIncrement(const nsString& aCounterIncrement) { return _to SetCounterIncrement(aCounterIncrement); } \
+  NS_IMETHOD    GetCounterReset(nsString& aCounterReset) { return _to GetCounterReset(aCounterReset); } \
+  NS_IMETHOD    SetCounterReset(const nsString& aCounterReset) { return _to SetCounterReset(aCounterReset); } \
+  NS_IMETHOD    GetCue(nsString& aCue) { return _to GetCue(aCue); } \
+  NS_IMETHOD    SetCue(const nsString& aCue) { return _to SetCue(aCue); } \
+  NS_IMETHOD    GetCueAfter(nsString& aCueAfter) { return _to GetCueAfter(aCueAfter); } \
+  NS_IMETHOD    SetCueAfter(const nsString& aCueAfter) { return _to SetCueAfter(aCueAfter); } \
+  NS_IMETHOD    GetCueBefore(nsString& aCueBefore) { return _to GetCueBefore(aCueBefore); } \
+  NS_IMETHOD    SetCueBefore(const nsString& aCueBefore) { return _to SetCueBefore(aCueBefore); } \
+  NS_IMETHOD    GetCursor(nsString& aCursor) { return _to GetCursor(aCursor); } \
+  NS_IMETHOD    SetCursor(const nsString& aCursor) { return _to SetCursor(aCursor); } \
+  NS_IMETHOD    GetDirection(nsString& aDirection) { return _to GetDirection(aDirection); } \
+  NS_IMETHOD    SetDirection(const nsString& aDirection) { return _to SetDirection(aDirection); } \
+  NS_IMETHOD    GetDisplay(nsString& aDisplay) { return _to GetDisplay(aDisplay); } \
+  NS_IMETHOD    SetDisplay(const nsString& aDisplay) { return _to SetDisplay(aDisplay); } \
+  NS_IMETHOD    GetElevation(nsString& aElevation) { return _to GetElevation(aElevation); } \
+  NS_IMETHOD    SetElevation(const nsString& aElevation) { return _to SetElevation(aElevation); } \
+  NS_IMETHOD    GetEmptyCells(nsString& aEmptyCells) { return _to GetEmptyCells(aEmptyCells); } \
+  NS_IMETHOD    SetEmptyCells(const nsString& aEmptyCells) { return _to SetEmptyCells(aEmptyCells); } \
+  NS_IMETHOD    GetCssFloat(nsString& aCssFloat) { return _to GetCssFloat(aCssFloat); } \
+  NS_IMETHOD    SetCssFloat(const nsString& aCssFloat) { return _to SetCssFloat(aCssFloat); } \
+  NS_IMETHOD    GetFont(nsString& aFont) { return _to GetFont(aFont); } \
+  NS_IMETHOD    SetFont(const nsString& aFont) { return _to SetFont(aFont); } \
+  NS_IMETHOD    GetFontFamily(nsString& aFontFamily) { return _to GetFontFamily(aFontFamily); } \
+  NS_IMETHOD    SetFontFamily(const nsString& aFontFamily) { return _to SetFontFamily(aFontFamily); } \
+  NS_IMETHOD    GetFontSize(nsString& aFontSize) { return _to GetFontSize(aFontSize); } \
+  NS_IMETHOD    SetFontSize(const nsString& aFontSize) { return _to SetFontSize(aFontSize); } \
+  NS_IMETHOD    GetFontSizeAdjust(nsString& aFontSizeAdjust) { return _to GetFontSizeAdjust(aFontSizeAdjust); } \
+  NS_IMETHOD    SetFontSizeAdjust(const nsString& aFontSizeAdjust) { return _to SetFontSizeAdjust(aFontSizeAdjust); } \
+  NS_IMETHOD    GetFontStretch(nsString& aFontStretch) { return _to GetFontStretch(aFontStretch); } \
+  NS_IMETHOD    SetFontStretch(const nsString& aFontStretch) { return _to SetFontStretch(aFontStretch); } \
+  NS_IMETHOD    GetFontStyle(nsString& aFontStyle) { return _to GetFontStyle(aFontStyle); } \
+  NS_IMETHOD    SetFontStyle(const nsString& aFontStyle) { return _to SetFontStyle(aFontStyle); } \
+  NS_IMETHOD    GetFontVariant(nsString& aFontVariant) { return _to GetFontVariant(aFontVariant); } \
+  NS_IMETHOD    SetFontVariant(const nsString& aFontVariant) { return _to SetFontVariant(aFontVariant); } \
+  NS_IMETHOD    GetFontWeight(nsString& aFontWeight) { return _to GetFontWeight(aFontWeight); } \
+  NS_IMETHOD    SetFontWeight(const nsString& aFontWeight) { return _to SetFontWeight(aFontWeight); } \
+  NS_IMETHOD    GetHeight(nsString& aHeight) { return _to GetHeight(aHeight); } \
+  NS_IMETHOD    SetHeight(const nsString& aHeight) { return _to SetHeight(aHeight); } \
+  NS_IMETHOD    GetLeft(nsString& aLeft) { return _to GetLeft(aLeft); } \
+  NS_IMETHOD    SetLeft(const nsString& aLeft) { return _to SetLeft(aLeft); } \
+  NS_IMETHOD    GetLetterSpacing(nsString& aLetterSpacing) { return _to GetLetterSpacing(aLetterSpacing); } \
+  NS_IMETHOD    SetLetterSpacing(const nsString& aLetterSpacing) { return _to SetLetterSpacing(aLetterSpacing); } \
+  NS_IMETHOD    GetLineHeight(nsString& aLineHeight) { return _to GetLineHeight(aLineHeight); } \
+  NS_IMETHOD    SetLineHeight(const nsString& aLineHeight) { return _to SetLineHeight(aLineHeight); } \
+  NS_IMETHOD    GetListStyle(nsString& aListStyle) { return _to GetListStyle(aListStyle); } \
+  NS_IMETHOD    SetListStyle(const nsString& aListStyle) { return _to SetListStyle(aListStyle); } \
+  NS_IMETHOD    GetListStyleImage(nsString& aListStyleImage) { return _to GetListStyleImage(aListStyleImage); } \
+  NS_IMETHOD    SetListStyleImage(const nsString& aListStyleImage) { return _to SetListStyleImage(aListStyleImage); } \
+  NS_IMETHOD    GetListStylePosition(nsString& aListStylePosition) { return _to GetListStylePosition(aListStylePosition); } \
+  NS_IMETHOD    SetListStylePosition(const nsString& aListStylePosition) { return _to SetListStylePosition(aListStylePosition); } \
+  NS_IMETHOD    GetListStyleType(nsString& aListStyleType) { return _to GetListStyleType(aListStyleType); } \
+  NS_IMETHOD    SetListStyleType(const nsString& aListStyleType) { return _to SetListStyleType(aListStyleType); } \
+  NS_IMETHOD    GetMargin(nsString& aMargin) { return _to GetMargin(aMargin); } \
+  NS_IMETHOD    SetMargin(const nsString& aMargin) { return _to SetMargin(aMargin); } \
+  NS_IMETHOD    GetMarginTop(nsString& aMarginTop) { return _to GetMarginTop(aMarginTop); } \
+  NS_IMETHOD    SetMarginTop(const nsString& aMarginTop) { return _to SetMarginTop(aMarginTop); } \
+  NS_IMETHOD    GetMarginRight(nsString& aMarginRight) { return _to GetMarginRight(aMarginRight); } \
+  NS_IMETHOD    SetMarginRight(const nsString& aMarginRight) { return _to SetMarginRight(aMarginRight); } \
+  NS_IMETHOD    GetMarginBottom(nsString& aMarginBottom) { return _to GetMarginBottom(aMarginBottom); } \
+  NS_IMETHOD    SetMarginBottom(const nsString& aMarginBottom) { return _to SetMarginBottom(aMarginBottom); } \
+  NS_IMETHOD    GetMarginLeft(nsString& aMarginLeft) { return _to GetMarginLeft(aMarginLeft); } \
+  NS_IMETHOD    SetMarginLeft(const nsString& aMarginLeft) { return _to SetMarginLeft(aMarginLeft); } \
+  NS_IMETHOD    GetMarkerOffset(nsString& aMarkerOffset) { return _to GetMarkerOffset(aMarkerOffset); } \
+  NS_IMETHOD    SetMarkerOffset(const nsString& aMarkerOffset) { return _to SetMarkerOffset(aMarkerOffset); } \
+  NS_IMETHOD    GetMarks(nsString& aMarks) { return _to GetMarks(aMarks); } \
+  NS_IMETHOD    SetMarks(const nsString& aMarks) { return _to SetMarks(aMarks); } \
+  NS_IMETHOD    GetMaxHeight(nsString& aMaxHeight) { return _to GetMaxHeight(aMaxHeight); } \
+  NS_IMETHOD    SetMaxHeight(const nsString& aMaxHeight) { return _to SetMaxHeight(aMaxHeight); } \
+  NS_IMETHOD    GetMaxWidth(nsString& aMaxWidth) { return _to GetMaxWidth(aMaxWidth); } \
+  NS_IMETHOD    SetMaxWidth(const nsString& aMaxWidth) { return _to SetMaxWidth(aMaxWidth); } \
+  NS_IMETHOD    GetMinHeight(nsString& aMinHeight) { return _to GetMinHeight(aMinHeight); } \
+  NS_IMETHOD    SetMinHeight(const nsString& aMinHeight) { return _to SetMinHeight(aMinHeight); } \
+  NS_IMETHOD    GetMinWidth(nsString& aMinWidth) { return _to GetMinWidth(aMinWidth); } \
+  NS_IMETHOD    SetMinWidth(const nsString& aMinWidth) { return _to SetMinWidth(aMinWidth); } \
+  NS_IMETHOD    GetOrphans(nsString& aOrphans) { return _to GetOrphans(aOrphans); } \
+  NS_IMETHOD    SetOrphans(const nsString& aOrphans) { return _to SetOrphans(aOrphans); } \
+  NS_IMETHOD    GetOutline(nsString& aOutline) { return _to GetOutline(aOutline); } \
+  NS_IMETHOD    SetOutline(const nsString& aOutline) { return _to SetOutline(aOutline); } \
+  NS_IMETHOD    GetOutlineColor(nsString& aOutlineColor) { return _to GetOutlineColor(aOutlineColor); } \
+  NS_IMETHOD    SetOutlineColor(const nsString& aOutlineColor) { return _to SetOutlineColor(aOutlineColor); } \
+  NS_IMETHOD    GetOutlineStyle(nsString& aOutlineStyle) { return _to GetOutlineStyle(aOutlineStyle); } \
+  NS_IMETHOD    SetOutlineStyle(const nsString& aOutlineStyle) { return _to SetOutlineStyle(aOutlineStyle); } \
+  NS_IMETHOD    GetOutlineWidth(nsString& aOutlineWidth) { return _to GetOutlineWidth(aOutlineWidth); } \
+  NS_IMETHOD    SetOutlineWidth(const nsString& aOutlineWidth) { return _to SetOutlineWidth(aOutlineWidth); } \
+  NS_IMETHOD    GetOverflow(nsString& aOverflow) { return _to GetOverflow(aOverflow); } \
+  NS_IMETHOD    SetOverflow(const nsString& aOverflow) { return _to SetOverflow(aOverflow); } \
+  NS_IMETHOD    GetPadding(nsString& aPadding) { return _to GetPadding(aPadding); } \
+  NS_IMETHOD    SetPadding(const nsString& aPadding) { return _to SetPadding(aPadding); } \
+  NS_IMETHOD    GetPaddingTop(nsString& aPaddingTop) { return _to GetPaddingTop(aPaddingTop); } \
+  NS_IMETHOD    SetPaddingTop(const nsString& aPaddingTop) { return _to SetPaddingTop(aPaddingTop); } \
+  NS_IMETHOD    GetPaddingRight(nsString& aPaddingRight) { return _to GetPaddingRight(aPaddingRight); } \
+  NS_IMETHOD    SetPaddingRight(const nsString& aPaddingRight) { return _to SetPaddingRight(aPaddingRight); } \
+  NS_IMETHOD    GetPaddingBottom(nsString& aPaddingBottom) { return _to GetPaddingBottom(aPaddingBottom); } \
+  NS_IMETHOD    SetPaddingBottom(const nsString& aPaddingBottom) { return _to SetPaddingBottom(aPaddingBottom); } \
+  NS_IMETHOD    GetPaddingLeft(nsString& aPaddingLeft) { return _to GetPaddingLeft(aPaddingLeft); } \
+  NS_IMETHOD    SetPaddingLeft(const nsString& aPaddingLeft) { return _to SetPaddingLeft(aPaddingLeft); } \
+  NS_IMETHOD    GetPage(nsString& aPage) { return _to GetPage(aPage); } \
+  NS_IMETHOD    SetPage(const nsString& aPage) { return _to SetPage(aPage); } \
+  NS_IMETHOD    GetPageBreakAfter(nsString& aPageBreakAfter) { return _to GetPageBreakAfter(aPageBreakAfter); } \
+  NS_IMETHOD    SetPageBreakAfter(const nsString& aPageBreakAfter) { return _to SetPageBreakAfter(aPageBreakAfter); } \
+  NS_IMETHOD    GetPageBreakBefore(nsString& aPageBreakBefore) { return _to GetPageBreakBefore(aPageBreakBefore); } \
+  NS_IMETHOD    SetPageBreakBefore(const nsString& aPageBreakBefore) { return _to SetPageBreakBefore(aPageBreakBefore); } \
+  NS_IMETHOD    GetPageBreakInside(nsString& aPageBreakInside) { return _to GetPageBreakInside(aPageBreakInside); } \
+  NS_IMETHOD    SetPageBreakInside(const nsString& aPageBreakInside) { return _to SetPageBreakInside(aPageBreakInside); } \
+  NS_IMETHOD    GetPause(nsString& aPause) { return _to GetPause(aPause); } \
+  NS_IMETHOD    SetPause(const nsString& aPause) { return _to SetPause(aPause); } \
+  NS_IMETHOD    GetPauseAfter(nsString& aPauseAfter) { return _to GetPauseAfter(aPauseAfter); } \
+  NS_IMETHOD    SetPauseAfter(const nsString& aPauseAfter) { return _to SetPauseAfter(aPauseAfter); } \
+  NS_IMETHOD    GetPauseBefore(nsString& aPauseBefore) { return _to GetPauseBefore(aPauseBefore); } \
+  NS_IMETHOD    SetPauseBefore(const nsString& aPauseBefore) { return _to SetPauseBefore(aPauseBefore); } \
+  NS_IMETHOD    GetPitch(nsString& aPitch) { return _to GetPitch(aPitch); } \
+  NS_IMETHOD    SetPitch(const nsString& aPitch) { return _to SetPitch(aPitch); } \
+  NS_IMETHOD    GetPitchRange(nsString& aPitchRange) { return _to GetPitchRange(aPitchRange); } \
+  NS_IMETHOD    SetPitchRange(const nsString& aPitchRange) { return _to SetPitchRange(aPitchRange); } \
+  NS_IMETHOD    GetPlayDuring(nsString& aPlayDuring) { return _to GetPlayDuring(aPlayDuring); } \
+  NS_IMETHOD    SetPlayDuring(const nsString& aPlayDuring) { return _to SetPlayDuring(aPlayDuring); } \
+  NS_IMETHOD    GetPosition(nsString& aPosition) { return _to GetPosition(aPosition); } \
+  NS_IMETHOD    SetPosition(const nsString& aPosition) { return _to SetPosition(aPosition); } \
+  NS_IMETHOD    GetQuotes(nsString& aQuotes) { return _to GetQuotes(aQuotes); } \
+  NS_IMETHOD    SetQuotes(const nsString& aQuotes) { return _to SetQuotes(aQuotes); } \
+  NS_IMETHOD    GetRichness(nsString& aRichness) { return _to GetRichness(aRichness); } \
+  NS_IMETHOD    SetRichness(const nsString& aRichness) { return _to SetRichness(aRichness); } \
+  NS_IMETHOD    GetRight(nsString& aRight) { return _to GetRight(aRight); } \
+  NS_IMETHOD    SetRight(const nsString& aRight) { return _to SetRight(aRight); } \
+  NS_IMETHOD    GetSize(nsString& aSize) { return _to GetSize(aSize); } \
+  NS_IMETHOD    SetSize(const nsString& aSize) { return _to SetSize(aSize); } \
+  NS_IMETHOD    GetSpeak(nsString& aSpeak) { return _to GetSpeak(aSpeak); } \
+  NS_IMETHOD    SetSpeak(const nsString& aSpeak) { return _to SetSpeak(aSpeak); } \
+  NS_IMETHOD    GetSpeakHeader(nsString& aSpeakHeader) { return _to GetSpeakHeader(aSpeakHeader); } \
+  NS_IMETHOD    SetSpeakHeader(const nsString& aSpeakHeader) { return _to SetSpeakHeader(aSpeakHeader); } \
+  NS_IMETHOD    GetSpeakNumeral(nsString& aSpeakNumeral) { return _to GetSpeakNumeral(aSpeakNumeral); } \
+  NS_IMETHOD    SetSpeakNumeral(const nsString& aSpeakNumeral) { return _to SetSpeakNumeral(aSpeakNumeral); } \
+  NS_IMETHOD    GetSpeakPunctuation(nsString& aSpeakPunctuation) { return _to GetSpeakPunctuation(aSpeakPunctuation); } \
+  NS_IMETHOD    SetSpeakPunctuation(const nsString& aSpeakPunctuation) { return _to SetSpeakPunctuation(aSpeakPunctuation); } \
+  NS_IMETHOD    GetSpeechRate(nsString& aSpeechRate) { return _to GetSpeechRate(aSpeechRate); } \
+  NS_IMETHOD    SetSpeechRate(const nsString& aSpeechRate) { return _to SetSpeechRate(aSpeechRate); } \
+  NS_IMETHOD    GetStress(nsString& aStress) { return _to GetStress(aStress); } \
+  NS_IMETHOD    SetStress(const nsString& aStress) { return _to SetStress(aStress); } \
+  NS_IMETHOD    GetTableLayout(nsString& aTableLayout) { return _to GetTableLayout(aTableLayout); } \
+  NS_IMETHOD    SetTableLayout(const nsString& aTableLayout) { return _to SetTableLayout(aTableLayout); } \
+  NS_IMETHOD    GetTextAlign(nsString& aTextAlign) { return _to GetTextAlign(aTextAlign); } \
+  NS_IMETHOD    SetTextAlign(const nsString& aTextAlign) { return _to SetTextAlign(aTextAlign); } \
+  NS_IMETHOD    GetTextDecoration(nsString& aTextDecoration) { return _to GetTextDecoration(aTextDecoration); } \
+  NS_IMETHOD    SetTextDecoration(const nsString& aTextDecoration) { return _to SetTextDecoration(aTextDecoration); } \
+  NS_IMETHOD    GetTextIndent(nsString& aTextIndent) { return _to GetTextIndent(aTextIndent); } \
+  NS_IMETHOD    SetTextIndent(const nsString& aTextIndent) { return _to SetTextIndent(aTextIndent); } \
+  NS_IMETHOD    GetTextShadow(nsString& aTextShadow) { return _to GetTextShadow(aTextShadow); } \
+  NS_IMETHOD    SetTextShadow(const nsString& aTextShadow) { return _to SetTextShadow(aTextShadow); } \
+  NS_IMETHOD    GetTextTransform(nsString& aTextTransform) { return _to GetTextTransform(aTextTransform); } \
+  NS_IMETHOD    SetTextTransform(const nsString& aTextTransform) { return _to SetTextTransform(aTextTransform); } \
+  NS_IMETHOD    GetTop(nsString& aTop) { return _to GetTop(aTop); } \
+  NS_IMETHOD    SetTop(const nsString& aTop) { return _to SetTop(aTop); } \
+  NS_IMETHOD    GetUnicodeBidi(nsString& aUnicodeBidi) { return _to GetUnicodeBidi(aUnicodeBidi); } \
+  NS_IMETHOD    SetUnicodeBidi(const nsString& aUnicodeBidi) { return _to SetUnicodeBidi(aUnicodeBidi); } \
+  NS_IMETHOD    GetVerticalAlign(nsString& aVerticalAlign) { return _to GetVerticalAlign(aVerticalAlign); } \
+  NS_IMETHOD    SetVerticalAlign(const nsString& aVerticalAlign) { return _to SetVerticalAlign(aVerticalAlign); } \
+  NS_IMETHOD    GetVisibility(nsString& aVisibility) { return _to GetVisibility(aVisibility); } \
+  NS_IMETHOD    SetVisibility(const nsString& aVisibility) { return _to SetVisibility(aVisibility); } \
+  NS_IMETHOD    GetVoiceFamily(nsString& aVoiceFamily) { return _to GetVoiceFamily(aVoiceFamily); } \
+  NS_IMETHOD    SetVoiceFamily(const nsString& aVoiceFamily) { return _to SetVoiceFamily(aVoiceFamily); } \
+  NS_IMETHOD    GetVolume(nsString& aVolume) { return _to GetVolume(aVolume); } \
+  NS_IMETHOD    SetVolume(const nsString& aVolume) { return _to SetVolume(aVolume); } \
+  NS_IMETHOD    GetWhiteSpace(nsString& aWhiteSpace) { return _to GetWhiteSpace(aWhiteSpace); } \
+  NS_IMETHOD    SetWhiteSpace(const nsString& aWhiteSpace) { return _to SetWhiteSpace(aWhiteSpace); } \
+  NS_IMETHOD    GetWidows(nsString& aWidows) { return _to GetWidows(aWidows); } \
+  NS_IMETHOD    SetWidows(const nsString& aWidows) { return _to SetWidows(aWidows); } \
+  NS_IMETHOD    GetWidth(nsString& aWidth) { return _to GetWidth(aWidth); } \
+  NS_IMETHOD    SetWidth(const nsString& aWidth) { return _to SetWidth(aWidth); } \
+  NS_IMETHOD    GetWordSpacing(nsString& aWordSpacing) { return _to GetWordSpacing(aWordSpacing); } \
+  NS_IMETHOD    SetWordSpacing(const nsString& aWordSpacing) { return _to SetWordSpacing(aWordSpacing); } \
+  NS_IMETHOD    GetZIndex(nsString& aZIndex) { return _to GetZIndex(aZIndex); } \
+  NS_IMETHOD    SetZIndex(const nsString& aZIndex) { return _to SetZIndex(aZIndex); } \
+  NS_IMETHOD    GetOpacity(nsString& aOpacity) { return _to GetOpacity(aOpacity); } \
+  NS_IMETHOD    SetOpacity(const nsString& aOpacity) { return _to SetOpacity(aOpacity); } \
+
+
+extern "C" NS_DOM nsresult NS_InitCSS2PropertiesClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptCSS2Properties(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMCSS2Properties_h__

mozilla/dom/public/css/nsIDOMCSSFontFaceRule.h

@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+/* AUTO-GENERATED. DO NOT EDIT!!! */
+
+#ifndef nsIDOMCSSFontFaceRule_h__
+#define nsIDOMCSSFontFaceRule_h__
+
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMCSSRule.h"
+
+class nsIDOMCSSStyleDeclaration;
+
+#define NS_IDOMCSSFONTFACERULE_IID \
+ { 0xa6cf90bb, 0x15b3, 0x11d2, \
+   { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 } } 
+
+class nsIDOMCSSFontFaceRule : public nsIDOMCSSRule {
+public:
+  static const nsIID& GetIID() { static nsIID iid = NS_IDOMCSSFONTFACERULE_IID; return iid; }
+
+  NS_IMETHOD    GetStyle(nsIDOMCSSStyleDeclaration** aStyle)=0;
+  NS_IMETHOD    SetStyle(nsIDOMCSSStyleDeclaration* aStyle)=0;
+};
+
+
+#define NS_DECL_IDOMCSSFONTFACERULE   \
+  NS_IMETHOD    GetStyle(nsIDOMCSSStyleDeclaration** aStyle);  \
+  NS_IMETHOD    SetStyle(nsIDOMCSSStyleDeclaration* aStyle);  \
+
+
+
+#define NS_FORWARD_IDOMCSSFONTFACERULE(_to)  \
+  NS_IMETHOD    GetStyle(nsIDOMCSSStyleDeclaration** aStyle) { return _to GetStyle(aStyle); } \
+  NS_IMETHOD    SetStyle(nsIDOMCSSStyleDeclaration* aStyle) { return _to SetStyle(aStyle); } \
+
+
+extern "C" NS_DOM nsresult NS_InitCSSFontFaceRuleClass(nsIScriptContext *aContext, void **aPrototype);
+
+extern "C" NS_DOM nsresult NS_NewScriptCSSFontFaceRule(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn);
+
+#endif // nsIDOMCSSFontFaceRule_h__