Back to index

lightning-sunbird  0.9+nobinonly
nsXULElement.h
Go to the documentation of this file.
00001 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
00002 /* ***** BEGIN LICENSE BLOCK *****
00003  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
00004  *
00005  * The contents of this file are subject to the Mozilla Public License Version
00006  * 1.1 (the "License"); you may not use this file except in compliance with
00007  * the License. You may obtain a copy of the License at
00008  * http://www.mozilla.org/MPL/
00009  *
00010  * Software distributed under the License is distributed on an "AS IS" basis,
00011  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
00012  * for the specific language governing rights and limitations under the
00013  * License.
00014  *
00015  * The Original Code is Mozilla Communicator client code.
00016  *
00017  * The Initial Developer of the Original Code is
00018  * Netscape Communications Corporation.
00019  * Portions created by the Initial Developer are Copyright (C) 1998
00020  * the Initial Developer. All Rights Reserved.
00021  *
00022  * Contributor(s):
00023  *   Chris Waterson <waterson@netscape.com>
00024  *   Peter Annema <disttsc@bart.nl>
00025  *   Mike Shaver <shaver@mozilla.org>
00026  *   Ben Goodger <ben@netscape.com>
00027  *
00028  * Alternatively, the contents of this file may be used under the terms of
00029  * either of the GNU General Public License Version 2 or later (the "GPL"),
00030  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
00031  * in which case the provisions of the GPL or the LGPL are applicable instead
00032  * of those above. If you wish to allow use of your version of this file only
00033  * under the terms of either the GPL or the LGPL, and not to allow others to
00034  * use your version of this file under the terms of the MPL, indicate your
00035  * decision by deleting the provisions above and replace them with the notice
00036  * and other provisions required by the GPL or the LGPL. If you do not delete
00037  * the provisions above, a recipient may use your version of this file under
00038  * the terms of any one of the MPL, the GPL or the LGPL.
00039  *
00040  * ***** END LICENSE BLOCK ***** */
00041 
00042 /*
00043 
00044   The base XUL element class and associates.
00045 
00046 */
00047 
00048 #ifndef nsXULElement_h__
00049 #define nsXULElement_h__
00050 
00051 // XXX because nsIEventListenerManager has broken includes
00052 #include "nsIDOMEvent.h"
00053 #include "nsIServiceManager.h"
00054 #include "nsIAtom.h"
00055 #include "nsINodeInfo.h"
00056 #include "nsIControllers.h"
00057 #include "nsICSSParser.h"
00058 #include "nsIDOMElement.h"
00059 #include "nsIDOMEventReceiver.h"
00060 #include "nsIDOM3EventTarget.h"
00061 #include "nsIDOMXULElement.h"
00062 #include "nsIDOMXULMultSelectCntrlEl.h"
00063 #include "nsIEventListenerManager.h"
00064 #include "nsIRDFCompositeDataSource.h"
00065 #include "nsIRDFResource.h"
00066 #include "nsIScriptObjectOwner.h"
00067 #include "nsIStyledContent.h"
00068 #include "nsIBindingManager.h"
00069 #include "nsIURI.h"
00070 #include "nsIXMLContent.h"
00071 #include "nsIXULPrototypeCache.h"
00072 #include "nsIXULTemplateBuilder.h"
00073 #include "nsIBoxObject.h"
00074 #include "nsIChromeEventHandler.h"
00075 #include "nsIXBLService.h"
00076 #include "nsICSSOMFactory.h"
00077 #include "nsLayoutCID.h"
00078 #include "nsAttrAndChildArray.h"
00079 #include "nsXULAtoms.h"
00080 #include "nsAutoPtr.h"
00081 #include "nsGenericElement.h"
00082 
00083 class nsIDocument;
00084 class nsIRDFService;
00085 class nsISupportsArray;
00086 class nsIXULContentUtils;
00087 class nsIXULPrototypeDocument;
00088 class nsString;
00089 class nsVoidArray;
00090 class nsIDocShell;
00091 class nsDOMAttributeMap;
00092 class nsICSSStyleRule;
00093 
00094 class nsIObjectInputStream;
00095 class nsIObjectOutputStream;
00096 
00097 static NS_DEFINE_CID(kCSSParserCID, NS_CSSPARSER_CID);
00098 
00100 
00101 #ifdef XUL_PROTOTYPE_ATTRIBUTE_METERING
00102 #define XUL_PROTOTYPE_ATTRIBUTE_METER(counter) (nsXULPrototypeAttribute::counter++)
00103 #else
00104 #define XUL_PROTOTYPE_ATTRIBUTE_METER(counter) ((void) 0)
00105 #endif
00106 
00107 
00114 MOZ_DECL_CTOR_COUNTER(nsXULPrototypeAttribute)
00115 
00116 class nsXULPrototypeAttribute
00117 {
00118 public:
00119     nsXULPrototypeAttribute()
00120         : mName(nsXULAtoms::id),  // XXX this is a hack, but names have to have a value
00121           mEventHandler(nsnull)
00122     {
00123         XUL_PROTOTYPE_ATTRIBUTE_METER(gNumAttributes);
00124         MOZ_COUNT_CTOR(nsXULPrototypeAttribute);
00125     }
00126 
00127     ~nsXULPrototypeAttribute();
00128 
00129     nsAttrName mName;
00130     nsAttrValue mValue;
00131     void* mEventHandler;
00132 
00133 #ifdef XUL_PROTOTYPE_ATTRIBUTE_METERING
00134 
00172     static PRUint32   gNumElements;
00173     static PRUint32   gNumAttributes;
00174     static PRUint32   gNumEventHandlers;
00175     static PRUint32   gNumCacheTests;
00176     static PRUint32   gNumCacheHits;
00177     static PRUint32   gNumCacheSets;
00178     static PRUint32   gNumCacheFills;
00179 #endif /* !XUL_PROTOTYPE_ATTRIBUTE_METERING */
00180 };
00181 
00182 
00192 class nsXULPrototypeNode
00193 {
00194 public:
00195     enum Type { eType_Element, eType_Script, eType_Text };
00196 
00197     Type                     mType;
00198 
00199     PRInt32                  mRefCnt;
00200 
00201     virtual ~nsXULPrototypeNode() {}
00202     virtual nsresult Serialize(nsIObjectOutputStream* aStream,
00203                                nsIScriptContext* aContext,
00204                                const nsCOMArray<nsINodeInfo> *aNodeInfos) = 0;
00205     virtual nsresult Deserialize(nsIObjectInputStream* aStream,
00206                                  nsIScriptContext* aContext,
00207                                  nsIURI* aDocumentURI,
00208                                  const nsCOMArray<nsINodeInfo> *aNodeInfos) = 0;
00209 
00210 #ifdef NS_BUILD_REFCNT_LOGGING
00211     virtual const char* ClassName() = 0;
00212     virtual PRUint32 ClassSize() = 0;
00213 #endif
00214 
00215     void AddRef() {
00216         ++mRefCnt;
00217         NS_LOG_ADDREF(this, mRefCnt, ClassName(), ClassSize());
00218     }
00219     void Release()
00220     {
00221         --mRefCnt;
00222         NS_LOG_RELEASE(this, mRefCnt, ClassName());
00223         if (mRefCnt == 0)
00224             delete this;
00225     }
00226     virtual void ReleaseSubtree() { Release(); }
00227 
00228 protected:
00229     nsXULPrototypeNode(Type aType)
00230         : mType(aType), mRefCnt(1) {}
00231 };
00232 
00233 class nsXULPrototypeElement : public nsXULPrototypeNode
00234 {
00235 public:
00236     nsXULPrototypeElement()
00237         : nsXULPrototypeNode(eType_Element),
00238           mNumChildren(0),
00239           mChildren(nsnull),
00240           mNumAttributes(0),
00241           mAttributes(nsnull)
00242     {
00243         NS_LOG_ADDREF(this, 1, ClassName(), ClassSize());
00244     }
00245 
00246     virtual ~nsXULPrototypeElement()
00247     {
00248         delete[] mAttributes;
00249         delete[] mChildren;
00250     }
00251 
00252 #ifdef NS_BUILD_REFCNT_LOGGING
00253     virtual const char* ClassName() { return "nsXULPrototypeElement"; }
00254     virtual PRUint32 ClassSize() { return sizeof(*this); }
00255 #endif
00256 
00257     virtual void ReleaseSubtree()
00258     {
00259       if (mChildren) {
00260         for (PRInt32 i = mNumChildren-1; i >= 0; i--) {
00261           if (mChildren[i])
00262             mChildren[i]->ReleaseSubtree();
00263         }
00264       }
00265 
00266       nsXULPrototypeNode::ReleaseSubtree();
00267     }
00268 
00269     virtual nsresult Serialize(nsIObjectOutputStream* aStream,
00270                                nsIScriptContext* aContext,
00271                                const nsCOMArray<nsINodeInfo> *aNodeInfos);
00272     virtual nsresult Deserialize(nsIObjectInputStream* aStream,
00273                                  nsIScriptContext* aContext,
00274                                  nsIURI* aDocumentURI,
00275                                  const nsCOMArray<nsINodeInfo> *aNodeInfos);
00276 
00277     nsresult SetAttrAt(PRUint32 aPos, const nsAString& aValue, nsIURI* aDocumentURI);
00278 
00279     PRUint32                 mNumChildren;
00280     nsXULPrototypeNode**     mChildren;           // [OWNER]
00281 
00282     nsCOMPtr<nsINodeInfo>    mNodeInfo;           // [OWNER]
00283 
00284     PRUint32                 mNumAttributes;
00285     nsXULPrototypeAttribute* mAttributes;         // [OWNER]
00286 
00287     static void ReleaseGlobals()
00288     {
00289         NS_IF_RELEASE(sCSSParser);
00290     }
00291 
00292 protected:
00293     static nsICSSParser* GetCSSParser()
00294     {
00295         if (!sCSSParser) {
00296             CallCreateInstance(kCSSParserCID, &sCSSParser);
00297             if (sCSSParser) {
00298                 sCSSParser->SetCaseSensitive(PR_TRUE);
00299                 sCSSParser->SetQuirkMode(PR_FALSE);
00300             }
00301         }
00302         return sCSSParser;
00303     }
00304     static nsICSSParser* sCSSParser;
00305 };
00306 
00307 struct JSRuntime;
00308 struct JSObject;
00309 class nsXULDocument;
00310 
00311 class nsXULPrototypeScript : public nsXULPrototypeNode
00312 {
00313 public:
00314     // Note: if *rv is failure after the script is constructed, delete
00315     // it and return *rv.
00316     nsXULPrototypeScript(PRUint32 aLineNo, const char *aVersion,
00317                          PRBool aHasE4XOption, nsresult* rv);
00318     virtual ~nsXULPrototypeScript();
00319 
00320 #ifdef NS_BUILD_REFCNT_LOGGING
00321     virtual const char* ClassName() { return "nsXULPrototypeScript"; }
00322     virtual PRUint32 ClassSize() { return sizeof(*this); }
00323 #endif
00324 
00325     virtual nsresult Serialize(nsIObjectOutputStream* aStream,
00326                                nsIScriptContext* aContext,
00327                                const nsCOMArray<nsINodeInfo> *aNodeInfos);
00328     nsresult SerializeOutOfLine(nsIObjectOutputStream* aStream,
00329                                 nsIScriptContext* aContext);
00330     virtual nsresult Deserialize(nsIObjectInputStream* aStream,
00331                                  nsIScriptContext* aContext,
00332                                  nsIURI* aDocumentURI,
00333                                  const nsCOMArray<nsINodeInfo> *aNodeInfos);
00334     nsresult DeserializeOutOfLine(nsIObjectInputStream* aInput,
00335                                   nsIScriptContext* aContext);
00336 
00337     nsresult Compile(const PRUnichar* aText, PRInt32 aTextLength,
00338                      nsIURI* aURI, PRUint32 aLineNo,
00339                      nsIDocument* aDocument,
00340                      nsIXULPrototypeDocument* aPrototypeDocument);
00341 
00342     nsCOMPtr<nsIURI>         mSrcURI;
00343     PRUint32                 mLineNo;
00344     PRPackedBool             mSrcLoading;
00345     PRPackedBool             mOutOfLine;
00346     PRPackedBool             mHasE4XOption;
00347     PRPackedBool             mAddedGCRoot;
00348     nsXULDocument*           mSrcLoadWaiters;   // [OWNER] but not COMPtr
00349     JSObject*                mJSObject;
00350     const char*              mLangVersion;
00351 
00352     static void ReleaseGlobals()
00353     {
00354         NS_IF_RELEASE(sXULPrototypeCache);
00355     }
00356 
00357 protected:
00358     static nsIXULPrototypeCache* GetXULCache()
00359     {
00360         if (!sXULPrototypeCache)
00361             CallGetService("@mozilla.org/xul/xul-prototype-cache;1", &sXULPrototypeCache);
00362 
00363         return sXULPrototypeCache;
00364     }
00365     static nsIXULPrototypeCache* sXULPrototypeCache;
00366 };
00367 
00368 class nsXULPrototypeText : public nsXULPrototypeNode
00369 {
00370 public:
00371     nsXULPrototypeText()
00372         : nsXULPrototypeNode(eType_Text)
00373     {
00374         NS_LOG_ADDREF(this, 1, ClassName(), ClassSize());
00375     }
00376 
00377     virtual ~nsXULPrototypeText()
00378     {
00379     }
00380 
00381 #ifdef NS_BUILD_REFCNT_LOGGING
00382     virtual const char* ClassName() { return "nsXULPrototypeText"; }
00383     virtual PRUint32 ClassSize() { return sizeof(*this); }
00384 #endif
00385 
00386     virtual nsresult Serialize(nsIObjectOutputStream* aStream,
00387                                nsIScriptContext* aContext,
00388                                const nsCOMArray<nsINodeInfo> *aNodeInfos);
00389     virtual nsresult Deserialize(nsIObjectInputStream* aStream,
00390                                  nsIScriptContext* aContext,
00391                                  nsIURI* aDocumentURI,
00392                                  const nsCOMArray<nsINodeInfo> *aNodeInfos);
00393 
00394     nsString                 mValue;
00395 };
00396 
00398 
00405 #define XUL_ELEMENT_LAZY_STATE_OFFSET ELEMENT_TYPE_SPECIFIC_BITS_OFFSET
00406 
00407 class nsXULElement : public nsGenericElement,
00408                      public nsIDOMXULElement,
00409                      public nsIScriptEventHandlerOwner,
00410                      public nsIChromeEventHandler
00411 {
00412 public:
00429     enum LazyState {
00430         eChildrenMustBeRebuilt  = 0x1,
00431         eTemplateContentsBuilt  = 0x2,
00432         eContainerContentsBuilt = 0x4
00433     };
00434 
00436     static nsXULElement* FromContent(nsIContent *aContent)
00437     {
00438         if (aContent->IsContentOfType(eXUL))
00439             return NS_STATIC_CAST(nsXULElement*, aContent);
00440         return nsnull;
00441     }
00442 
00443 public:
00444     static nsIXBLService* GetXBLService() {
00445         if (!gXBLService)
00446             CallGetService("@mozilla.org/xbl;1", &gXBLService);
00447         return gXBLService;
00448     }
00449     static void ReleaseGlobals() {
00450         NS_IF_RELEASE(gXBLService);
00451         NS_IF_RELEASE(gCSSOMFactory);
00452     }
00453 
00454 protected:
00455     // pseudo-constants
00456     static nsIXBLService*       gXBLService;
00457     static nsICSSOMFactory*     gCSSOMFactory;
00458 
00459 public:
00460     static nsresult
00461     Create(nsXULPrototypeElement* aPrototype, nsIDocument* aDocument,
00462            PRBool aIsScriptable, nsIContent** aResult);
00463 
00464     // nsISupports
00465     NS_DECL_ISUPPORTS_INHERITED
00466 
00467     // nsIContent
00468     virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
00469                                 nsIContent* aBindingParent,
00470                                 PRBool aCompileEventHandlers);
00471     virtual void UnbindFromTree(PRBool aDeep = PR_TRUE,
00472                                 PRBool aNullParent = PR_TRUE);
00473     virtual PRBool IsNativeAnonymous() const;
00474     virtual PRUint32 GetChildCount() const;
00475     virtual nsIContent *GetChildAt(PRUint32 aIndex) const;
00476     virtual PRInt32 IndexOf(nsIContent* aPossibleChild) const;
00477     virtual nsresult InsertChildAt(nsIContent* aKid, PRUint32 aIndex,
00478                                    PRBool aNotify);
00479     virtual nsresult AppendChildTo(nsIContent* aKid, PRBool aNotify);
00480     virtual nsresult RemoveChildAt(PRUint32 aIndex, PRBool aNotify);
00481     virtual nsIAtom *GetIDAttributeName() const;
00482     virtual nsIAtom *GetClassAttributeName() const;
00483     nsresult SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
00484                      const nsAString& aValue, PRBool aNotify)
00485     {
00486       return SetAttr(aNameSpaceID, aName, nsnull, aValue, aNotify);
00487     }
00488     virtual nsresult SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix,
00489                              const nsAString& aValue, PRBool aNotify);
00490     virtual nsresult GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
00491                              nsAString& aResult) const;
00492     virtual PRBool HasAttr(PRInt32 aNameSpaceID, nsIAtom* aName) const;
00493     virtual nsresult UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
00494                                PRBool aNotify);
00495     virtual nsresult GetAttrNameAt(PRUint32 aIndex, PRInt32* aNameSpaceID,
00496                                    nsIAtom** aName, nsIAtom** aPrefix) const;
00497     virtual PRUint32 GetAttrCount() const;
00498 #ifdef DEBUG
00499     virtual void List(FILE* out, PRInt32 aIndent) const;
00500     virtual void DumpContent(FILE* out, PRInt32 aIndent,PRBool aDumpAll) const
00501     {
00502     }
00503 #endif
00504     virtual nsresult HandleDOMEvent(nsPresContext* aPresContext,
00505                               nsEvent* aEvent,
00506                               nsIDOMEvent** aDOMEvent,
00507                               PRUint32 aFlags,
00508                               nsEventStatus* aEventStatus);
00509 
00510     virtual PRUint32 ContentID() const;
00511     virtual void SetContentID(PRUint32 aID);
00512 
00513     virtual nsresult RangeAdd(nsIDOMRange* aRange);
00514     virtual void RangeRemove(nsIDOMRange* aRange);
00515     virtual const nsVoidArray *GetRangeList() const;
00516     virtual void SetFocus(nsPresContext* aPresContext);
00517     virtual void RemoveFocus(nsPresContext* aPresContext);
00518 
00519     virtual nsIContent *GetBindingParent() const;
00520     virtual PRBool IsContentOfType(PRUint32 aFlags) const;
00521     virtual nsresult GetListenerManager(nsIEventListenerManager** aResult);
00522     virtual PRBool IsFocusable(PRInt32 *aTabIndex = nsnull);
00523 
00524     // nsIXMLContent
00525     NS_IMETHOD MaybeTriggerAutoLink(nsIDocShell *aShell);
00526 
00527     // nsIStyledContent
00528     virtual nsIAtom* GetID() const;
00529     virtual const nsAttrValue* GetClasses() const;
00530     NS_IMETHOD_(PRBool) HasClass(nsIAtom* aClass, PRBool aCaseSensitive) const;
00531 
00532     NS_IMETHOD WalkContentStyleRules(nsRuleWalker* aRuleWalker);
00533     virtual nsICSSStyleRule* GetInlineStyleRule();
00534     NS_IMETHOD SetInlineStyleRule(nsICSSStyleRule* aStyleRule, PRBool aNotify);
00535     virtual nsChangeHint GetAttributeChangeHint(const nsIAtom* aAttribute,
00536                                                 PRInt32 aModType) const;
00537     NS_IMETHOD_(PRBool) IsAttributeMapped(const nsIAtom* aAttribute) const;
00538 
00539     // XUL element methods
00540     PRUint32 PeekChildCount() const
00541     { return mAttrsAndChildren.ChildCount(); }
00542     void SetLazyState(LazyState aFlags)
00543     { SetFlags(aFlags << XUL_ELEMENT_LAZY_STATE_OFFSET); }
00544     void ClearLazyState(LazyState aFlags)
00545     { UnsetFlags(aFlags << XUL_ELEMENT_LAZY_STATE_OFFSET); }
00546     PRBool GetLazyState(LazyState aFlag)
00547     { return GetFlags() & (aFlag << XUL_ELEMENT_LAZY_STATE_OFFSET); }
00548     NS_HIDDEN_(nsresult) AddScriptEventListener(nsIAtom* aName,
00549                                                 const nsAString& aValue);
00550 
00551     // nsIDOMNode
00552     NS_FORWARD_NSIDOMNODE_NO_CLONENODE(nsGenericElement::)
00553 
00554     // nsIDOMElement
00555     NS_FORWARD_NSIDOMELEMENT(nsGenericElement::)
00556 
00557     // nsIDOMXULElement
00558     NS_DECL_NSIDOMXULELEMENT
00559 
00560     // nsIScriptEventHandlerOwner
00561     nsresult CompileEventHandler(nsIScriptContext* aContext,
00562                                  void* aTarget,
00563                                  nsIAtom *aName,
00564                                  const nsAString& aBody,
00565                                  const char* aURL,
00566                                  PRUint32 aLineNo,
00567                                  void** aHandler);
00568     nsresult GetCompiledEventHandler(nsIAtom *aName, void** aHandler);
00569 
00570     // nsIChromeEventHandler
00571     NS_DECL_NSICHROMEEVENTHANDLER
00572 
00573 
00574 protected:
00575     nsXULElement(nsINodeInfo* aNodeInfo);
00576     virtual ~nsXULElement(void);
00577 
00578     // Implementation methods
00579     nsresult EnsureContentsGenerated(void) const;
00580 
00581     nsresult ExecuteOnBroadcastHandler(nsIDOMElement* anElement, const nsAString& attrName);
00582 
00583     static nsresult
00584     ExecuteJSCode(nsIDOMElement* anElement, nsEvent* aEvent);
00585 
00586     // Helper routine that crawls a parent chain looking for a tree element.
00587     NS_IMETHOD GetParentTree(nsIDOMXULMultiSelectControlElement** aTreeElement);
00588 
00589     nsresult AddPopupListener(nsIAtom* aName);
00590 
00591 protected:
00592     // Required fields
00593     nsXULPrototypeElement*              mPrototype;
00594     nsCOMPtr<nsIEventListenerManager>   mListenerManager;    // [OWNER]
00595 
00600     nsIContent*                         mBindingParent;
00601 
00605     nsresult MakeHeavyweight();
00606 
00607     const nsAttrValue* FindLocalOrProtoAttr(PRInt32 aNameSpaceID,
00608                                             nsIAtom *aName) const;
00609   
00613     nsXULPrototypeAttribute *FindPrototypeAttribute(PRInt32 aNameSpaceID,
00614                                                     nsIAtom *aName) const;
00618     void AddListenerFor(const nsAttrName& aName,
00619                         PRBool aCompileEventHandlers);
00620     void MaybeAddPopupListener(nsIAtom* aLocalName);
00621 
00622 
00623     nsresult HideWindowChrome(PRBool aShouldHide);
00624 
00625     
00626     nsresult SetAttrAndNotify(PRInt32 aNamespaceID,
00627                               nsIAtom* aAttribute,
00628                               nsIAtom* aPrefix,
00629                               const nsAString& aOldValue,
00630                               nsAttrValue& aParsedValue,
00631                               PRBool aModification,
00632                               PRBool aFireMutation,
00633                               PRBool aNotify);
00634 
00635     const nsAttrName* InternalGetExistingAttrNameFromQName(const nsAString& aStr) const;
00636 
00637 protected:
00638     // Internal accessor. This shadows the 'Slots', and returns
00639     // appropriate value.
00640     nsIControllers *Controllers() {
00641       nsDOMSlots* slots = GetExistingDOMSlots();
00642       return slots ? slots->mControllers : nsnull; 
00643     }
00644 
00645     void UnregisterAccessKey(const nsAString& aOldValue);
00646     PRBool BoolAttrIsTrue(nsIAtom* aName);
00647 
00648     friend nsresult
00649     NS_NewXULElement(nsIContent** aResult, nsINodeInfo *aNodeInfo);
00650 };
00651 
00652 
00653 #endif // nsXULElement_h__