/* * Copyright (C) 2005-2007 by Scott Lanning * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * $CVSHeader: Mozilla-DOM/xs/DOM.xs,v 1.24 2007-06-06 21:47:36 slanning Exp $ */ #include "mozilladom2perl.h" /* ------------------------------------------------------------------------- */ /* conversion functions between Perl and C */ MOZDOM_DEF_I_TYPEMAPPERS(WebBrowser) MOZDOM_DEF_I_TYPEMAPPERS(WebNavigation) MOZDOM_DEF_I_TYPEMAPPERS(URI) MOZDOM_DEF_I_TYPEMAPPERS(Selection) MOZDOM_DEF_I_TYPEMAPPERS(Supports) MOZDOM_DEF_DOM_TYPEMAPPERS(AbstractView) MOZDOM_DEF_DOM_TYPEMAPPERS(DocumentView) MOZDOM_DEF_DOM_TYPEMAPPERS(Event) MOZDOM_DEF_DOM_TYPEMAPPERS(NSEvent) MOZDOM_DEF_DOM_TYPEMAPPERS(UIEvent) MOZDOM_DEF_DOM_TYPEMAPPERS(NSUIEvent) MOZDOM_DEF_DOM_TYPEMAPPERS(DocumentEvent) MOZDOM_DEF_DOM_TYPEMAPPERS(MutationEvent) MOZDOM_DEF_DOM_TYPEMAPPERS(KeyEvent) MOZDOM_DEF_DOM_TYPEMAPPERS(MouseEvent) MOZDOM_DEF_DOM_TYPEMAPPERS(EventTarget) MOZDOM_DEF_DOM_TYPEMAPPERS(EventListener) MOZDOM_DEF_DOM_TYPEMAPPERS(Window) MOZDOM_DEF_DOM_TYPEMAPPERS(Window2) MOZDOM_DEF_DOM_TYPEMAPPERS(WindowInternal) MOZDOM_DEF_DOM_TYPEMAPPERS(WindowCollection) MOZDOM_DEF_DOM_TYPEMAPPERS(Document) MOZDOM_DEF_DOM_TYPEMAPPERS(NSDocument) MOZDOM_DEF_DOM_TYPEMAPPERS(DocumentFragment) MOZDOM_DEF_DOM_TYPEMAPPERS(DocumentRange) MOZDOM_DEF_DOM_TYPEMAPPERS(DocumentType) MOZDOM_DEF_DOM_TYPEMAPPERS(DOMException) MOZDOM_DEF_DOM_TYPEMAPPERS(Node) MOZDOM_DEF_DOM_TYPEMAPPERS(NodeList) MOZDOM_DEF_DOM_TYPEMAPPERS(NamedNodeMap) MOZDOM_DEF_DOM_TYPEMAPPERS(Element) MOZDOM_DEF_DOM_TYPEMAPPERS(Entity) MOZDOM_DEF_DOM_TYPEMAPPERS(EntityReference) MOZDOM_DEF_DOM_TYPEMAPPERS(Attr) MOZDOM_DEF_DOM_TYPEMAPPERS(Notation) MOZDOM_DEF_DOM_TYPEMAPPERS(ProcessingInstruction) MOZDOM_DEF_DOM_TYPEMAPPERS(CDATASection) MOZDOM_DEF_DOM_TYPEMAPPERS(Comment) MOZDOM_DEF_DOM_TYPEMAPPERS(CharacterData) MOZDOM_DEF_DOM_TYPEMAPPERS(Text) MOZDOM_DEF_DOM_TYPEMAPPERS(DOMImplementation) MOZDOM_DEF_DOM_TYPEMAPPERS(Range) MOZDOM_DEF_DOM_TYPEMAPPERS(NSRange) MOZDOM_DEF_DOM_TYPEMAPPERS(History) MOZDOM_DEF_DOM_TYPEMAPPERS(Location) MOZDOM_DEF_DOM_TYPEMAPPERS(Navigator) MOZDOM_DEF_DOM_TYPEMAPPERS(Screen) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLAnchorElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLAnchorElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLAreaElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLAreaElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLAppletElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLBRElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLBaseElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLBaseFontElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLBodyElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLButtonElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLButtonElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLCollection) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLDListElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLDirectoryElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLDivElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLDocument) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLEmbedElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLFieldSetElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLFontElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLFormElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLFormElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLFrameElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLFrameElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLFrameSetElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLHRElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLHRElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLHeadElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLHeadingElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLHtmlElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLIFrameElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLImageElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLImageElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLInputElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLInputElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLIsIndexElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLLIElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLLabelElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLLegendElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLLinkElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLMapElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLMenuElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLMetaElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLModElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLOListElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLObjectElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLOptGroupElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLOptionElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLOptionElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLOptionsCollection) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLParagraphElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLParamElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLPreElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLQuoteElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLScriptElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLSelectElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLSelectElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLStyleElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLTableCaptionElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLTableCellElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLTableColElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLTableElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLTableRowElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLTableSectionElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLTextAreaElement) MOZDOM_DEF_DOM_TYPEMAPPERS(NSHTMLTextAreaElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLTitleElement) MOZDOM_DEF_DOM_TYPEMAPPERS(HTMLUListElement) /* ------------------------------------------------------------------------- */ /* I'm not a C++ or XS whiz, so let me know if I'm doing something stupid. Support for this is "experimental". It will only be enabled if you do `perl Makefile.PL DEFINE=MDEXP_EVENT_LISTENER`. */ #ifdef MDEXP_EVENT_LISTENER NS_IMPL_ISUPPORTS1(MozDomEventListener, nsIDOMEventListener) MozDomEventListener::MozDomEventListener() { return; } MozDomEventListener::MozDomEventListener(SV *handler) : mHandler(newSVsv(handler)) { return; } MozDomEventListener::~MozDomEventListener() { /* XXX: do we need sv_free(mHandler) or SvREFCNT ? */ return; } NS_IMETHODIMP MozDomEventListener::HandleEvent(nsIDOMEvent *event) { dSP; ENTER; SAVETMPS; PUSHMARK(SP); XPUSHs(sv_2mortal(newSVnsIDOMEvent(event))); PUTBACK; /* call the subroutine passed to `new' */ call_sv(mHandler, G_DISCARD); FREETMPS; LEAVE; } #endif /* MDEXP_EVENT_LISTENER */ /* ------------------------------------------------------------------------- */ MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::AbstractView PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMAbstractView.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMABSTRACTVIEW_IID) static nsIID nsIDOMAbstractView::GetIID() CODE: const nsIID &id = nsIDOMAbstractView::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDocument(nsIDOMDocumentView * *aDocument) nsIDOMDocumentView * moz_dom_GetDocument (view) nsIDOMAbstractView *view; PREINIT: nsIDOMDocumentView *docview; CODE: view->GetDocument(&docview); RETVAL = docview; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::DocumentView PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMDocumentView.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDOCUMENTVIEW_IID) static nsIID nsIDOMDocumentView::GetIID() CODE: const nsIID &id = nsIDOMDocumentView::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDefaultView(nsIDOMAbstractView * *aDefaultView); nsIDOMAbstractView * moz_dom_GetDefaultView (docview) nsIDOMDocumentView *docview; PREINIT: nsIDOMAbstractView *view; CODE: docview->GetDefaultView(&view); RETVAL = view; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Event PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMEvent.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMEVENT_IID) static nsIID nsIDOMEvent::GetIID() CODE: const nsIID &id = nsIDOMEvent::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (event) nsIDOMEvent *event; PREINIT: nsEmbedString type; CODE: event->GetType(type); RETVAL = type; OUTPUT: RETVAL ## GetTarget(nsIDOMEventTarget * *aTarget), etc. nsIDOMEventTarget * moz_dom_GetTarget (event) nsIDOMEvent *event ALIAS: Mozilla::DOM::Event::GetCurrentTarget = 1 PREINIT: nsIDOMEventTarget *target; CODE: switch (ix) { case 0: event->GetTarget(&target); break; case 1: event->GetCurrentTarget(&target); break; default: XSRETURN_UNDEF; } RETVAL = target; OUTPUT: RETVAL ## GetEventPhase(PRUint16 *aEventPhase) PRUint16 moz_dom_GetEventPhase (event) nsIDOMEvent *event; PREINIT: PRUint16 phase; CODE: event->GetEventPhase(&phase); RETVAL = phase; OUTPUT: RETVAL ## GetBubbles(PRBool *aBubbles), etc. PRBool moz_dom_GetBubbles (event) nsIDOMEvent *event; ALIAS: Mozilla::DOM::Event::GetCancelable = 1 PREINIT: PRBool can; CODE: switch (ix) { case 0: event->GetBubbles(&can); break; case 1: event->GetCancelable(&can); break; default: can = 0; } RETVAL = can; OUTPUT: RETVAL ## GetTimeStamp(DOMTimeStamp *aTimeStamp) DOMTimeStamp moz_dom_GetTimeStamp (event) nsIDOMEvent *event; PREINIT: DOMTimeStamp ts; CODE: event->GetTimeStamp(&ts); RETVAL = ts; OUTPUT: RETVAL ## StopPropagation(void), etc. void moz_dom_StopPropagation (event) nsIDOMEvent *event; ALIAS: Mozilla::DOM::Event::PreventDefault = 1 CODE: switch (ix) { case 0: event->StopPropagation(); break; case 1: event->PreventDefault(); break; default: break; } ## InitEvent(const nsAString & eventTypeArg, PRBool canBubbleArg, PRBool cancelableArg) void moz_dom_InitEvent (event, eventtype, canbubble, cancelable) nsIDOMEvent *event; nsEmbedString eventtype; PRBool canbubble; PRBool cancelable; CODE: /* XXX: this can throw an exception, so should check... */ event->InitEvent(eventtype, canbubble, cancelable); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSEvent PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSEvent.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSEVENT_IID) static nsIID nsIDOMNSEvent::GetIID() CODE: const nsIID &id = nsIDOMNSEvent::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetOriginalTarget(nsIDOMEventTarget * *aOriginalTarget) nsIDOMEventTarget * moz_dom_GetOriginalTarget (nsevent) nsIDOMNSEvent *nsevent; PREINIT: nsIDOMEventTarget * aOriginalTarget; CODE: nsevent->GetOriginalTarget(&aOriginalTarget); RETVAL = aOriginalTarget; OUTPUT: RETVAL ## GetExplicitOriginalTarget(nsIDOMEventTarget * *aExplicitOriginalTarget) nsIDOMEventTarget * moz_dom_GetExplicitOriginalTarget (nsevent) nsIDOMNSEvent *nsevent; PREINIT: nsIDOMEventTarget * aExplicitOriginalTarget; CODE: nsevent->GetExplicitOriginalTarget(&aExplicitOriginalTarget); RETVAL = aExplicitOriginalTarget; OUTPUT: RETVAL ## GetTmpRealOriginalTarget(nsIDOMEventTarget * *aTmpRealOriginalTarget) nsIDOMEventTarget * moz_dom_GetTmpRealOriginalTarget (nsevent) nsIDOMNSEvent *nsevent; PREINIT: nsIDOMEventTarget * aTmpRealOriginalTarget; CODE: nsevent->GetTmpRealOriginalTarget(&aTmpRealOriginalTarget); RETVAL = aTmpRealOriginalTarget; OUTPUT: RETVAL ## PreventBubble(void) void moz_dom_PreventBubble (nsevent) nsIDOMNSEvent *nsevent; CODE: nsevent->PreventBubble(); ## PreventCapture(void) void moz_dom_PreventCapture (nsevent) nsIDOMNSEvent *nsevent; CODE: nsevent->PreventCapture(); ## GetIsTrusted(PRBool *aIsTrusted) PRBool moz_dom_GetIsTrusted (nsevent) nsIDOMNSEvent *nsevent; PREINIT: PRBool aIsTrusted; CODE: nsevent->GetIsTrusted(&aIsTrusted); RETVAL = aIsTrusted; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::UIEvent PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMUIEvent.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMUIEVENT_IID) static nsIID nsIDOMUIEvent::GetIID() CODE: const nsIID &id = nsIDOMUIEvent::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDetail(PRInt32 *aDetail) PRInt32 moz_dom_GetDetail (event) nsIDOMUIEvent *event; PREINIT: PRInt32 detail; CODE: event->GetDetail(&detail); RETVAL = detail; OUTPUT: RETVAL ## GetView(nsIDOMAbstractView * *aView) nsIDOMAbstractView * moz_dom_GetView (event) nsIDOMUIEvent *event; PREINIT: nsIDOMAbstractView *view; CODE: event->GetView(&view); RETVAL = view; OUTPUT: RETVAL ## InitUIEvent(const nsAString & typeArg, PRBool canBubbleArg, PRBool cancelableArg, nsIDOMAbstractView *viewArg, PRInt32 detailArg) void moz_dom_InitUIEvent (event, eventtype, canbubble, cancelable, detail) nsIDOMUIEvent *event; nsEmbedString eventtype; PRBool canbubble; PRBool cancelable; PRInt32 detail; CODE: event->InitUIEvent(eventtype, canbubble, cancelable, nsnull, detail); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSUIEvent PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSUIEvent.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSUIEVENT_IID) static nsIID nsIDOMNSUIEvent::GetIID() CODE: const nsIID &id = nsIDOMNSUIEvent::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetPreventDefault(PRBool *_retval) PRBool moz_dom_GetPreventDefault (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRBool _retval; CODE: nsuievent->GetPreventDefault(&_retval); RETVAL = _retval; OUTPUT: RETVAL ## GetLayerX(PRInt32 *aLayerX) PRInt32 moz_dom_GetLayerX (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRInt32 aLayerX; CODE: nsuievent->GetLayerX(&aLayerX); RETVAL = aLayerX; OUTPUT: RETVAL ## GetLayerY(PRInt32 *aLayerY) PRInt32 moz_dom_GetLayerY (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRInt32 aLayerY; CODE: nsuievent->GetLayerY(&aLayerY); RETVAL = aLayerY; OUTPUT: RETVAL ## GetPageX(PRInt32 *aPageX) PRInt32 moz_dom_GetPageX (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRInt32 aPageX; CODE: nsuievent->GetPageX(&aPageX); RETVAL = aPageX; OUTPUT: RETVAL ## GetPageY(PRInt32 *aPageY) PRInt32 moz_dom_GetPageY (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRInt32 aPageY; CODE: nsuievent->GetPageY(&aPageY); RETVAL = aPageY; OUTPUT: RETVAL ## GetWhich(PRUint32 *aWhich) PRUint32 moz_dom_GetWhich (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRUint32 aWhich; CODE: nsuievent->GetWhich(&aWhich); RETVAL = aWhich; OUTPUT: RETVAL ## GetRangeParent(nsIDOMNode * *aRangeParent) nsIDOMNode * moz_dom_GetRangeParent (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: nsIDOMNode * aRangeParent; CODE: nsuievent->GetRangeParent(&aRangeParent); RETVAL = aRangeParent; OUTPUT: RETVAL ## GetRangeOffset(PRInt32 *aRangeOffset) PRInt32 moz_dom_GetRangeOffset (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRInt32 aRangeOffset; CODE: nsuievent->GetRangeOffset(&aRangeOffset); RETVAL = aRangeOffset; OUTPUT: RETVAL ## GetCancelBubble(PRBool *aCancelBubble) PRBool moz_dom_GetCancelBubble (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRBool aCancelBubble; CODE: nsuievent->GetCancelBubble(&aCancelBubble); RETVAL = aCancelBubble; OUTPUT: RETVAL ## SetCancelBubble(PRBool aCancelBubble) void moz_dom_SetCancelBubble (nsuievent, aCancelBubble) nsIDOMNSUIEvent *nsuievent; PRBool aCancelBubble; CODE: nsuievent->SetCancelBubble(aCancelBubble); ## GetIsChar(PRBool *aIsChar) PRBool moz_dom_GetIsChar (nsuievent) nsIDOMNSUIEvent *nsuievent; PREINIT: PRBool aIsChar; CODE: nsuievent->GetIsChar(&aIsChar); RETVAL = aIsChar; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::DocumentEvent PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMDocumentEvent.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDOCUMENTEVENT_IID) static nsIID nsIDOMDocumentEvent::GetIID() CODE: const nsIID &id = nsIDOMDocumentEvent::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## CreateEvent(const nsAString & eventType, nsIDOMEvent **_retval) nsIDOMEvent * moz_dom_CreateEvent (docevent, eventtype) nsIDOMDocumentEvent *docevent; nsEmbedString eventtype; PREINIT: nsIDOMEvent *event; CODE: /* XXX: this can throw an exception, so should check... */ docevent->CreateEvent(eventtype, &event); RETVAL = event; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::MouseEvent PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMMouseEvent.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMMOUSEEVENT_IID) static nsIID nsIDOMMouseEvent::GetIID() CODE: const nsIID &id = nsIDOMMouseEvent::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetScreenX(PRInt32 *aScreenX), etc. PRInt32 moz_dom_GetScreenX (event) nsIDOMMouseEvent *event; ALIAS: Mozilla::DOM::MouseEvent::GetScreenY = 1 Mozilla::DOM::MouseEvent::GetClientX = 2 Mozilla::DOM::MouseEvent::GetClientY = 3 PREINIT: PRInt32 pos; CODE: switch (ix) { case 0: event->GetScreenX(&pos); break; case 1: event->GetScreenY(&pos); break; case 2: event->GetClientX(&pos); break; case 3: event->GetClientY(&pos); break; default: pos = 0; } RETVAL = pos; OUTPUT: RETVAL ## GetCtrlKey(PRBool *aCtrlKey), etc. PRBool moz_dom_GetCtrlKey (event) nsIDOMMouseEvent *event; ALIAS: Mozilla::DOM::MouseEvent::GetShiftKey = 1 Mozilla::DOM::MouseEvent::GetAltKey = 2 Mozilla::DOM::MouseEvent::GetMetaKey = 3 PREINIT: PRBool key; CODE: switch (ix) { case 0: event->GetCtrlKey(&key); break; case 1: event->GetShiftKey(&key); break; case 2: event->GetAltKey(&key); break; case 3: event->GetMetaKey(&key); break; default: key = 0; } RETVAL = key; OUTPUT: RETVAL ## GetButton(PRUint16 *aButton) PRUint16 moz_dom_GetButton (event) nsIDOMMouseEvent *event; PREINIT: PRUint16 button; CODE: event->GetButton(&button); RETVAL = button; OUTPUT: RETVAL ## GetRelatedTarget(nsIDOMEventTarget * *aRelatedTarget) nsIDOMEventTarget * moz_dom_GetTarget (event) nsIDOMMouseEvent *event PREINIT: nsIDOMEventTarget *target; CODE: event->GetRelatedTarget(&target); RETVAL = target; OUTPUT: RETVAL ## InitMouseEvent(const nsAString & typeArg, PRBool canBubbleArg, PRBool cancelableArg, nsIDOMAbstractView *viewArg, PRInt32 detailArg, PRInt32 screenXArg, PRInt32 screenYArg, PRInt32 clientXArg, PRInt32 clientYArg, PRBool ctrlKeyArg, PRBool altKeyArg, PRBool shiftKeyArg, PRBool metaKeyArg, PRUint16 buttonArg, nsIDOMEventTarget *relatedTargetArg) void moz_dom_InitMouseEvent (event, eventtype, canbubble, cancelable, detail, screenx, screeny, clientx, clienty, ctrlkey, altkey, shiftkey, metakey, button, target) nsIDOMMouseEvent *event; nsEmbedString eventtype; PRBool canbubble; PRBool cancelable; PRInt32 detail; PRInt32 screenx; PRInt32 screeny; PRInt32 clientx; PRInt32 clienty; PRBool ctrlkey; PRBool altkey; PRBool shiftkey; PRBool metakey; PRUint16 button; nsIDOMEventTarget *target; CODE: event->InitMouseEvent(eventtype, canbubble, cancelable, nsnull, detail, screenx, screeny, clientx, clienty, ctrlkey, altkey, shiftkey, metakey, button, target); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::KeyEvent PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMKeyEvent.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMKEYEVENT_IID) static nsIID nsIDOMKeyEvent::GetIID() CODE: const nsIID &id = nsIDOMKeyEvent::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCharCode(PRUint32 *aCharCode), etc. PRUint32 moz_dom_GetCharCode (event) nsIDOMKeyEvent *event; ALIAS: Mozilla::DOM::KeyEvent::GetKeyCode = 1 PREINIT: PRUint32 code; CODE: switch (ix) { case 0: event->GetCharCode(&code); break; case 1: event->GetKeyCode(&code); break; default: code = 0; } RETVAL = code; OUTPUT: RETVAL ## GetCtrlKey(PRBool *aCtrlKey), etc. PRBool moz_dom_GetCtrlKey (event) nsIDOMKeyEvent *event; ALIAS: Mozilla::DOM::KeyEvent::GetShiftKey = 1 Mozilla::DOM::KeyEvent::GetAltKey = 2 Mozilla::DOM::KeyEvent::GetMetaKey = 3 PREINIT: PRBool key; CODE: switch (ix) { case 0: event->GetCtrlKey(&key); break; case 1: event->GetShiftKey(&key); break; case 2: event->GetAltKey(&key); break; case 3: event->GetMetaKey(&key); break; default: key = 0; } RETVAL = key; OUTPUT: RETVAL ## InitKeyEvent(const nsAString & typeArg, PRBool canBubbleArg, PRBool cancelableArg, nsIDOMAbstractView *viewArg, PRBool ctrlKeyArg, PRBool altKeyArg, PRBool shiftKeyArg, PRBool metaKeyArg, PRUint32 keyCodeArg, PRUint32 charCodeArg) void moz_dom_InitKeyEvent (event, eventtype, canbubble, cancelable, ctrlkey, altkey, shiftkey, metakey, keycode, charcode) nsIDOMKeyEvent *event; nsEmbedString eventtype; PRBool canbubble; PRBool cancelable; PRBool ctrlkey; PRBool altkey; PRBool shiftkey; PRBool metakey; PRUint32 keycode; PRUint32 charcode; CODE: event->InitKeyEvent(eventtype, canbubble, cancelable, nsnull, ctrlkey, altkey, shiftkey, metakey, keycode, charcode); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::MutationEvent PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMMutationEvent.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMMUTATIONEVENT_IID) static nsIID nsIDOMMutationEvent::GetIID() CODE: const nsIID &id = nsIDOMMutationEvent::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetRelatedNode(nsIDOMNode * *aRelatedNode) nsIDOMNode * moz_dom_GetRelatedNode (mutationevent) nsIDOMMutationEvent *mutationevent; PREINIT: nsIDOMNode *node; CODE: mutationevent->GetRelatedNode(&node); RETVAL = node; OUTPUT: RETVAL ## GetPrevValue(nsAString & aPrevValue) nsEmbedString moz_dom_GetPrevValue (mutationevent) nsIDOMMutationEvent *mutationevent; PREINIT: nsEmbedString value; CODE: mutationevent->GetPrevValue(value); RETVAL = value; OUTPUT: RETVAL ## GetNewValue(nsAString & aNewValue) nsEmbedString moz_dom_GetNewValue (mutationevent) nsIDOMMutationEvent *mutationevent; PREINIT: nsEmbedString value; CODE: mutationevent->GetNewValue(value); RETVAL = value; OUTPUT: RETVAL ## GetAttrName(nsAString & aAttrName) nsEmbedString moz_dom_GetAttrName (mutationevent) nsIDOMMutationEvent *mutationevent; PREINIT: nsEmbedString name; CODE: mutationevent->GetAttrName(name); RETVAL = name; OUTPUT: RETVAL ## GetAttrChange(PRUint16 *aAttrChange) PRUint16 moz_dom_GetAttrChange (mutationevent) nsIDOMMutationEvent *mutationevent; PREINIT: PRUint16 change; CODE: mutationevent->GetAttrChange(&change); RETVAL = change; OUTPUT: RETVAL ## InitMutationEvent(const nsAString & typeArg, PRBool canBubbleArg, PRBool cancelableArg, nsIDOMNode *relatedNodeArg, const nsAString & prevValueArg, const nsAString & newValueArg, const nsAString & attrNameArg, PRUint16 attrChangeArg) void moz_dom_InitMutationEvent (event, eventtype, canbubble, cancelable, node, prevval, newval, attrname, attrchange) nsIDOMMutationEvent *event; nsEmbedString eventtype; PRBool canbubble; PRBool cancelable; nsIDOMNode *node; nsEmbedString prevval; nsEmbedString newval; nsEmbedString attrname; PRUint16 attrchange; CODE: event->InitMutationEvent(eventtype, canbubble, cancelable, node, prevval, newval, attrname, attrchange); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::EventTarget PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMEventTarget.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMEVENTTARGET_IID) static nsIID nsIDOMEventTarget::GetIID() CODE: const nsIID id = nsIDOMEventTarget::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL # INCLUDE: perl -pe 's/XXXXX/DOMEventTarget/g' GetIID.xsh | #ifdef MDEXP_EVENT_LISTENER ## AddEventListener(const nsAString & type, nsIDOMEventListener *listener, PRBool useCapture) ## RemoveEventListener(const nsAString & type, nsIDOMEventListener *listener, PRBool useCapture) void moz_dom_AddEventListener (target, type, listener, usecapture) nsIDOMEventTarget *target; nsEmbedString type; MozDomEventListener *listener; PRBool usecapture; ALIAS: Mozilla::DOM::EventTarget::RemoveEventListener = 1 CODE: switch (ix) { case 0: /* XXX: here is where we should probably actually create the MozDomEventListener */ target->AddEventListener(type, listener, usecapture); break; case 1: target->RemoveEventListener(type, listener, usecapture); /* XXX: here is where we should probably actually destroy the MozDomEventListener */ break; default: break; } #endif /* MDEXP_EVENT_LISTENER */ ## DispatchEvent(nsIDOMEvent *evt, PRBool *_retval) PRBool moz_dom_DispatchEvent (target, event) nsIDOMEventTarget *target; nsIDOMEvent *event; PREINIT: PRBool rv; CODE: target->DispatchEvent(event, &rv); RETVAL = rv; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::EventListener PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMEventListener.h #ifdef MDEXP_EVENT_LISTENER ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMEVENTLISTENER_IID) static nsIID nsIDOMEventListener::GetIID() CODE: const nsIID &id = nsIDOMEventListener::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## See C++ class at the top of this file. ## MozDomEventListner isa nsIDOMEventListener. MozDomEventListener * MozDomEventListener::new(handler) SV *handler; PREINIT: MozDomEventListener *listener; CODE: listener = new MozDomEventListener(handler); RETVAL = listener; OUTPUT: RETVAL void MozDomEventListener::DESTROY() ## HandleEvent(nsIDOMEvent *event) ## See the C++ class at the top of this file #endif /* MDEXP_EVENT_LISTENER */ # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Window PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMWindow.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMWINDOW_IID) static nsIID nsIDOMWindow::GetIID() CODE: const nsIID &id = nsIDOMWindow::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (window) nsIDOMWindow *window; PREINIT: nsEmbedString name; CODE: window->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (window, name) nsIDOMWindow *window; nsEmbedString name; CODE: /* XXX: can this thrown an exception? */ window->SetName(name); ## SizeToContent(void) void moz_dom_SizeToContent (window) nsIDOMWindow *window; CODE: window->SizeToContent(); ## GetDocument(nsIDOMDocument * *aDocument) nsIDOMDocument * moz_dom_GetDocument (window) nsIDOMWindow *window; PREINIT: nsIDOMDocument *doc; CODE: window->GetDocument(&doc); RETVAL = doc; OUTPUT: RETVAL ## GetFrames(nsIDOMWindowCollection * *aFrames) nsIDOMWindowCollection * moz_dom_GetFrames_windowcollection (window) nsIDOMWindow *window; PREINIT: nsIDOMWindowCollection *frames; CODE: window->GetFrames(&frames); RETVAL = frames; OUTPUT: RETVAL ## GetParent(nsIDOMWindow * *aParent), etc. nsIDOMWindow * moz_dom_GetParent (window) nsIDOMWindow *window; ALIAS: Mozilla::DOM::Window::GetTop = 1 PREINIT: nsIDOMWindow *retwindow; CODE: switch (ix) { case 0: window->GetParent(&retwindow); break; case 1: window->GetTop(&retwindow); break; default: break; } RETVAL = retwindow; OUTPUT: RETVAL ## GetTextZoom(float *aTextZoom) float moz_dom_GetTextZoom (window) nsIDOMWindow *window; PREINIT: float zoom; CODE: window->GetTextZoom(&zoom); RETVAL = zoom; OUTPUT: RETVAL ## SetTextZoom(float aTextZoom) void moz_dom_SetTextZoom (window, zoom) nsIDOMWindow *window; float zoom; CODE: window->SetTextZoom(zoom); ## GetSelection(nsISelection **_retval) nsISelection * moz_dom_GetSelection (window) nsIDOMWindow *window; PREINIT: nsISelection *sel; CODE: window->GetSelection(&sel); RETVAL = sel; OUTPUT: RETVAL =begin comment /** * Accessor for the object that controls whether or not scrollbars * are shown in this window. * * This attribute is "replaceable" in JavaScript */ /* readonly attribute nsIDOMBarProp scrollbars; */ #=for apidoc Mozilla::DOM::Window::GetScrollbars # #=for signature $window->GetScrollbars(nsIDOMBarProp * *aScrollbars) # # # #=cut # ### GetScrollbars(nsIDOMBarProp * *aScrollbars) #somereturn * #moz_dom_GetScrollbars (window, aScrollbars) # nsIDOMWindow *window; # nsIDOMBarProp * *aScrollbars ; # PREINIT: # # CODE: # window->GetScrollbars(&); # RETVAL = ; # OUTPUT: # RETVAL =end comment =cut ## GetScrollX(PRInt32 *aScrollX) PRInt32 moz_dom_GetScrollX (window) nsIDOMWindow *window; PREINIT: PRInt32 aScrollX; CODE: window->GetScrollX(&aScrollX); RETVAL = aScrollX; OUTPUT: RETVAL ## GetScrollY(PRInt32 *aScrollY) PRInt32 moz_dom_GetScrollY (window) nsIDOMWindow *window; PREINIT: PRInt32 aScrollY; CODE: window->GetScrollY(&aScrollY); RETVAL = aScrollY; OUTPUT: RETVAL ## ScrollTo(PRInt32 xScroll, PRInt32 yScroll) void moz_dom_ScrollTo (window, xScroll, yScroll) nsIDOMWindow *window; PRInt32 xScroll; PRInt32 yScroll; CODE: window->ScrollTo(xScroll, yScroll); ## ScrollBy(PRInt32 xScrollDif, PRInt32 yScrollDif) void moz_dom_ScrollBy (window, xScrollDif, yScrollDif) nsIDOMWindow *window; PRInt32 xScrollDif; PRInt32 yScrollDif; CODE: window->ScrollBy(xScrollDif, yScrollDif); ## ScrollByLines(PRInt32 numLines) void moz_dom_ScrollByLines (window, numLines) nsIDOMWindow *window; PRInt32 numLines; CODE: window->ScrollByLines(numLines); ## ScrollByPages(PRInt32 numPages) void moz_dom_ScrollByPages (window, numPages) nsIDOMWindow *window; PRInt32 numPages; CODE: window->ScrollByPages(numPages); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Window2 PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMWindow2.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMWINDOW2_IID) static nsIID nsIDOMWindow2::GetIID() CODE: const nsIID &id = nsIDOMWindow2::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetWindowRoot(nsIDOMEventTarget * *aWindowRoot) nsIDOMEventTarget * moz_dom_GetWindowRoot (window2) nsIDOMWindow2 *window2; PREINIT: nsIDOMEventTarget * aWindowRoot; CODE: window2->GetWindowRoot(&aWindowRoot); RETVAL = aWindowRoot; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::WindowInternal PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMWindowInternal.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMWINDOWINTERNAL_IID) static nsIID nsIDOMWindowInternal::GetIID() CODE: const nsIID &id = nsIDOMWindowInternal::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetWindow(nsIDOMWindowInternal * *aWindow) nsIDOMWindowInternal * moz_dom_GetWindow (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMWindowInternal * aWindow; CODE: windowinternal->GetWindow(&aWindow); RETVAL = aWindow; OUTPUT: RETVAL ## GetSelf(nsIDOMWindowInternal * *aSelf) nsIDOMWindowInternal * moz_dom_GetSelf (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMWindowInternal * aSelf; CODE: windowinternal->GetSelf(&aSelf); RETVAL = aSelf; OUTPUT: RETVAL ## GetNavigator(nsIDOMNavigator * *aNavigator) nsIDOMNavigator * moz_dom_GetNavigator (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMNavigator * aNavigator; CODE: windowinternal->GetNavigator(&aNavigator); RETVAL = aNavigator; OUTPUT: RETVAL ## GetScreen(nsIDOMScreen * *aScreen) nsIDOMScreen * moz_dom_GetScreen (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMScreen * aScreen; CODE: windowinternal->GetScreen(&aScreen); RETVAL = aScreen; OUTPUT: RETVAL ## GetHistory(nsIDOMHistory * *aHistory) nsIDOMHistory * moz_dom_GetHistory (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMHistory * aHistory; CODE: windowinternal->GetHistory(&aHistory); RETVAL = aHistory; OUTPUT: RETVAL ## GetContent(nsIDOMWindow * *aContent) nsIDOMWindow * moz_dom_GetContent (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMWindow * aContent; CODE: windowinternal->GetContent(&aContent); RETVAL = aContent; OUTPUT: RETVAL #=for apidoc Mozilla::DOM::WindowInternal::GetPrompter # #=for signature $prompter = $windowinternal->GetPrompter() # # # #=cut # ### GetPrompter(nsIPrompt * *aPrompter) #nsIPrompt * #moz_dom_GetPrompter (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIPrompt * aPrompter; # CODE: # windowinternal->GetPrompter(&aPrompter); # RETVAL = aPrompter; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WindowInternal::GetMenubar # #=for signature $menubar = $windowinternal->GetMenubar() # # # #=cut # ### GetMenubar(nsIDOMBarProp * *aMenubar) #nsIDOMBarProp * #moz_dom_GetMenubar (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIDOMBarProp * aMenubar; # CODE: # windowinternal->GetMenubar(&aMenubar); # RETVAL = aMenubar; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WindowInternal::GetToolbar # #=for signature $toolbar = $windowinternal->GetToolbar() # # # #=cut # ### GetToolbar(nsIDOMBarProp * *aToolbar) #nsIDOMBarProp * #moz_dom_GetToolbar (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIDOMBarProp * aToolbar; # CODE: # windowinternal->GetToolbar(&aToolbar); # RETVAL = aToolbar; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WindowInternal::GetLocationbar # #=for signature $locationbar = $windowinternal->GetLocationbar() # # # #=cut # ### GetLocationbar(nsIDOMBarProp * *aLocationbar) #nsIDOMBarProp * #moz_dom_GetLocationbar (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIDOMBarProp * aLocationbar; # CODE: # windowinternal->GetLocationbar(&aLocationbar); # RETVAL = aLocationbar; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WindowInternal::GetPersonalbar # #=for signature $personalbar = $windowinternal->GetPersonalbar() # # # #=cut # ### GetPersonalbar(nsIDOMBarProp * *aPersonalbar) #nsIDOMBarProp * #moz_dom_GetPersonalbar (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIDOMBarProp * aPersonalbar; # CODE: # windowinternal->GetPersonalbar(&aPersonalbar); # RETVAL = aPersonalbar; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WindowInternal::GetStatusbar # #=for signature $statusbar = $windowinternal->GetStatusbar() # # # #=cut # ### GetStatusbar(nsIDOMBarProp * *aStatusbar) #nsIDOMBarProp * #moz_dom_GetStatusbar (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIDOMBarProp * aStatusbar; # CODE: # windowinternal->GetStatusbar(&aStatusbar); # RETVAL = aStatusbar; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WindowInternal::GetDirectories # #=for signature $directories = $windowinternal->GetDirectories() # # # #=cut # ### GetDirectories(nsIDOMBarProp * *aDirectories) #nsIDOMBarProp * #moz_dom_GetDirectories (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIDOMBarProp * aDirectories; # CODE: # windowinternal->GetDirectories(&aDirectories); # RETVAL = aDirectories; # OUTPUT: # RETVAL ## GetClosed(PRBool *aClosed) PRBool moz_dom_GetClosed (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRBool aClosed; CODE: windowinternal->GetClosed(&aClosed); RETVAL = aClosed; OUTPUT: RETVAL #=for apidoc Mozilla::DOM::WindowInternal::GetCrypto # #=for signature $crypto = $windowinternal->GetCrypto() # # # #=cut # ### GetCrypto(nsIDOMCrypto * *aCrypto) #nsIDOMCrypto * #moz_dom_GetCrypto (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIDOMCrypto * aCrypto; # CODE: # windowinternal->GetCrypto(&aCrypto); # RETVAL = aCrypto; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WindowInternal::GetPkcs11 # #=for signature $pkcs11 = $windowinternal->GetPkcs11() # # # #=cut # ### GetPkcs11(nsIDOMPkcs11 * *aPkcs11) #nsIDOMPkcs11 * #moz_dom_GetPkcs11 (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIDOMPkcs11 * aPkcs11; # CODE: # windowinternal->GetPkcs11(&aPkcs11); # RETVAL = aPkcs11; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WindowInternal::GetControllers # #=for signature $controllers = $windowinternal->GetControllers() # # # #=cut # ### GetControllers(nsIControllers * *aControllers) #nsIControllers * #moz_dom_GetControllers (windowinternal) # nsIDOMWindowInternal *windowinternal; # PREINIT: # nsIControllers * aControllers; # CODE: # windowinternal->GetControllers(&aControllers); # RETVAL = aControllers; # OUTPUT: # RETVAL ## GetOpener(nsIDOMWindowInternal * *aOpener) nsIDOMWindowInternal * moz_dom_GetOpener (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMWindowInternal * aOpener; CODE: windowinternal->GetOpener(&aOpener); RETVAL = aOpener; OUTPUT: RETVAL ## SetOpener(nsIDOMWindowInternal * aOpener) void moz_dom_SetOpener (windowinternal, aOpener) nsIDOMWindowInternal *windowinternal; nsIDOMWindowInternal * aOpener; CODE: windowinternal->SetOpener(aOpener); ## GetStatus(nsAString & aStatus) nsEmbedString moz_dom_GetStatus (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsEmbedString aStatus; CODE: windowinternal->GetStatus(aStatus); RETVAL = aStatus; OUTPUT: RETVAL ## SetStatus(const nsAString & aStatus) void moz_dom_SetStatus (windowinternal, aStatus) nsIDOMWindowInternal *windowinternal; nsEmbedString aStatus; CODE: windowinternal->SetStatus(aStatus); ## GetDefaultStatus(nsAString & aDefaultStatus) nsEmbedString moz_dom_GetDefaultStatus (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsEmbedString aDefaultStatus; CODE: windowinternal->GetDefaultStatus(aDefaultStatus); RETVAL = aDefaultStatus; OUTPUT: RETVAL ## SetDefaultStatus(const nsAString & aDefaultStatus) void moz_dom_SetDefaultStatus (windowinternal, aDefaultStatus) nsIDOMWindowInternal *windowinternal; nsEmbedString aDefaultStatus; CODE: windowinternal->SetDefaultStatus(aDefaultStatus); ## GetLocation(nsIDOMLocation * *aLocation) nsIDOMLocation * moz_dom_GetLocation (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMLocation * aLocation; CODE: windowinternal->GetLocation(&aLocation); RETVAL = aLocation; OUTPUT: RETVAL ## GetInnerWidth(PRInt32 *aInnerWidth) PRInt32 moz_dom_GetInnerWidth (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aInnerWidth; CODE: windowinternal->GetInnerWidth(&aInnerWidth); RETVAL = aInnerWidth; OUTPUT: RETVAL ## SetInnerWidth(PRInt32 aInnerWidth) void moz_dom_SetInnerWidth (windowinternal, aInnerWidth) nsIDOMWindowInternal *windowinternal; PRInt32 aInnerWidth; CODE: windowinternal->SetInnerWidth(aInnerWidth); ## GetInnerHeight(PRInt32 *aInnerHeight) PRInt32 moz_dom_GetInnerHeight (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aInnerHeight; CODE: windowinternal->GetInnerHeight(&aInnerHeight); RETVAL = aInnerHeight; OUTPUT: RETVAL ## SetInnerHeight(PRInt32 aInnerHeight) void moz_dom_SetInnerHeight (windowinternal, aInnerHeight) nsIDOMWindowInternal *windowinternal; PRInt32 aInnerHeight; CODE: windowinternal->SetInnerHeight(aInnerHeight); ## GetOuterWidth(PRInt32 *aOuterWidth) PRInt32 moz_dom_GetOuterWidth (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aOuterWidth; CODE: windowinternal->GetOuterWidth(&aOuterWidth); RETVAL = aOuterWidth; OUTPUT: RETVAL ## SetOuterWidth(PRInt32 aOuterWidth) void moz_dom_SetOuterWidth (windowinternal, aOuterWidth) nsIDOMWindowInternal *windowinternal; PRInt32 aOuterWidth; CODE: windowinternal->SetOuterWidth(aOuterWidth); ## GetOuterHeight(PRInt32 *aOuterHeight) PRInt32 moz_dom_GetOuterHeight (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aOuterHeight; CODE: windowinternal->GetOuterHeight(&aOuterHeight); RETVAL = aOuterHeight; OUTPUT: RETVAL ## SetOuterHeight(PRInt32 aOuterHeight) void moz_dom_SetOuterHeight (windowinternal, aOuterHeight) nsIDOMWindowInternal *windowinternal; PRInt32 aOuterHeight; CODE: windowinternal->SetOuterHeight(aOuterHeight); ## GetScreenX(PRInt32 *aScreenX) PRInt32 moz_dom_GetScreenX (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aScreenX; CODE: windowinternal->GetScreenX(&aScreenX); RETVAL = aScreenX; OUTPUT: RETVAL ## SetScreenX(PRInt32 aScreenX) void moz_dom_SetScreenX (windowinternal, aScreenX) nsIDOMWindowInternal *windowinternal; PRInt32 aScreenX; CODE: windowinternal->SetScreenX(aScreenX); ## GetScreenY(PRInt32 *aScreenY) PRInt32 moz_dom_GetScreenY (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aScreenY; CODE: windowinternal->GetScreenY(&aScreenY); RETVAL = aScreenY; OUTPUT: RETVAL ## SetScreenY(PRInt32 aScreenY) void moz_dom_SetScreenY (windowinternal, aScreenY) nsIDOMWindowInternal *windowinternal; PRInt32 aScreenY; CODE: windowinternal->SetScreenY(aScreenY); ## GetPageXOffset(PRInt32 *aPageXOffset) PRInt32 moz_dom_GetPageXOffset (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aPageXOffset; CODE: windowinternal->GetPageXOffset(&aPageXOffset); RETVAL = aPageXOffset; OUTPUT: RETVAL ## GetPageYOffset(PRInt32 *aPageYOffset) PRInt32 moz_dom_GetPageYOffset (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aPageYOffset; CODE: windowinternal->GetPageYOffset(&aPageYOffset); RETVAL = aPageYOffset; OUTPUT: RETVAL ## GetScrollMaxX(PRInt32 *aScrollMaxX) PRInt32 moz_dom_GetScrollMaxX (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aScrollMaxX; CODE: windowinternal->GetScrollMaxX(&aScrollMaxX); RETVAL = aScrollMaxX; OUTPUT: RETVAL ## GetScrollMaxY(PRInt32 *aScrollMaxY) PRInt32 moz_dom_GetScrollMaxY (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRInt32 aScrollMaxY; CODE: windowinternal->GetScrollMaxY(&aScrollMaxY); RETVAL = aScrollMaxY; OUTPUT: RETVAL ## GetLength(PRUint32 *aLength) PRUint32 moz_dom_GetLength (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRUint32 aLength; CODE: windowinternal->GetLength(&aLength); RETVAL = aLength; OUTPUT: RETVAL ## GetFullScreen(PRBool *aFullScreen) PRBool moz_dom_GetFullScreen (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: PRBool aFullScreen; CODE: windowinternal->GetFullScreen(&aFullScreen); RETVAL = aFullScreen; OUTPUT: RETVAL ## SetFullScreen(PRBool aFullScreen) void moz_dom_SetFullScreen (windowinternal, aFullScreen) nsIDOMWindowInternal *windowinternal; PRBool aFullScreen; CODE: windowinternal->SetFullScreen(aFullScreen); ## Alert(const nsAString & text) void moz_dom_Alert (windowinternal, text) nsIDOMWindowInternal *windowinternal; nsEmbedString text; CODE: windowinternal->Alert(text); ## Confirm(const nsAString & text, PRBool *_retval) PRBool moz_dom_Confirm (windowinternal, text) nsIDOMWindowInternal *windowinternal; nsEmbedString text; PREINIT: PRBool _retval; CODE: windowinternal->Confirm(text, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## Prompt(const nsAString & aMessage, const nsAString & aInitial, const nsAString & aTitle, PRUint32 aSavePassword, nsAString & _retval) nsEmbedString moz_dom_Prompt (windowinternal, aMessage, aInitial, aTitle, aSavePassword) nsIDOMWindowInternal *windowinternal; nsEmbedString aMessage; nsEmbedString aInitial; nsEmbedString aTitle; PRUint32 aSavePassword; PREINIT: nsEmbedString _retval; CODE: windowinternal->Prompt(aMessage, aInitial, aTitle, aSavePassword, _retval); RETVAL = _retval; OUTPUT: RETVAL ## Focus(void) void moz_dom_Focus (windowinternal) nsIDOMWindowInternal *windowinternal; CODE: windowinternal->Focus(); ## Blur(void) void moz_dom_Blur (windowinternal) nsIDOMWindowInternal *windowinternal; CODE: windowinternal->Blur(); ## Back(void) void moz_dom_Back (windowinternal) nsIDOMWindowInternal *windowinternal; CODE: windowinternal->Back(); ## Forward(void) void moz_dom_Forward (windowinternal) nsIDOMWindowInternal *windowinternal; CODE: windowinternal->Forward(); ## Home(void) void moz_dom_Home (windowinternal) nsIDOMWindowInternal *windowinternal; CODE: windowinternal->Home(); ## Stop(void) void moz_dom_Stop (windowinternal) nsIDOMWindowInternal *windowinternal; CODE: windowinternal->Stop(); ## Print(void) void moz_dom_Print (windowinternal) nsIDOMWindowInternal *windowinternal; CODE: windowinternal->Print(); ## MoveTo(PRInt32 xPos, PRInt32 yPos) void moz_dom_MoveTo (windowinternal, xPos, yPos) nsIDOMWindowInternal *windowinternal; PRInt32 xPos; PRInt32 yPos; CODE: windowinternal->MoveTo(xPos, yPos); ## MoveBy(PRInt32 xDif, PRInt32 yDif) void moz_dom_MoveBy (windowinternal, xDif, yDif) nsIDOMWindowInternal *windowinternal; PRInt32 xDif; PRInt32 yDif; CODE: windowinternal->MoveBy(xDif, yDif); ## ResizeTo(PRInt32 width, PRInt32 height) void moz_dom_ResizeTo (windowinternal, width, height) nsIDOMWindowInternal *windowinternal; PRInt32 width; PRInt32 height; CODE: windowinternal->ResizeTo(width, height); ## ResizeBy(PRInt32 widthDif, PRInt32 heightDif) void moz_dom_ResizeBy (windowinternal, widthDif, heightDif) nsIDOMWindowInternal *windowinternal; PRInt32 widthDif; PRInt32 heightDif; CODE: windowinternal->ResizeBy(widthDif, heightDif); ## Scroll(PRInt32 xScroll, PRInt32 yScroll) void moz_dom_Scroll (windowinternal, xScroll, yScroll) nsIDOMWindowInternal *windowinternal; PRInt32 xScroll; PRInt32 yScroll; CODE: windowinternal->Scroll(xScroll, yScroll); ## Open(const nsAString & url, const nsAString & name, const nsAString & options, nsIDOMWindow **_retval) nsIDOMWindow * moz_dom_Open (windowinternal, url, name, options) nsIDOMWindowInternal *windowinternal; nsEmbedString url; nsEmbedString name; nsEmbedString options; PREINIT: nsIDOMWindow * _retval; CODE: windowinternal->Open(url, name, options, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## OpenDialog(const nsAString & url, const nsAString & name, const nsAString & options, nsISupports *aExtraArgument, nsIDOMWindow **_retval) nsIDOMWindow * moz_dom_OpenDialog (windowinternal, url, name, options, aExtraArgument) nsIDOMWindowInternal *windowinternal; nsEmbedString url; nsEmbedString name; nsEmbedString options; nsISupports * aExtraArgument; PREINIT: nsIDOMWindow * _retval; CODE: windowinternal->OpenDialog(url, name, options, aExtraArgument, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## Close(void) void moz_dom_Close (windowinternal) nsIDOMWindowInternal *windowinternal; CODE: windowinternal->Close(); ## UpdateCommands(const nsAString & action) void moz_dom_UpdateCommands (windowinternal, action) nsIDOMWindowInternal *windowinternal; nsEmbedString action; CODE: windowinternal->UpdateCommands(action); ## Find(const nsAString & str, PRBool caseSensitive, PRBool backwards, PRBool wrapAround, PRBool wholeWord, PRBool searchInFrames, PRBool showDialog, PRBool *_retval) PRBool moz_dom_Find (windowinternal, str, caseSensitive, backwards, wrapAround, wholeWord, searchInFrames, showDialog) nsIDOMWindowInternal *windowinternal; nsEmbedString str; PRBool caseSensitive; PRBool backwards; PRBool wrapAround; PRBool wholeWord; PRBool searchInFrames; PRBool showDialog; PREINIT: PRBool _retval; CODE: windowinternal->Find(str, caseSensitive, backwards, wrapAround, wholeWord, searchInFrames, showDialog, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## Atob(const nsAString & aAsciiString, nsAString & _retval) nsEmbedString moz_dom_Atob (windowinternal, aAsciiString) nsIDOMWindowInternal *windowinternal; nsEmbedString aAsciiString; PREINIT: nsEmbedString _retval; CODE: windowinternal->Atob(aAsciiString, _retval); RETVAL = _retval; OUTPUT: RETVAL ## Btoa(const nsAString & aBase64Data, nsAString & _retval) nsEmbedString moz_dom_Btoa (windowinternal, aBase64Data) nsIDOMWindowInternal *windowinternal; nsEmbedString aBase64Data; PREINIT: nsEmbedString _retval; CODE: windowinternal->Btoa(aBase64Data, _retval); RETVAL = _retval; OUTPUT: RETVAL ## GetFrameElement(nsIDOMElement * *aFrameElement) nsIDOMElement * moz_dom_GetFrameElement (windowinternal) nsIDOMWindowInternal *windowinternal; PREINIT: nsIDOMElement * aFrameElement; CODE: windowinternal->GetFrameElement(&aFrameElement); RETVAL = aFrameElement; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::WindowCollection PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMWindowCollection.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMWINDOWCOLLECTION_IID) static nsIID nsIDOMWindowCollection::GetIID() CODE: const nsIID &id = nsIDOMWindowCollection::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetLength(PRUint32 *aLength) PRUint32 moz_dom_GetLength (coll) nsIDOMWindowCollection *coll; PREINIT: PRUint32 len; CODE: coll->GetLength(&len); RETVAL = len; OUTPUT: RETVAL ## Item(PRUint32 index, nsIDOMWindow **_retval) nsIDOMWindow * moz_dom_Item (coll, i) nsIDOMWindowCollection *coll; PRUint32 i; PREINIT: nsIDOMWindow *window; CODE: coll->Item(i, &window); RETVAL = window; OUTPUT: RETVAL ## NamedItem(const nsAString & name, nsIDOMWindow **_retval) nsIDOMWindow * moz_dom_NamedItem (coll, name) nsIDOMWindowCollection *coll; nsEmbedString name; PREINIT: nsIDOMWindow *window; CODE: coll->NamedItem(name, &window); RETVAL = window; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Node PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMNode.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNODE_IID) static nsIID nsIDOMNode::GetIID() CODE: const nsIID &id = nsIDOMNode::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetNodeName(nsAString & aNodeName) nsEmbedString moz_dom_GetNodeName (node) nsIDOMNode *node; PREINIT: nsEmbedString name; CODE: node->GetNodeName(name); RETVAL = name; OUTPUT: RETVAL ## GetNodeValue(nsAString & aNodeValue) nsEmbedString moz_dom_GetNodeValue (node) nsIDOMNode *node; PREINIT: nsEmbedString value; CODE: node->GetNodeValue(value); RETVAL = value; OUTPUT: RETVAL ## SetNodeValue(const nsAString & aNodeValue) void moz_dom_SetNodeValue (node, value) nsIDOMNode *node; nsEmbedString value; CODE: node->SetNodeValue(value); ## GetNodeType(PRUint16 *aNodeType) PRUint16 moz_dom_GetNodeType (node) nsIDOMNode *node; PREINIT: PRUint16 type; CODE: node->GetNodeType(&type); RETVAL = type; OUTPUT: RETVAL ## GetParentNode(nsIDOMNode * *aParentNode) nsIDOMNode * moz_dom_GetParentNode (node) nsIDOMNode *node; PREINIT: nsIDOMNode *parent; CODE: node->GetParentNode(&parent); RETVAL = parent; OUTPUT: RETVAL # GetChildNodes(nsIDOMNodeList * *aChildNodes) nsIDOMNodeList * moz_dom_GetChildNodes_nodelist (node) nsIDOMNode *node; PREINIT: nsIDOMNodeList *nodelist; CODE: node->GetChildNodes(&nodelist); RETVAL = nodelist; OUTPUT: RETVAL ## GetFirstChild(nsIDOMNode * *aFirstChild) nsIDOMNode * moz_dom_GetFirstChild (node) nsIDOMNode *node; PREINIT: nsIDOMNode *child; CODE: node->GetFirstChild(&child); RETVAL = child; OUTPUT: RETVAL ## GetLastChild(nsIDOMNode * *aLastChild) nsIDOMNode * moz_dom_GetLastChild (node) nsIDOMNode *node; PREINIT: nsIDOMNode *child; CODE: node->GetLastChild(&child); RETVAL = child; OUTPUT: RETVAL ## GetPreviousSibling(nsIDOMNode * *aPreviousSibling) nsIDOMNode * moz_dom_GetPreviousSibling (node) nsIDOMNode *node; PREINIT: nsIDOMNode *bro; CODE: node->GetPreviousSibling(&bro); RETVAL = bro; OUTPUT: RETVAL ## GetNextSibling(nsIDOMNode * *aNextSibling) nsIDOMNode * moz_dom_GetNextSibling (node) nsIDOMNode *node; PREINIT: nsIDOMNode *bro; CODE: node->GetNextSibling(&bro); RETVAL = bro; OUTPUT: RETVAL ## GetAttributes(nsIDOMNamedNodeMap * *aAttributes) nsIDOMNamedNodeMap * moz_dom_GetAttributes_namednodemap (node) nsIDOMNode *node; PREINIT: nsIDOMNamedNodeMap *nodemap; CODE: node->GetAttributes(&nodemap); RETVAL = nodemap; OUTPUT: RETVAL ## GetOwnerDocument(nsIDOMDocument * *aOwnerDocument) nsIDOMDocument * moz_dom_GetOwnerDocument (node) nsIDOMNode *node; PREINIT: nsIDOMDocument *doc; CODE: node->GetOwnerDocument(&doc); RETVAL = doc; OUTPUT: RETVAL ## InsertBefore(nsIDOMNode *newChild, nsIDOMNode *refChild, nsIDOMNode **_retval) nsIDOMNode * moz_dom_InsertBefore (node, newChild, refChild=0) nsIDOMNode *node; nsIDOMNode *newChild; nsIDOMNode *refChild; PREINIT: nsIDOMNode *insert; CODE: /* raises (DOMException) */ node->InsertBefore(newChild, refChild, &insert); RETVAL = insert; OUTPUT: RETVAL ## ReplaceChild(nsIDOMNode *newChild, nsIDOMNode *oldChild, nsIDOMNode **_retval) nsIDOMNode * moz_dom_ReplaceChild (node, newChild, oldChild) nsIDOMNode *node; nsIDOMNode *newChild; nsIDOMNode *oldChild; PREINIT: nsIDOMNode *child; CODE: /* raises (DOMException) */ node->ReplaceChild(newChild, oldChild, &child); RETVAL = child; OUTPUT: RETVAL ## RemoveChild(nsIDOMNode *oldChild, nsIDOMNode **_retval) nsIDOMNode * moz_dom_RemoveChild (node, oldChild) nsIDOMNode *node; nsIDOMNode *oldChild; PREINIT: nsIDOMNode *child; CODE: /* raises (DOMException) */ node->RemoveChild(oldChild, &child); RETVAL = node; OUTPUT: RETVAL ## AppendChild(nsIDOMNode *newChild, nsIDOMNode **_retval) nsIDOMNode * moz_dom_AppendChild (node, newChild) nsIDOMNode *node; nsIDOMNode *newChild; PREINIT: nsIDOMNode *child; CODE: /* raises (DOMException) */ node->AppendChild(newChild, &child); RETVAL = child; OUTPUT: RETVAL ## HasChildNodes(PRBool *_retval) PRBool moz_dom_HasChildNodes (node) nsIDOMNode *node; PREINIT: PRBool has; CODE: node->HasChildNodes(&has); RETVAL = has; OUTPUT: RETVAL ## CloneNode(PRBool deep, nsIDOMNode **_retval) nsIDOMNode * moz_dom_CloneNode (node, deep) nsIDOMNode *node; PRBool deep; PREINIT: nsIDOMNode *clone; CODE: node->CloneNode(deep, &clone); RETVAL = clone; OUTPUT: RETVAL ## Normalize(void) void moz_dom_Normalize (node) nsIDOMNode *node; CODE: node->Normalize(); ## IsSupported(const nsAString & feature, const nsAString & version, PRBool *_retval) PRBool moz_dom_IsSupported (node, feature, version) nsIDOMNode *node; nsEmbedString feature; nsEmbedString version; PREINIT: PRBool is; CODE: node->IsSupported(feature, version, &is); RETVAL = is; OUTPUT: RETVAL ## GetNamespaceURI(nsAString & aNamespaceURI) nsEmbedString moz_dom_GetNamespaceURI (node) nsIDOMNode *node; PREINIT: nsEmbedString uri; CODE: node->GetNamespaceURI(uri); RETVAL = uri; OUTPUT: RETVAL ## GetPrefix(nsAString & aPrefix) nsEmbedString moz_dom_GetPrefix (node) nsIDOMNode *node; PREINIT: nsEmbedString aPrefix; CODE: node->GetPrefix(aPrefix); RETVAL = aPrefix; OUTPUT: RETVAL ## SetPrefix(const nsAString & aPrefix) void moz_dom_SetPrefix (node, aPrefix) nsIDOMNode *node; nsEmbedString aPrefix; CODE: node->SetPrefix(aPrefix); ## GetLocalName(nsAString & aLocalName) nsEmbedString moz_dom_GetLocalName (node) nsIDOMNode *node; PREINIT: nsEmbedString name; CODE: node->GetLocalName(name); RETVAL = name; OUTPUT: RETVAL ## HasAttributes(PRBool *_retval) PRBool moz_dom_HasAttributes (node) nsIDOMNode *node; PREINIT: PRBool has; CODE: node->HasAttributes(&has); RETVAL = has; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NodeList PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMNodeList.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNODELIST_IID) static nsIID nsIDOMNodeList::GetIID() CODE: const nsIID &id = nsIDOMNodeList::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## Item(PRUint32 index, nsIDOMNode **_retval) nsIDOMNode * moz_dom_Item (nodelist, index) nsIDOMNodeList *nodelist; PRUint32 index; PREINIT: nsIDOMNode *node; CODE: nodelist->Item(index, &node); RETVAL = node; OUTPUT: RETVAL ## GetLength(PRUint32 *aLength) PRUint32 moz_dom_GetLength (nodelist) nsIDOMNodeList *nodelist; PREINIT: PRUint32 len; CODE: nodelist->GetLength(&len); RETVAL = len; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NamedNodeMap PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMNamedNodeMap.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNAMEDNODEMAP_IID) static nsIID nsIDOMNamedNodeMap::GetIID() CODE: const nsIID &id = nsIDOMNamedNodeMap::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetNamedItem(const nsAString & name, nsIDOMNode **_retval) nsIDOMNode * moz_dom_GetNamedItem (namednodemap, name) nsIDOMNamedNodeMap *namednodemap; nsEmbedString name; PREINIT: nsIDOMNode *node; CODE: namednodemap->GetNamedItem(name, &node); RETVAL = node; OUTPUT: RETVAL ## SetNamedItem(nsIDOMNode *arg, nsIDOMNode **_retval) nsIDOMNode * moz_dom_SetNamedItem (namednodemap, arg) nsIDOMNamedNodeMap *namednodemap; nsIDOMNode *arg; PREINIT: nsIDOMNode *node; CODE: /* raises (DOMException) */ namednodemap->SetNamedItem(arg, &node); RETVAL = node; OUTPUT: RETVAL ## RemoveNamedItem(const nsAString & name, nsIDOMNode **_retval) nsIDOMNode * moz_dom_RemoveNamedItem (namednodemap, name) nsIDOMNamedNodeMap *namednodemap; nsEmbedString name; PREINIT: nsIDOMNode *node; CODE: /* raises (DOMException) */ namednodemap->RemoveNamedItem(name, &node); RETVAL = node; OUTPUT: RETVAL ## Item(PRUint32 index, nsIDOMNode **_retval) nsIDOMNode * moz_dom_Item (namednodemap, index) nsIDOMNamedNodeMap *namednodemap; PRUint32 index; PREINIT: nsIDOMNode *node; CODE: namednodemap->Item(index, &node); RETVAL = node; OUTPUT: RETVAL ## GetLength(PRUint32 *aLength) PRUint32 moz_dom_GetLength (namednodemap) nsIDOMNamedNodeMap *namednodemap; PREINIT: PRUint32 len; CODE: namednodemap->GetLength(&len); RETVAL = len; OUTPUT: RETVAL ## GetNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMNode **_retval) nsIDOMNode * moz_dom_GetNamedItemNS (namednodemap, namespaceURI, localName) nsIDOMNamedNodeMap *namednodemap; nsEmbedString namespaceURI; nsEmbedString localName; PREINIT: nsIDOMNode *node; CODE: namednodemap->GetNamedItemNS(namespaceURI, localName, &node); RETVAL = node; OUTPUT: RETVAL ## SetNamedItemNS(nsIDOMNode *arg, nsIDOMNode **_retval) nsIDOMNode * moz_dom_SetNamedItemNS (namednodemap, arg) nsIDOMNamedNodeMap *namednodemap; nsIDOMNode *arg; PREINIT: nsIDOMNode *node; CODE: /* raises (DOMException) */ namednodemap->SetNamedItemNS(arg, &node); RETVAL = node; OUTPUT: RETVAL ## RemoveNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMNode **_retval) nsIDOMNode * moz_dom_RemoveNamedItemNS (namednodemap, namespaceURI, localName) nsIDOMNamedNodeMap *namednodemap; nsEmbedString namespaceURI; nsEmbedString localName; PREINIT: nsIDOMNode *node; CODE: /* raises (DOMException) */ namednodemap->RemoveNamedItemNS(namespaceURI, localName, &node); RETVAL = node; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Document PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMDocument.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDOCUMENT_IID) static nsIID nsIDOMDocument::GetIID() CODE: const nsIID &id = nsIDOMDocument::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDoctype(nsIDOMDocumentType * *aDoctype) nsIDOMDocumentType * moz_dom_GetDoctype (document) nsIDOMDocument *document; PREINIT: nsIDOMDocumentType *doctype ; CODE: document->GetDoctype(&doctype); RETVAL = doctype; OUTPUT: RETVAL ## GetImplementation(nsIDOMDOMImplementation * *aImplementation) nsIDOMDOMImplementation * moz_dom_GetImplementation (document) nsIDOMDocument *document; PREINIT: nsIDOMDOMImplementation *implementation; CODE: document->GetImplementation(&implementation); RETVAL = implementation; OUTPUT: RETVAL ## GetDocumentElement(nsIDOMElement * *aDocumentElement) nsIDOMElement * moz_dom_GetDocumentElement (document) nsIDOMDocument *document; PREINIT: nsIDOMElement *element; CODE: document->GetDocumentElement(&element); RETVAL = element; OUTPUT: RETVAL ## CreateElement(const nsAString & tagName, nsIDOMElement **_retval) nsIDOMElement * moz_dom_CreateElement (document, tagname) nsIDOMDocument *document; nsEmbedString tagname; PREINIT: nsIDOMElement *element; CODE: /* raises (DOMException) */ document->CreateElement(tagname, &element); RETVAL = element; OUTPUT: RETVAL ## CreateDocumentFragment(nsIDOMDocumentFragment **_retval) nsIDOMDocumentFragment * moz_dom_CreateDocumentFragment (document) nsIDOMDocument *document; PREINIT: nsIDOMDocumentFragment *fragment; CODE: document->CreateDocumentFragment(&fragment); RETVAL = fragment; OUTPUT: RETVAL ## CreateTextNode(const nsAString & data, nsIDOMText **_retval) nsIDOMText * moz_dom_CreateTextNode (document, data) nsIDOMDocument *document; nsEmbedString data; PREINIT: nsIDOMText *node; CODE: document->CreateTextNode(data, &node); RETVAL = node; OUTPUT: RETVAL ## CreateComment(const nsAString & data, nsIDOMComment **_retval) nsIDOMComment * moz_dom_CreateComment (document, data) nsIDOMDocument *document; nsEmbedString data; PREINIT: nsIDOMComment *comment; CODE: document->CreateComment(data, &comment); RETVAL = comment; OUTPUT: RETVAL ## CreateCDATASection(const nsAString & data, nsIDOMCDATASection **_retval) nsIDOMCDATASection * moz_dom_CreateCDATASection (document, data) nsIDOMDocument *document; nsEmbedString data; PREINIT: nsIDOMCDATASection *node; CODE: /* raises (DOMException) */ document->CreateCDATASection(data, &node); RETVAL = node; OUTPUT: RETVAL ## CreateProcessingInstruction(const nsAString & target, const nsAString & data, nsIDOMProcessingInstruction **_retval) nsIDOMProcessingInstruction * moz_dom_CreateProcessingInstruction (document, target, data) nsIDOMDocument *document; nsEmbedString target; nsEmbedString data; PREINIT: nsIDOMProcessingInstruction *node; CODE: /* raises (DOMException) */ document->CreateProcessingInstruction(target, data, &node); RETVAL = node; OUTPUT: RETVAL ## CreateAttribute(const nsAString & name, nsIDOMAttr **_retval) nsIDOMAttr * moz_dom_CreateAttribute (document, name) nsIDOMDocument *document; nsEmbedString name; PREINIT: nsIDOMAttr *node; CODE: /* raises (DOMException) */ document->CreateAttribute(name, &node); RETVAL = node; OUTPUT: RETVAL ## CreateEntityReference(const nsAString & name, nsIDOMEntityReference **_retval) nsIDOMEntityReference * moz_dom_CreateEntityReference (document, name) nsIDOMDocument *document; nsEmbedString name; PREINIT: nsIDOMEntityReference *node; CODE: /* raises (DOMException) */ document->CreateEntityReference(name, &node); RETVAL = node; OUTPUT: RETVAL ## GetElementsByTagName(const nsAString & tagname, nsIDOMNodeList **_retval) nsIDOMNodeList * moz_dom_GetElementsByTagName_nodelist (document, tagname) nsIDOMDocument *document; nsEmbedString tagname; PREINIT: nsIDOMNodeList *nodelist; CODE: document->GetElementsByTagName(tagname, &nodelist); RETVAL = nodelist; OUTPUT: RETVAL ## ImportNode(nsIDOMNode *importedNode, PRBool deep, nsIDOMNode **_retval) nsIDOMNode * moz_dom_ImportNode (document, importedNode, deep) nsIDOMDocument *document; nsIDOMNode *importedNode; PRBool deep; PREINIT: nsIDOMNode *node; CODE: /* raises (DOMException) */ document->ImportNode(importedNode, deep, &node); RETVAL = node; OUTPUT: RETVAL ## CreateElementNS(const nsAString & namespaceURI, const nsAString & qualifiedName, nsIDOMElement **_retval) nsIDOMElement * moz_dom_CreateElementNS (document, namespaceURI, qualifiedName) nsIDOMDocument *document; nsEmbedString namespaceURI; nsEmbedString qualifiedName; PREINIT: nsIDOMElement *element; CODE: /* raises (DOMException) */ document->CreateElementNS(namespaceURI, qualifiedName, &element); RETVAL = element; OUTPUT: RETVAL ## CreateAttributeNS(const nsAString & namespaceURI, const nsAString & qualifiedName, nsIDOMAttr **_retval) nsIDOMAttr * moz_dom_CreateAttributeNS (document, namespaceURI, qualifiedName) nsIDOMDocument *document; nsEmbedString namespaceURI; nsEmbedString qualifiedName; PREINIT: nsIDOMAttr *attr; CODE: /* raises (DOMException) */ document->CreateAttributeNS(namespaceURI, qualifiedName, &attr); RETVAL = attr; OUTPUT: RETVAL ## GetElementsByTagNameNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMNodeList **_retval) nsIDOMNodeList * moz_dom_GetElementsByTagNameNS_nodelist (document, namespaceURI, localName) nsIDOMDocument *document; nsEmbedString namespaceURI; nsEmbedString localName; PREINIT: nsIDOMNodeList *nodelist; CODE: document->GetElementsByTagNameNS(namespaceURI, localName, &nodelist); RETVAL = nodelist; OUTPUT: RETVAL ## GetElementById(const nsAString & elementId, nsIDOMElement **_retval) nsIDOMElement * moz_dom_GetElementById (document, elementId) nsIDOMDocument *document; nsEmbedString elementId; PREINIT: nsIDOMElement *element; CODE: document->GetElementById(elementId, &element); RETVAL = element; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSDocument PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSDocument.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSDOCUMENT_IID) static nsIID nsIDOMNSDocument::GetIID() CODE: const nsIID &id = nsIDOMNSDocument::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCharacterSet(nsAString & aCharacterSet) nsEmbedString moz_dom_GetCharacterSet (nsdocument) nsIDOMNSDocument *nsdocument; PREINIT: nsEmbedString aCharacterSet; CODE: nsdocument->GetCharacterSet(aCharacterSet); RETVAL = aCharacterSet; OUTPUT: RETVAL ## GetDir(nsAString & aDir) nsEmbedString moz_dom_GetDir (nsdocument) nsIDOMNSDocument *nsdocument; PREINIT: nsEmbedString aDir; CODE: nsdocument->GetDir(aDir); RETVAL = aDir; OUTPUT: RETVAL ## SetDir(const nsAString & aDir) void moz_dom_SetDir (nsdocument, aDir) nsIDOMNSDocument *nsdocument; nsEmbedString aDir; CODE: nsdocument->SetDir(aDir); ## GetLocation(nsIDOMLocation * *aLocation) nsIDOMLocation * moz_dom_GetLocation (nsdocument) nsIDOMNSDocument *nsdocument; PREINIT: nsIDOMLocation * aLocation; CODE: nsdocument->GetLocation(&aLocation); RETVAL = aLocation; OUTPUT: RETVAL ## GetTitle(nsAString & aTitle) nsEmbedString moz_dom_GetTitle (nsdocument) nsIDOMNSDocument *nsdocument; PREINIT: nsEmbedString aTitle; CODE: nsdocument->GetTitle(aTitle); RETVAL = aTitle; OUTPUT: RETVAL ## SetTitle(const nsAString & aTitle) void moz_dom_SetTitle (nsdocument, aTitle) nsIDOMNSDocument *nsdocument; nsEmbedString aTitle; CODE: nsdocument->SetTitle(aTitle); ## GetContentType(nsAString & aContentType) nsEmbedString moz_dom_GetContentType (nsdocument) nsIDOMNSDocument *nsdocument; PREINIT: nsEmbedString aContentType; CODE: nsdocument->GetContentType(aContentType); RETVAL = aContentType; OUTPUT: RETVAL ## GetLastModified(nsAString & aLastModified) nsEmbedString moz_dom_GetLastModified (nsdocument) nsIDOMNSDocument *nsdocument; PREINIT: nsEmbedString aLastModified; CODE: nsdocument->GetLastModified(aLastModified); RETVAL = aLastModified; OUTPUT: RETVAL ## GetReferrer(nsAString & aReferrer) nsEmbedString moz_dom_GetReferrer (nsdocument) nsIDOMNSDocument *nsdocument; PREINIT: nsEmbedString aReferrer; CODE: nsdocument->GetReferrer(aReferrer); RETVAL = aReferrer; OUTPUT: RETVAL ### GetBoxObjectFor(nsIDOMElement *elt, nsIBoxObject **_retval) #nsIBoxObject * #moz_dom_GetBoxObjectFor (nsdocument, elt) # nsIDOMNSDocument *nsdocument; # nsIDOMElement * elt; # PREINIT: # nsIBoxObject * _retval; # CODE: # nsdocument->GetBoxObjectFor(elt, &_retval); # RETVAL = _retval; # OUTPUT: # RETVAL # ### SetBoxObjectFor(nsIDOMElement *elt, nsIBoxObject *boxObject) #void #moz_dom_SetBoxObjectFor (nsdocument, elt, boxObject) # nsIDOMNSDocument *nsdocument; # nsIDOMElement * elt; # nsIBoxObject * boxObject; # CODE: # nsdocument->SetBoxObjectFor(elt, boxObject); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Element PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMELEMENT_IID) static nsIID nsIDOMElement::GetIID() CODE: const nsIID &id = nsIDOMElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetTagName(nsAString & aTagName) nsEmbedString moz_dom_GetTagName (element) nsIDOMElement *element; PREINIT: nsEmbedString tagname; CODE: element->GetTagName(tagname); RETVAL = tagname; OUTPUT: RETVAL ## GetAttribute(const nsAString & name, nsAString & _retval) nsEmbedString moz_dom_GetAttribute (element, name) nsIDOMElement *element; nsEmbedString name; PREINIT: nsEmbedString attr; CODE: element->GetAttribute(name, attr); RETVAL = attr; OUTPUT: RETVAL ## SetAttribute(const nsAString & name, const nsAString & value) void moz_dom_SetAttribute (element, name, value) nsIDOMElement *element; nsEmbedString name; nsEmbedString value; CODE: /* raises (DOMException) */ element->SetAttribute(name, value); ## RemoveAttribute(const nsAString & name) void moz_dom_RemoveAttribute (element, name) nsIDOMElement *element; nsEmbedString name; CODE: /* raises (DOMException) */ element->RemoveAttribute(name); ## GetAttributeNode(const nsAString & name, nsIDOMAttr **_retval) nsIDOMAttr * moz_dom_GetAttributeNode (element, name) nsIDOMElement *element; nsEmbedString name; PREINIT: nsIDOMAttr *attrnode; CODE: element->GetAttributeNode(name, &attrnode); RETVAL = attrnode; OUTPUT: RETVAL ## SetAttributeNode(nsIDOMAttr *newAttr, nsIDOMAttr **_retval) nsIDOMAttr * moz_dom_SetAttributeNode (element, newAttr) nsIDOMElement *element; nsIDOMAttr *newAttr; PREINIT: nsIDOMAttr *attrnode; CODE: /* raises (DOMException) */ element->SetAttributeNode(newAttr, &attrnode); RETVAL = attrnode; OUTPUT: RETVAL ## RemoveAttributeNode(nsIDOMAttr *oldAttr, nsIDOMAttr **_retval) nsIDOMAttr * moz_dom_RemoveAttributeNode (element, oldAttr) nsIDOMElement *element; nsIDOMAttr *oldAttr; PREINIT: nsIDOMAttr *attrnode; CODE: /* raises (DOMException) */ element->RemoveAttributeNode(oldAttr, &attrnode); RETVAL = attrnode; OUTPUT: RETVAL ## GetElementsByTagName(const nsAString & name, nsIDOMNodeList **_retval) nsIDOMNodeList * moz_dom_GetElementsByTagName_nodelist (element, name) nsIDOMElement *element; nsEmbedString name; PREINIT: nsIDOMNodeList *nodelist; CODE: element->GetElementsByTagName(name, &nodelist); RETVAL = nodelist; OUTPUT: RETVAL ## GetAttributeNS(const nsAString & namespaceURI, const nsAString & localName, nsAString & _retval) nsEmbedString moz_dom_GetAttributeNS (element, namespaceURI, localName) nsIDOMElement *element; nsEmbedString namespaceURI; nsEmbedString localName; PREINIT: nsEmbedString attr; CODE: element->GetAttributeNS(namespaceURI, localName, attr); RETVAL = attr; OUTPUT: RETVAL ## SetAttributeNS(const nsAString & namespaceURI, const nsAString & qualifiedName, const nsAString & value) void moz_dom_SetAttributeNS (element, namespaceURI, qualifiedName, value) nsIDOMElement *element; nsEmbedString namespaceURI; nsEmbedString qualifiedName; nsEmbedString value; CODE: /* raises (DOMException) */ element->SetAttributeNS(namespaceURI, qualifiedName, value); ## RemoveAttributeNS(const nsAString & namespaceURI, const nsAString & localName) void moz_dom_RemoveAttributeNS (element, namespaceURI, localName) nsIDOMElement *element; nsEmbedString namespaceURI; nsEmbedString localName; CODE: /* raises (DOMException) */ element->RemoveAttributeNS(namespaceURI, localName); ## GetAttributeNodeNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr **_retval) nsIDOMAttr * moz_dom_GetAttributeNodeNS (element, namespaceURI, localName) nsIDOMElement *element; nsEmbedString namespaceURI; nsEmbedString localName; PREINIT: nsIDOMAttr *attrnode; CODE: element->GetAttributeNodeNS(namespaceURI, localName, &attrnode); RETVAL = attrnode; OUTPUT: RETVAL ## SetAttributeNodeNS(nsIDOMAttr *newAttr, nsIDOMAttr **_retval) nsIDOMAttr * moz_dom_SetAttributeNodeNS (element, newAttr) nsIDOMElement *element; nsIDOMAttr *newAttr; PREINIT: nsIDOMAttr *attrnode; CODE: /* raises (DOMException) */ element->SetAttributeNodeNS(newAttr, &attrnode); RETVAL = attrnode; OUTPUT: RETVAL ## GetElementsByTagNameNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMNodeList **_retval) nsIDOMNodeList * moz_dom_GetElementsByTagNameNS_nodelist (element, namespaceURI, localName) nsIDOMElement *element; nsEmbedString namespaceURI; nsEmbedString localName; PREINIT: nsIDOMNodeList *nodelist; CODE: element->GetElementsByTagNameNS(namespaceURI, localName, &nodelist); RETVAL = nodelist; OUTPUT: RETVAL ## HasAttribute(const nsAString & name, PRBool *_retval) PRBool moz_dom_HasAttribute (element, name) nsIDOMElement *element; nsEmbedString name; PREINIT: PRBool has; CODE: element->HasAttribute(name, &has); RETVAL = has; OUTPUT: RETVAL ## HasAttributeNS(const nsAString & namespaceURI, const nsAString & localName, PRBool *_retval) PRBool moz_dom_HasAttributeNS (element, namespaceURI, localName) nsIDOMElement *element; nsEmbedString namespaceURI; nsEmbedString localName; PREINIT: PRBool has; CODE: element->HasAttributeNS(namespaceURI, localName, &has); RETVAL = has; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Entity PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMEntity.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMENTITY_IID) static nsIID nsIDOMEntity::GetIID() CODE: const nsIID &id = nsIDOMEntity::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetPublicId(nsAString & aPublicId) nsEmbedString moz_dom_GetPublicId (entity) nsIDOMEntity *entity; PREINIT: nsEmbedString aPublicId; CODE: entity->GetPublicId(aPublicId); RETVAL = aPublicId; OUTPUT: RETVAL ## GetSystemId(nsAString & aSystemId) nsEmbedString moz_dom_GetSystemId (entity) nsIDOMEntity *entity; PREINIT: nsEmbedString aSystemId; CODE: entity->GetSystemId(aSystemId); RETVAL = aSystemId; OUTPUT: RETVAL ## GetNotationName(nsAString & aNotationName) nsEmbedString moz_dom_GetNotationName (entity) nsIDOMEntity *entity; PREINIT: nsEmbedString aNotationName; CODE: entity->GetNotationName(aNotationName); RETVAL = aNotationName; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::EntityReference PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMEntityReference.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMENTITYREFERENCE_IID) static nsIID nsIDOMEntityReference::GetIID() CODE: const nsIID &id = nsIDOMEntityReference::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Attr PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMAttr.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMATTR_IID) static nsIID nsIDOMAttr::GetIID() CODE: const nsIID &id = nsIDOMAttr::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (attr) nsIDOMAttr *attr; PREINIT: nsEmbedString name; CODE: attr->GetName(name); RETVAL = name; OUTPUT: RETVAL ## GetSpecified(PRBool *aSpecified) PRBool moz_dom_GetSpecified (attr) nsIDOMAttr *attr; PREINIT: PRBool spec; CODE: attr->GetSpecified(&spec); RETVAL = spec; OUTPUT: RETVAL ## GetValue(nsAString & aValue) nsEmbedString moz_dom_GetValue (attr) nsIDOMAttr *attr; PREINIT: nsEmbedString value; CODE: attr->GetValue(value); RETVAL = value; OUTPUT: RETVAL ## SetValue(const nsAString & aValue) void moz_dom_SetValue (attr, value) nsIDOMAttr *attr; nsEmbedString value; CODE: attr->SetValue(value); ## GetOwnerElement(nsIDOMElement * *aOwnerElement) nsIDOMElement * moz_dom_GetOwnerElement (attr) nsIDOMAttr *attr; PREINIT: nsIDOMElement *element; CODE: attr->GetOwnerElement(&element); RETVAL = element; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Notation PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMNotation.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNOTATION_IID) static nsIID nsIDOMNotation::GetIID() CODE: const nsIID &id = nsIDOMNotation::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetPublicId(nsAString & aPublicId) nsEmbedString moz_dom_GetPublicId (notation) nsIDOMNotation *notation; PREINIT: nsEmbedString aPublicId; CODE: notation->GetPublicId(aPublicId); RETVAL = aPublicId; OUTPUT: RETVAL ## GetSystemId(nsAString & aSystemId) nsEmbedString moz_dom_GetSystemId (notation) nsIDOMNotation *notation; PREINIT: nsEmbedString aSystemId; CODE: notation->GetSystemId(aSystemId); RETVAL = aSystemId; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::ProcessingInstruction PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMProcessingInstruction.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMPROCESSINGINSTRUCTION_IID) static nsIID nsIDOMProcessingInstruction::GetIID() CODE: const nsIID &id = nsIDOMProcessingInstruction::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetTarget(nsAString & aTarget), etc.. nsEmbedString moz_dom_GetTarget (pi) nsIDOMProcessingInstruction *pi; ALIAS: Mozilla::DOM::ProcessingInstruction::GetData = 1 PREINIT: nsEmbedString str; CODE: switch (ix) { case 0: pi->GetTarget(str); break; case 1: pi->GetData(str); break; default: XSRETURN_UNDEF; } RETVAL = str; OUTPUT: RETVAL ## SetData(const nsAString & aData) void moz_dom_SetData (pi, data) nsIDOMProcessingInstruction *pi; nsEmbedString data; CODE: pi->SetData(data); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::CDATASection PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMCDATASection.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMCDATASECTION_IID) static nsIID nsIDOMCDATASection::GetIID() CODE: const nsIID &id = nsIDOMCDATASection::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Comment PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMComment.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMCOMMENT_IID) static nsIID nsIDOMComment::GetIID() CODE: const nsIID &id = nsIDOMComment::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::CharacterData PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMCharacterData.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMCHARACTERDATA_IID) static nsIID nsIDOMCharacterData::GetIID() CODE: const nsIID &id = nsIDOMCharacterData::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetData(nsAString & aData) nsEmbedString moz_dom_GetData (characterdata) nsIDOMCharacterData *characterdata; PREINIT: nsEmbedString data; CODE: characterdata->GetData(data); RETVAL = data; OUTPUT: RETVAL ## SetData(const nsAString & aData) void moz_dom_SetData (characterdata, data) nsIDOMCharacterData *characterdata; nsEmbedString data; CODE: characterdata->SetData(data); ## GetLength(PRUint32 *aLength) PRUint32 moz_dom_GetLength (characterdata) nsIDOMCharacterData *characterdata; PREINIT: PRUint32 len; CODE: characterdata->GetLength(&len); RETVAL = len; OUTPUT: RETVAL ## SubstringData(PRUint32 offset, PRUint32 count, nsAString & _retval) nsEmbedString moz_dom_SubstringData (characterdata, offset, count) nsIDOMCharacterData *characterdata; PRUint32 offset; PRUint32 count; PREINIT: nsEmbedString data; CODE: /* raises (DOMException) */ characterdata->SubstringData(offset, count, data); RETVAL = data; OUTPUT: RETVAL ## AppendData(const nsAString & arg) void moz_dom_AppendData (characterdata, data) nsIDOMCharacterData *characterdata; nsEmbedString data; CODE: /* raises (DOMException) */ characterdata->AppendData(data); ## InsertData(PRUint32 offset, const nsAString & arg) void moz_dom_InsertData (characterdata, offset, data) nsIDOMCharacterData *characterdata; PRUint32 offset; nsEmbedString data; CODE: /* raises (DOMException) */ characterdata->InsertData(offset, data); ## DeleteData(PRUint32 offset, PRUint32 count) void moz_dom_DeleteData (characterdata, offset, count) nsIDOMCharacterData *characterdata; PRUint32 offset; PRUint32 count; CODE: /* raises (DOMException) */ characterdata->DeleteData(offset, count); ## ReplaceData(PRUint32 offset, PRUint32 count, const nsAString & arg) void moz_dom_ReplaceData (characterdata, offset, count, data) nsIDOMCharacterData *characterdata; PRUint32 offset; PRUint32 count; nsEmbedString data; CODE: /* raises (DOMException) */ characterdata->ReplaceData(offset, count, data); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Text PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMText.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMTEXT_IID) static nsIID nsIDOMText::GetIID() CODE: const nsIID &id = nsIDOMText::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## SplitText(PRUint32 offset, nsIDOMText **_retval) nsIDOMText * moz_dom_SplitText (text, offset) nsIDOMText *text; PRUint32 offset; PREINIT: nsIDOMText *splittext; CODE: /* raises (DOMException) */ text->SplitText(offset, &splittext); RETVAL = splittext; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::DocumentFragment PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMDocumentFragment.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDOCUMENTFRAGMENT_IID) static nsIID nsIDOMDocumentFragment::GetIID() CODE: const nsIID &id = nsIDOMDocumentFragment::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::DocumentType PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMDocumentType.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDOCUMENTTYPE_IID) static nsIID nsIDOMDocumentType::GetIID() CODE: const nsIID &id = nsIDOMDocumentType::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (documenttype) nsIDOMDocumentType *documenttype; PREINIT: nsEmbedString name; CODE: documenttype->GetName(name); RETVAL = name; OUTPUT: RETVAL ## GetEntities(nsIDOMNamedNodeMap * *aEntities) nsIDOMNamedNodeMap * moz_dom_GetEntities_namednodemap (documenttype) nsIDOMDocumentType *documenttype; PREINIT: nsIDOMNamedNodeMap *nodemap; CODE: documenttype->GetEntities(&nodemap); RETVAL = nodemap; OUTPUT: RETVAL ## GetNotations(nsIDOMNamedNodeMap * *aNotations) nsIDOMNamedNodeMap * moz_dom_GetNotations_namednodemap (documenttype) nsIDOMDocumentType *documenttype; PREINIT: nsIDOMNamedNodeMap *nodemap; CODE: documenttype->GetNotations(&nodemap); RETVAL = nodemap; OUTPUT: RETVAL ## GetPublicId(nsAString & aPublicId) nsEmbedString moz_dom_GetPublicId (documenttype) nsIDOMDocumentType *documenttype; PREINIT: nsEmbedString id; CODE: documenttype->GetPublicId(id); RETVAL = id; OUTPUT: RETVAL ## GetSystemId(nsAString & aSystemId) nsEmbedString moz_dom_GetSystemId (documenttype) nsIDOMDocumentType *documenttype; PREINIT: nsEmbedString id; CODE: documenttype->GetSystemId(id); RETVAL = id; OUTPUT: RETVAL ## GetInternalSubset(nsAString & aInternalSubset) nsEmbedString moz_dom_GetInternalSubset (documenttype) nsIDOMDocumentType *documenttype; PREINIT: nsEmbedString subset; CODE: documenttype->GetInternalSubset(subset); RETVAL = subset; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::DOMImplementation PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMDOMImplementation.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDOMIMPLEMENTATION_IID) static nsIID nsIDOMDOMImplementation::GetIID() CODE: const nsIID &id = nsIDOMDOMImplementation::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## HasFeature(const nsAString & feature, const nsAString & version, PRBool *_retval) PRBool moz_dom_HasFeature (domimplementation, feature, version) nsIDOMDOMImplementation *domimplementation; nsEmbedString feature; nsEmbedString version; PREINIT: PRBool has; CODE: domimplementation->HasFeature(feature, version, &has); RETVAL = has; OUTPUT: RETVAL ## CreateDocumentType(const nsAString & qualifiedName, const nsAString & publicId, const nsAString & systemId, nsIDOMDocumentType **_retval) nsIDOMDocumentType * moz_dom_CreateDocumentType (domimplementation, qualifiedName, publicId, systemId) nsIDOMDOMImplementation *domimplementation; nsEmbedString qualifiedName; nsEmbedString publicId; nsEmbedString systemId; PREINIT: nsIDOMDocumentType *type; CODE: /* raises (DOMException) */ domimplementation->CreateDocumentType(qualifiedName, publicId, systemId, &type); RETVAL = type; OUTPUT: RETVAL ## CreateDocument(const nsAString & namespaceURI, const nsAString & qualifiedName, nsIDOMDocumentType *doctype, nsIDOMDocument **_retval) nsIDOMDocument * moz_dom_CreateDocument (domimplementation, namespaceURI, qualifiedName, doctype) nsIDOMDOMImplementation *domimplementation; nsEmbedString namespaceURI; nsEmbedString qualifiedName; nsIDOMDocumentType *doctype; PREINIT: nsIDOMDocument *doc; CODE: /* raises (DOMException) */ domimplementation->CreateDocument(namespaceURI, qualifiedName, doctype, &doc); RETVAL = doc; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::DOMException PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMDOMException.h # XXX: this isn't supported yet here, as I've ignored catching # any exceptions that are raised (though they are all noted # in comments). Will soon. # If you want to throw an exception object, assign the object to $@ and then pass # "Nullch" to croak(): # # errsv = get_sv("@", TRUE); # sv_setsv(errsv, exception_object); # croak(Nullch); # # But how do I create a nsIDOMDOMException object? Is one thrown # when an exception occurs? (I was under the impression that # methods generally just return error codes.) ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDOMEXCEPTION_IID) static nsIID nsIDOMDOMException::GetIID() CODE: const nsIID &id = nsIDOMDOMException::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## found code: ##nsresult rv; ##rv=aTarget->GetValue(&Url); ##if (NS_FAILED(rv)) return 2; ##(also have NS_SUCCEEDED) # /* readonly attribute unsigned long code; */ #=for apidoc Mozilla::DOM::DOMException::GetCode # #=for signature $exception->GetCode(PRUint32 *aCode) # # # #=cut # ### GetCode(PRUint32 *aCode) #somereturn * #moz_dom_GetCode (exception, aCode) # nsIDOMexception *exception; # PRUint32 *aCode ; # PREINIT: # # CODE: # exception->GetCode(&); # RETVAL = ; # OUTPUT: # RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Selection PREFIX = moz_dom_ # /usr/include/mozilla/nsISelection.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_ISELECTION_IID) static nsIID nsISelection::GetIID() CODE: const nsIID &id = nsISelection::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAnchorNode(nsIDOMNode * *aAnchorNode) nsIDOMNode * moz_dom_GetAnchorNode (selection) nsISelection *selection; PREINIT: nsIDOMNode *node; CODE: selection->GetAnchorNode(&node); RETVAL = node; OUTPUT: RETVAL ## GetAnchorOffset(PRInt32 *aAnchorOffset) PRInt32 moz_dom_GetAnchorOffset (selection) nsISelection *selection; PREINIT: PRInt32 offset; CODE: selection->GetAnchorOffset(&offset); RETVAL = offset; OUTPUT: RETVAL ## GetFocusNode(nsIDOMNode * *aFocusNode) nsIDOMNode * moz_dom_GetFocusNode (selection) nsISelection *selection; PREINIT: nsIDOMNode *node; CODE: selection->GetFocusNode(&node); RETVAL = node; OUTPUT: RETVAL ## GetFocusOffset(PRInt32 *aFocusOffset) PRInt32 moz_dom_GetFocusOffset (selection) nsISelection *selection; PREINIT: PRInt32 offset; CODE: selection->GetFocusOffset(&offset); RETVAL = offset; OUTPUT: RETVAL ## GetIsCollapsed(PRBool *aIsCollapsed) PRBool moz_dom_GetIsCollapsed (selection) nsISelection *selection; PREINIT: PRBool is; CODE: selection->GetIsCollapsed(&is); RETVAL = is; OUTPUT: RETVAL ## GetRangeCount(PRInt32 *aRangeCount) PRInt32 moz_dom_GetRangeCount (selection) nsISelection *selection; PREINIT: PRInt32 count; CODE: selection->GetRangeCount(&count); RETVAL = count; OUTPUT: RETVAL ## GetRangeAt(PRInt32 index, nsIDOMRange **_retval) nsIDOMRange * moz_dom_GetRangeAt (selection, index) nsISelection *selection; PRInt32 index; PREINIT: nsIDOMRange *range; CODE: selection->GetRangeAt(index, &range); RETVAL = range; OUTPUT: RETVAL ## Collapse(nsIDOMNode *parentNode, PRInt32 offset) void moz_dom_Collapse (selection, parentNode, offset) nsISelection *selection; nsIDOMNode *parentNode; PRInt32 offset; CODE: selection->Collapse(parentNode, offset); # Extend(nsIDOMNode *parentNode, PRInt32 offset) void moz_dom_Extend (selection, parentNode, offset) nsISelection *selection; nsIDOMNode *parentNode; PRInt32 offset; CODE: selection->Extend(parentNode, offset); ## CollapseToStart(void) void moz_dom_CollapseToStart (selection) nsISelection *selection; CODE: selection->CollapseToStart(); ## CollapseToEnd(void) void moz_dom_CollapseToEnd (selection) nsISelection *selection; CODE: selection->CollapseToEnd(); ## ContainsNode(nsIDOMNode *node, PRBool entirelyContained, PRBool *_retval) PRBool moz_dom_ContainsNode (selection, node, entirelyContained) nsISelection *selection; nsIDOMNode *node; PRBool entirelyContained; PREINIT: PRBool has; CODE: selection->ContainsNode(node, entirelyContained, &has); RETVAL = has; OUTPUT: RETVAL ## SelectAllChildren(nsIDOMNode *parentNode) void moz_dom_SelectAllChildren (selection, parentNode) nsISelection *selection; nsIDOMNode *parentNode; CODE: selection->SelectAllChildren(parentNode); ## AddRange(nsIDOMRange *range) void moz_dom_AddRange (selection, range) nsISelection *selection; nsIDOMRange *range; CODE: selection->AddRange(range); ## RemoveRange(nsIDOMRange *range) void moz_dom_RemoveRange (selection, range) nsISelection *selection; nsIDOMRange *range; CODE: selection->RemoveRange(range); ## RemoveAllRanges(void) void moz_dom_RemoveAllRanges (selection) nsISelection *selection; CODE: selection->RemoveAllRanges(); ## DeleteFromDocument(void) void moz_dom_DeleteFromDocument (selection) nsISelection *selection; CODE: selection->DeleteFromDocument(); ## SelectionLanguageChange(PRBool langRTL) void moz_dom_SelectionLanguageChange (selection, langRTL) nsISelection *selection; PRBool langRTL; CODE: selection->SelectionLanguageChange(langRTL); ## ToString(PRUnichar **_retval) nsEmbedString moz_dom_ToString (selection) nsISelection *selection; PREINIT: PRUnichar *u16str; CODE: selection->ToString(&u16str); nsEmbedString str(u16str); RETVAL = str; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::DocumentRange PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMDocumentRange.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMDOCUMENTRANGE_IID) static nsIID nsIDOMDocumentRange::GetIID() CODE: const nsIID &id = nsIDOMDocumentRange::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## CreateRange(nsIDOMRange **_retval) nsIDOMRange * moz_dom_CreateRange (documentrange) nsIDOMDocumentRange *documentrange; PREINIT: nsIDOMRange * _retval; CODE: documentrange->CreateRange(&_retval); RETVAL = _retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Range PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMRange.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMRANGE_IID) static nsIID nsIDOMRange::GetIID() CODE: const nsIID &id = nsIDOMRange::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetStartContainer(nsIDOMNode * *aStartContainer) nsIDOMNode * moz_dom_GetStartContainer (range) nsIDOMRange *range; PREINIT: nsIDOMNode *node; CODE: range->GetStartContainer(&node); RETVAL = node; OUTPUT: RETVAL ## GetStartOffset(PRInt32 *aStartOffset) PRInt32 moz_dom_GetStartOffset (range) nsIDOMRange *range; PREINIT: PRInt32 offset; CODE: range->GetStartOffset(&offset); RETVAL = offset; OUTPUT: RETVAL ## GetEndContainer(nsIDOMNode * *aEndContainer) nsIDOMNode * moz_dom_GetEndContainer (range) nsIDOMRange *range; PREINIT: nsIDOMNode *node; CODE: range->GetEndContainer(&node); RETVAL = node; OUTPUT: RETVAL ## GetEndOffset(PRInt32 *aEndOffset) PRInt32 moz_dom_GetEndOffset (range) nsIDOMRange *range; PREINIT: PRInt32 offset; CODE: range->GetEndOffset(&offset); RETVAL = offset; OUTPUT: RETVAL ## GetCollapsed(PRBool *aCollapsed) PRBool moz_dom_GetCollapsed (range) nsIDOMRange *range; PREINIT: PRBool collapsed; CODE: range->GetCollapsed(&collapsed); RETVAL = collapsed; OUTPUT: RETVAL ## GetCommonAncestorContainer(nsIDOMNode * *aCommonAncestorContainer) nsIDOMNode * moz_dom_GetCommonAncestorContainer (range) nsIDOMRange *range; PREINIT: nsIDOMNode *node; CODE: range->GetCommonAncestorContainer(&node); RETVAL = node; OUTPUT: RETVAL ## SetStart(nsIDOMNode *refNode, PRInt32 offset) void moz_dom_SetStart (range, refNode, offset) nsIDOMRange *range; nsIDOMNode *refNode; PRInt32 offset; CODE: /* raises (RangeException, DOMException) */ range->SetStart(refNode, offset); ## SetEnd(nsIDOMNode *refNode, PRInt32 offset) void moz_dom_SetEnd (range, refNode, offset) nsIDOMRange *range; nsIDOMNode *refNode; PRInt32 offset; CODE: /* raises (RangeException, DOMException) */ range->SetEnd(refNode, offset); ## SetStartBefore(nsIDOMNode *refNode) void moz_dom_SetStartBefore (range, refNode) nsIDOMRange *range; nsIDOMNode *refNode; CODE: /* raises (RangeException, DOMException) */ range->SetStartBefore(refNode); ## SetStartAfter(nsIDOMNode *refNode) void moz_dom_SetStartAfter (range, refNode) nsIDOMRange *range; nsIDOMNode *refNode; CODE: /* raises (RangeException, DOMException) */ range->SetStartAfter(refNode); ## SetEndBefore(nsIDOMNode *refNode) void moz_dom_SetEndBefore (range, refNode) nsIDOMRange *range; nsIDOMNode *refNode; CODE: /* raises (RangeException, DOMException) */ range->SetEndBefore(refNode); ## SetEndAfter(nsIDOMNode *refNode) void moz_dom_SetEndAfter (range, refNode) nsIDOMRange *range; nsIDOMNode *refNode; CODE: /* raises (RangeException, DOMException) */ range->SetEndAfter(refNode); ## Collapse(PRBool toStart) void moz_dom_Collapse (range, toStart) nsIDOMRange *range; PRBool toStart; CODE: /* raises (DOMException) */ range->Collapse(toStart); ## SelectNode(nsIDOMNode *refNode) void moz_dom_SelectNode (range, refNode) nsIDOMRange *range; nsIDOMNode *refNode; CODE: /* raises (RangeException, DOMException) */ range->SelectNode(refNode); ## SelectNodeContents(nsIDOMNode *refNode) void moz_dom_SelectNodeContents (range, refNode) nsIDOMRange *range; nsIDOMNode *refNode; CODE: /* raises (RangeException, DOMException) */ range->SelectNodeContents(refNode); ## CompareBoundaryPoints(PRUint16 how, nsIDOMRange *sourceRange, PRInt16 *_retval) PRInt16 moz_dom_CompareBoundaryPoints (range, how, sourceRange) nsIDOMRange *range; PRUint16 how; nsIDOMRange *sourceRange; PREINIT: PRInt16 num; CODE: /* raises (DOMException) */ range->CompareBoundaryPoints(how, sourceRange, &num); RETVAL = num; OUTPUT: RETVAL ## DeleteContents(void) void moz_dom_DeleteContents (range) nsIDOMRange *range; CODE: /* raises (DOMException) */ range->DeleteContents(); ## ExtractContents(nsIDOMDocumentFragment **_retval) nsIDOMDocumentFragment * moz_dom_ExtractContents (range) nsIDOMRange *range; PREINIT: nsIDOMDocumentFragment *frag; CODE: /* raises (DOMException) */ range->ExtractContents(&frag); RETVAL = frag; OUTPUT: RETVAL ## CloneContents(nsIDOMDocumentFragment **_retval) nsIDOMDocumentFragment * moz_dom_CloneContents (range) nsIDOMRange *range; PREINIT: nsIDOMDocumentFragment *frag; CODE: /* raises (DOMException) */ range->CloneContents(&frag); RETVAL = frag; OUTPUT: RETVAL ## InsertNode(nsIDOMNode *newNode) void moz_dom_InsertNode (range, newNode) nsIDOMRange *range; nsIDOMNode *newNode; CODE: /* raises (RangeException, DOMException) */ range->InsertNode(newNode); ## SurroundContents(nsIDOMNode *newParent) void moz_dom_SurroundContents (range, newParent) nsIDOMRange *range; nsIDOMNode *newParent; CODE: /* raises (RangeException, DOMException) */ range->SurroundContents(newParent); ## CloneRange(nsIDOMRange **_retval) nsIDOMRange * moz_dom_CloneRange (range) nsIDOMRange *range; PREINIT: nsIDOMRange *newrange; CODE: /* raises (DOMException) */ range->CloneRange(&newrange); RETVAL = newrange; ## ToString(nsAString & _retval) nsEmbedString moz_dom_ToString (range) nsIDOMRange *range; PREINIT: nsEmbedString str; CODE: /* raises (DOMException) */ range->ToString(str); RETVAL = str; OUTPUT: RETVAL ## Detach(void) void moz_dom_Detach (range) nsIDOMRange *range; CODE: /* raises (DOMException) */ range->Detach(); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSRange PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSRange.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSRANGE_IID) static nsIID nsIDOMNSRange::GetIID() CODE: const nsIID &id = nsIDOMNSRange::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## CreateContextualFragment(const nsAString & fragment, nsIDOMDocumentFragment **_retval) nsIDOMDocumentFragment * moz_dom_CreateContextualFragment (nsrange, fragment) nsIDOMNSRange *nsrange; nsEmbedString fragment; PREINIT: nsIDOMDocumentFragment * _retval; CODE: nsrange->CreateContextualFragment(fragment, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## IsPointInRange(nsIDOMNode *parent, PRInt32 offset, PRBool *_retval) PRBool moz_dom_IsPointInRange (nsrange, parent, offset) nsIDOMNSRange *nsrange; nsIDOMNode * parent; PRInt32 offset; PREINIT: PRBool _retval; CODE: nsrange->IsPointInRange(parent, offset, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## ComparePoint(nsIDOMNode *parent, PRInt32 offset, PRInt16 *_retval) PRInt16 moz_dom_ComparePoint (nsrange, parent, offset) nsIDOMNSRange *nsrange; nsIDOMNode * parent; PRInt32 offset; PREINIT: PRInt16 _retval; CODE: nsrange->ComparePoint(parent, offset, &_retval); RETVAL = _retval; OUTPUT: RETVAL ### see https://developer.mozilla.org/en/Gecko_1.9_Changes_affecting_websites #ifdef NOT_SUPPORTED_ANYMORE ## IntersectsNode(nsIDOMNode *n, PRBool *_retval) PRBool moz_dom_IntersectsNode (nsrange, n) nsIDOMNSRange *nsrange; nsIDOMNode * n; PREINIT: PRBool _retval; CODE: nsrange->IntersectsNode(n, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## CompareNode(nsIDOMNode *n, PRUint16 *_retval) PRUint16 moz_dom_CompareNode (nsrange, n) nsIDOMNSRange *nsrange; nsIDOMNode * n; PREINIT: PRUint16 _retval; CODE: nsrange->CompareNode(n, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## NSDetach(void) void moz_dom_NSDetach (nsrange) nsIDOMNSRange *nsrange; CODE: nsrange->NSDetach(); #endif # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Supports PREFIX = moz_dom_ # /usr/include/mozilla/nsISupports.h ## QueryInterface(const nsIID & uuid, void * *result) SV * moz_dom_QueryInterface (supports, uuid) nsISupports *supports; nsIID uuid; PREINIT: void *res; nsresult rv; CODE: rv = supports->QueryInterface((const nsIID)uuid, (void **)&res); if (NS_FAILED(rv)) croak("QueryInterface failed, rv=%d\n", rv); /* XXX: let me know if there's a better way to do this... */ if (uuid.Equals(nsIDOMAbstractView::GetIID())) { RETVAL = newSVnsIDOMAbstractView((nsIDOMAbstractView *)res); } else if (uuid.Equals(nsIDOMAttr::GetIID())) { RETVAL = newSVnsIDOMAttr((nsIDOMAttr *)res); } else if (uuid.Equals(nsIDOMCDATASection::GetIID())) { RETVAL = newSVnsIDOMCDATASection((nsIDOMCDATASection *)res); } else if (uuid.Equals(nsIDOMCharacterData::GetIID())) { RETVAL = newSVnsIDOMCharacterData((nsIDOMCharacterData *)res); } else if (uuid.Equals(nsIDOMComment::GetIID())) { RETVAL = newSVnsIDOMComment((nsIDOMComment *)res); } else if (uuid.Equals(nsIDOMDOMException::GetIID())) { RETVAL = newSVnsIDOMDOMException((nsIDOMDOMException *)res); } else if (uuid.Equals(nsIDOMDOMImplementation::GetIID())) { RETVAL = newSVnsIDOMDOMImplementation((nsIDOMDOMImplementation *)res); } else if (uuid.Equals(nsIDOMDocument::GetIID())) { RETVAL = newSVnsIDOMDocument((nsIDOMDocument *)res); } else if (uuid.Equals(nsIDOMNSDocument::GetIID())) { RETVAL = newSVnsIDOMNSDocument((nsIDOMNSDocument *)res); } else if (uuid.Equals(nsIDOMDocumentEvent::GetIID())) { RETVAL = newSVnsIDOMDocumentEvent((nsIDOMDocumentEvent *)res); } else if (uuid.Equals(nsIDOMDocumentFragment::GetIID())) { RETVAL = newSVnsIDOMDocumentFragment((nsIDOMDocumentFragment *)res); } else if (uuid.Equals(nsIDOMDocumentRange::GetIID())) { RETVAL = newSVnsIDOMDocumentRange((nsIDOMDocumentRange *)res); } else if (uuid.Equals(nsIDOMDocumentType::GetIID())) { RETVAL = newSVnsIDOMDocumentType((nsIDOMDocumentType *)res); } else if (uuid.Equals(nsIDOMDocumentView::GetIID())) { RETVAL = newSVnsIDOMDocumentView((nsIDOMDocumentView *)res); } else if (uuid.Equals(nsIDOMElement::GetIID())) { RETVAL = newSVnsIDOMElement((nsIDOMElement *)res); } else if (uuid.Equals(nsIDOMEntity::GetIID())) { RETVAL = newSVnsIDOMEntity((nsIDOMEntity *)res); } else if (uuid.Equals(nsIDOMEntityReference::GetIID())) { RETVAL = newSVnsIDOMEntityReference((nsIDOMEntityReference *)res); } else if (uuid.Equals(nsIDOMEvent::GetIID())) { RETVAL = newSVnsIDOMEvent((nsIDOMEvent *)res); } else if (uuid.Equals(nsIDOMNSEvent::GetIID())) { RETVAL = newSVnsIDOMNSEvent((nsIDOMNSEvent *)res); } else if (uuid.Equals(nsIDOMEventListener::GetIID())) { RETVAL = newSVnsIDOMEventListener((nsIDOMEventListener *)res); } else if (uuid.Equals(nsIDOMEventTarget::GetIID())) { RETVAL = newSVnsIDOMEventTarget((nsIDOMEventTarget *)res); } else if (uuid.Equals(nsIDOMKeyEvent::GetIID())) { RETVAL = newSVnsIDOMKeyEvent((nsIDOMKeyEvent *)res); } else if (uuid.Equals(nsIDOMMouseEvent::GetIID())) { RETVAL = newSVnsIDOMMouseEvent((nsIDOMMouseEvent *)res); } else if (uuid.Equals(nsIDOMMutationEvent::GetIID())) { RETVAL = newSVnsIDOMMutationEvent((nsIDOMMutationEvent *)res); } else if (uuid.Equals(nsIDOMNamedNodeMap::GetIID())) { RETVAL = newSVnsIDOMNamedNodeMap((nsIDOMNamedNodeMap *)res); } else if (uuid.Equals(nsIDOMNode::GetIID())) { RETVAL = newSVnsIDOMNode((nsIDOMNode *)res); } else if (uuid.Equals(nsIDOMNodeList::GetIID())) { RETVAL = newSVnsIDOMNodeList((nsIDOMNodeList *)res); } else if (uuid.Equals(nsIDOMNotation::GetIID())) { RETVAL = newSVnsIDOMNotation((nsIDOMNotation *)res); } else if (uuid.Equals(nsIDOMProcessingInstruction::GetIID())) { RETVAL = newSVnsIDOMProcessingInstruction((nsIDOMProcessingInstruction *)res); } else if (uuid.Equals(nsIDOMRange::GetIID())) { RETVAL = newSVnsIDOMRange((nsIDOMRange *)res); } else if (uuid.Equals(nsIDOMNSRange::GetIID())) { RETVAL = newSVnsIDOMNSRange((nsIDOMNSRange *)res); } else if (uuid.Equals(nsISelection::GetIID())) { RETVAL = newSVnsISelection((nsISelection *)res); } else if (uuid.Equals(nsIDOMText::GetIID())) { RETVAL = newSVnsIDOMText((nsIDOMText *)res); } else if (uuid.Equals(nsIDOMUIEvent::GetIID())) { RETVAL = newSVnsIDOMUIEvent((nsIDOMUIEvent *)res); } else if (uuid.Equals(nsIDOMNSUIEvent::GetIID())) { RETVAL = newSVnsIDOMNSUIEvent((nsIDOMNSUIEvent *)res); } else if (uuid.Equals(nsIWebBrowser::GetIID())) { RETVAL = newSVnsIWebBrowser((nsIWebBrowser *)res); } else if (uuid.Equals(nsIWebNavigation::GetIID())) { RETVAL = newSVnsIWebNavigation((nsIWebNavigation *)res); } else if (uuid.Equals(nsIURI::GetIID())) { RETVAL = newSVnsIURI((nsIURI *)res); } else if (uuid.Equals(nsIDOMWindow::GetIID())) { RETVAL = newSVnsIDOMWindow((nsIDOMWindow *)res); } else if (uuid.Equals(nsIDOMWindow2::GetIID())) { RETVAL = newSVnsIDOMWindow2((nsIDOMWindow2 *)res); } else if (uuid.Equals(nsIDOMWindowInternal::GetIID())) { RETVAL = newSVnsIDOMWindowInternal((nsIDOMWindowInternal *)res); } else if (uuid.Equals(nsIDOMWindowCollection::GetIID())) { RETVAL = newSVnsIDOMWindowCollection((nsIDOMWindowCollection *)res); } else if (uuid.Equals(nsIDOMHistory::GetIID())) { RETVAL = newSVnsIDOMHistory((nsIDOMHistory *)res); } else if (uuid.Equals(nsIDOMLocation::GetIID())) { RETVAL = newSVnsIDOMLocation((nsIDOMLocation *)res); } else if (uuid.Equals(nsIDOMNavigator::GetIID())) { RETVAL = newSVnsIDOMNavigator((nsIDOMNavigator *)res); } else if (uuid.Equals(nsIDOMScreen::GetIID())) { RETVAL = newSVnsIDOMScreen((nsIDOMScreen *)res); /* nsIDOMHTML* */ } else if (uuid.Equals(nsIDOMHTMLAnchorElement::GetIID())) { RETVAL = newSVnsIDOMHTMLAnchorElement((nsIDOMHTMLAnchorElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLAnchorElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLAnchorElement((nsIDOMNSHTMLAnchorElement *)res); } else if (uuid.Equals(nsIDOMHTMLAppletElement::GetIID())) { RETVAL = newSVnsIDOMHTMLAppletElement((nsIDOMHTMLAppletElement *)res); } else if (uuid.Equals(nsIDOMHTMLAreaElement::GetIID())) { RETVAL = newSVnsIDOMHTMLAreaElement((nsIDOMHTMLAreaElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLAreaElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLAreaElement((nsIDOMNSHTMLAreaElement *)res); } else if (uuid.Equals(nsIDOMHTMLBRElement::GetIID())) { RETVAL = newSVnsIDOMHTMLBRElement((nsIDOMHTMLBRElement *)res); } else if (uuid.Equals(nsIDOMHTMLBaseElement::GetIID())) { RETVAL = newSVnsIDOMHTMLBaseElement((nsIDOMHTMLBaseElement *)res); } else if (uuid.Equals(nsIDOMHTMLBaseFontElement::GetIID())) { RETVAL = newSVnsIDOMHTMLBaseFontElement((nsIDOMHTMLBaseFontElement *)res); } else if (uuid.Equals(nsIDOMHTMLBodyElement::GetIID())) { RETVAL = newSVnsIDOMHTMLBodyElement((nsIDOMHTMLBodyElement *)res); } else if (uuid.Equals(nsIDOMHTMLButtonElement::GetIID())) { RETVAL = newSVnsIDOMHTMLButtonElement((nsIDOMHTMLButtonElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLButtonElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLButtonElement((nsIDOMNSHTMLButtonElement *)res); } else if (uuid.Equals(nsIDOMHTMLCollection::GetIID())) { RETVAL = newSVnsIDOMHTMLCollection((nsIDOMHTMLCollection *)res); } else if (uuid.Equals(nsIDOMHTMLDListElement::GetIID())) { RETVAL = newSVnsIDOMHTMLDListElement((nsIDOMHTMLDListElement *)res); } else if (uuid.Equals(nsIDOMHTMLDirectoryElement::GetIID())) { RETVAL = newSVnsIDOMHTMLDirectoryElement((nsIDOMHTMLDirectoryElement *)res); } else if (uuid.Equals(nsIDOMHTMLDivElement::GetIID())) { RETVAL = newSVnsIDOMHTMLDivElement((nsIDOMHTMLDivElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLDocument::GetIID())) { RETVAL = newSVnsIDOMNSHTMLDocument((nsIDOMNSHTMLDocument *)res); } else if (uuid.Equals(nsIDOMHTMLElement::GetIID())) { RETVAL = newSVnsIDOMHTMLElement((nsIDOMHTMLElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLElement((nsIDOMNSHTMLElement *)res); } else if (uuid.Equals(nsIDOMHTMLEmbedElement::GetIID())) { RETVAL = newSVnsIDOMHTMLEmbedElement((nsIDOMHTMLEmbedElement *)res); } else if (uuid.Equals(nsIDOMHTMLFieldSetElement::GetIID())) { RETVAL = newSVnsIDOMHTMLFieldSetElement((nsIDOMHTMLFieldSetElement *)res); } else if (uuid.Equals(nsIDOMHTMLFontElement::GetIID())) { RETVAL = newSVnsIDOMHTMLFontElement((nsIDOMHTMLFontElement *)res); } else if (uuid.Equals(nsIDOMHTMLFormElement::GetIID())) { RETVAL = newSVnsIDOMHTMLFormElement((nsIDOMHTMLFormElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLFormElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLFormElement((nsIDOMNSHTMLFormElement *)res); } else if (uuid.Equals(nsIDOMHTMLFrameElement::GetIID())) { RETVAL = newSVnsIDOMHTMLFrameElement((nsIDOMHTMLFrameElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLFrameElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLFrameElement((nsIDOMNSHTMLFrameElement *)res); } else if (uuid.Equals(nsIDOMHTMLFrameSetElement::GetIID())) { RETVAL = newSVnsIDOMHTMLFrameSetElement((nsIDOMHTMLFrameSetElement *)res); } else if (uuid.Equals(nsIDOMHTMLHRElement::GetIID())) { RETVAL = newSVnsIDOMHTMLHRElement((nsIDOMHTMLHRElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLHRElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLHRElement((nsIDOMNSHTMLHRElement *)res); } else if (uuid.Equals(nsIDOMHTMLHeadElement::GetIID())) { RETVAL = newSVnsIDOMHTMLHeadElement((nsIDOMHTMLHeadElement *)res); } else if (uuid.Equals(nsIDOMHTMLHeadingElement::GetIID())) { RETVAL = newSVnsIDOMHTMLHeadingElement((nsIDOMHTMLHeadingElement *)res); } else if (uuid.Equals(nsIDOMHTMLHtmlElement::GetIID())) { RETVAL = newSVnsIDOMHTMLHtmlElement((nsIDOMHTMLHtmlElement *)res); } else if (uuid.Equals(nsIDOMHTMLIFrameElement::GetIID())) { RETVAL = newSVnsIDOMHTMLIFrameElement((nsIDOMHTMLIFrameElement *)res); } else if (uuid.Equals(nsIDOMHTMLImageElement::GetIID())) { RETVAL = newSVnsIDOMHTMLImageElement((nsIDOMHTMLImageElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLImageElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLImageElement((nsIDOMNSHTMLImageElement *)res); } else if (uuid.Equals(nsIDOMHTMLInputElement::GetIID())) { RETVAL = newSVnsIDOMHTMLInputElement((nsIDOMHTMLInputElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLInputElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLInputElement((nsIDOMNSHTMLInputElement *)res); } else if (uuid.Equals(nsIDOMHTMLIsIndexElement::GetIID())) { RETVAL = newSVnsIDOMHTMLIsIndexElement((nsIDOMHTMLIsIndexElement *)res); } else if (uuid.Equals(nsIDOMHTMLLIElement::GetIID())) { RETVAL = newSVnsIDOMHTMLLIElement((nsIDOMHTMLLIElement *)res); } else if (uuid.Equals(nsIDOMHTMLLabelElement::GetIID())) { RETVAL = newSVnsIDOMHTMLLabelElement((nsIDOMHTMLLabelElement *)res); } else if (uuid.Equals(nsIDOMHTMLLegendElement::GetIID())) { RETVAL = newSVnsIDOMHTMLLegendElement((nsIDOMHTMLLegendElement *)res); } else if (uuid.Equals(nsIDOMHTMLLinkElement::GetIID())) { RETVAL = newSVnsIDOMHTMLLinkElement((nsIDOMHTMLLinkElement *)res); } else if (uuid.Equals(nsIDOMHTMLMapElement::GetIID())) { RETVAL = newSVnsIDOMHTMLMapElement((nsIDOMHTMLMapElement *)res); } else if (uuid.Equals(nsIDOMHTMLMenuElement::GetIID())) { RETVAL = newSVnsIDOMHTMLMenuElement((nsIDOMHTMLMenuElement *)res); } else if (uuid.Equals(nsIDOMHTMLMetaElement::GetIID())) { RETVAL = newSVnsIDOMHTMLMetaElement((nsIDOMHTMLMetaElement *)res); } else if (uuid.Equals(nsIDOMHTMLModElement::GetIID())) { RETVAL = newSVnsIDOMHTMLModElement((nsIDOMHTMLModElement *)res); } else if (uuid.Equals(nsIDOMHTMLOListElement::GetIID())) { RETVAL = newSVnsIDOMHTMLOListElement((nsIDOMHTMLOListElement *)res); } else if (uuid.Equals(nsIDOMHTMLObjectElement::GetIID())) { RETVAL = newSVnsIDOMHTMLObjectElement((nsIDOMHTMLObjectElement *)res); } else if (uuid.Equals(nsIDOMHTMLOptGroupElement::GetIID())) { RETVAL = newSVnsIDOMHTMLOptGroupElement((nsIDOMHTMLOptGroupElement *)res); } else if (uuid.Equals(nsIDOMHTMLOptionElement::GetIID())) { RETVAL = newSVnsIDOMHTMLOptionElement((nsIDOMHTMLOptionElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLOptionElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLOptionElement((nsIDOMNSHTMLOptionElement *)res); } else if (uuid.Equals(nsIDOMHTMLOptionsCollection::GetIID())) { RETVAL = newSVnsIDOMHTMLOptionsCollection((nsIDOMHTMLOptionsCollection *)res); } else if (uuid.Equals(nsIDOMHTMLParagraphElement::GetIID())) { RETVAL = newSVnsIDOMHTMLParagraphElement((nsIDOMHTMLParagraphElement *)res); } else if (uuid.Equals(nsIDOMHTMLParamElement::GetIID())) { RETVAL = newSVnsIDOMHTMLParamElement((nsIDOMHTMLParamElement *)res); } else if (uuid.Equals(nsIDOMHTMLPreElement::GetIID())) { RETVAL = newSVnsIDOMHTMLPreElement((nsIDOMHTMLPreElement *)res); } else if (uuid.Equals(nsIDOMHTMLQuoteElement::GetIID())) { RETVAL = newSVnsIDOMHTMLQuoteElement((nsIDOMHTMLQuoteElement *)res); } else if (uuid.Equals(nsIDOMHTMLScriptElement::GetIID())) { RETVAL = newSVnsIDOMHTMLScriptElement((nsIDOMHTMLScriptElement *)res); } else if (uuid.Equals(nsIDOMHTMLSelectElement::GetIID())) { RETVAL = newSVnsIDOMHTMLSelectElement((nsIDOMHTMLSelectElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLSelectElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLSelectElement((nsIDOMNSHTMLSelectElement *)res); } else if (uuid.Equals(nsIDOMHTMLStyleElement::GetIID())) { RETVAL = newSVnsIDOMHTMLStyleElement((nsIDOMHTMLStyleElement *)res); } else if (uuid.Equals(nsIDOMHTMLTableCaptionElement::GetIID())) { RETVAL = newSVnsIDOMHTMLTableCaptionElement((nsIDOMHTMLTableCaptionElement *)res); } else if (uuid.Equals(nsIDOMHTMLTableCellElement::GetIID())) { RETVAL = newSVnsIDOMHTMLTableCellElement((nsIDOMHTMLTableCellElement *)res); } else if (uuid.Equals(nsIDOMHTMLTableColElement::GetIID())) { RETVAL = newSVnsIDOMHTMLTableColElement((nsIDOMHTMLTableColElement *)res); } else if (uuid.Equals(nsIDOMHTMLTableElement::GetIID())) { RETVAL = newSVnsIDOMHTMLTableElement((nsIDOMHTMLTableElement *)res); } else if (uuid.Equals(nsIDOMHTMLTableRowElement::GetIID())) { RETVAL = newSVnsIDOMHTMLTableRowElement((nsIDOMHTMLTableRowElement *)res); } else if (uuid.Equals(nsIDOMHTMLTableSectionElement::GetIID())) { RETVAL = newSVnsIDOMHTMLTableSectionElement((nsIDOMHTMLTableSectionElement *)res); } else if (uuid.Equals(nsIDOMHTMLTextAreaElement::GetIID())) { RETVAL = newSVnsIDOMHTMLTextAreaElement((nsIDOMHTMLTextAreaElement *)res); } else if (uuid.Equals(nsIDOMNSHTMLTextAreaElement::GetIID())) { RETVAL = newSVnsIDOMNSHTMLTextAreaElement((nsIDOMNSHTMLTextAreaElement *)res); } else if (uuid.Equals(nsIDOMHTMLTitleElement::GetIID())) { RETVAL = newSVnsIDOMHTMLTitleElement((nsIDOMHTMLTitleElement *)res); } else if (uuid.Equals(nsIDOMHTMLUListElement::GetIID())) { RETVAL = newSVnsIDOMHTMLUListElement((nsIDOMHTMLUListElement *)res); } OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::WebBrowser PREFIX = moz_dom_ # /usr/include/mozilla/nsIWebBrowser.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBBROWSER_IID) static nsIID nsIWebBrowser::GetIID() CODE: const nsIID &id = nsIWebBrowser::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ### AddWebBrowserListener(nsIWeakReference *aListener, const nsIID & aIID) #void #moz_dom_AddWebBrowserListener (webbrowser, aListener, aIID) # nsIWebBrowser *webbrowser; # nsIWeakReference * aListener; # const nsIID & aIID; # CODE: # webbrowser->AddWebBrowserListener(aListener, aIID); # ### RemoveWebBrowserListener(nsIWeakReference *aListener, const nsIID & aIID) #void #moz_dom_RemoveWebBrowserListener (webbrowser, aListener, aIID) # nsIWebBrowser *webbrowser; # nsIWeakReference * aListener; # const nsIID & aIID; # CODE: # webbrowser->RemoveWebBrowserListener(aListener, aIID); ## GetContentDOMWindow(nsIDOMWindow * *aContentDOMWindow) nsIDOMWindow * moz_dom_GetContentDOMWindow (browser) nsIWebBrowser *browser PREINIT: nsIDOMWindow *window; CODE: browser->GetContentDOMWindow(&window); if (!window) XSRETURN_UNDEF; else RETVAL = window; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::WebNavigation PREFIX = moz_dom_ # /usr/include/mozilla/docshell/nsIWebNavigation.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBNAVIGATION_IID) static nsIID nsIWebNavigation::GetIID() CODE: const nsIID &id = nsIWebNavigation::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCanGoBack(PRBool *aCanGoBack) PRBool moz_dom_GetCanGoBack (webnavigation) nsIWebNavigation *webnavigation; PREINIT: PRBool aCanGoBack; CODE: webnavigation->GetCanGoBack(&aCanGoBack); RETVAL = aCanGoBack; OUTPUT: RETVAL ## GetCanGoForward(PRBool *aCanGoForward) PRBool moz_dom_GetCanGoForward (webnavigation) nsIWebNavigation *webnavigation; PREINIT: PRBool aCanGoForward; CODE: webnavigation->GetCanGoForward(&aCanGoForward); RETVAL = aCanGoForward; OUTPUT: RETVAL ## GoBack(void) void moz_dom_GoBack (webnavigation) nsIWebNavigation *webnavigation; CODE: webnavigation->GoBack(); ## GoForward(void) void moz_dom_GoForward (webnavigation) nsIWebNavigation *webnavigation; CODE: webnavigation->GoForward(); ## GotoIndex(PRInt32 index) void moz_dom_GotoIndex (webnavigation, index) nsIWebNavigation *webnavigation; PRInt32 index; CODE: webnavigation->GotoIndex(index); # XXX: I really want this! (how do you get an nsIInputStream, though?) # [see mailing-list/xpcom/12660.txt & embedding/6646.txt # g++ testdom.cpp `mozilla-config xpcom --cflags --libs` -I /usr/include/mozilla/content -I /usr/include/mozilla/necko -I /usr/include/mozilla/string -o testdom -Wall # need to link to xpcom and #include "nsCOMPtr.h" # ] #=for apidoc Mozilla::DOM::WebNavigation::LoadURI # #=for signature $webnavigation->LoadURI($uri, $loadflags, $referrer, $postdata, $headers) # # * Loads a given URI. This will give priority to loading the requested URI # * in the object implementing this interface. If it can''t be loaded here # * however, the URL dispatcher will go through its normal process of content # * loading. # * # * @param uri - The URI string to load. # * @param loadFlags - Flags modifying load behaviour. Generally you will pass # * LOAD_FLAGS_NONE for this parameter. # * @param referrer - The referring URI. If this argument is NULL, the # * referring URI will be inferred internally. # * @param postData - nsIInputStream containing POST data for the request. # #Note: there is a similar method in Gtk2::MozEmbed: # # $embed->load_url($url) # #=cut # ### LoadURI(const PRUnichar *uri, PRUint32 loadFlags, nsIURI *referrer, nsIInputStream *postData, nsIInputStream *headers) #void #moz_dom_LoadURI (webnavigation, uri, loadFlags, referrer, postData, headers) # nsIWebNavigation *webnavigation; # const PRUnichar * uri; # PRUint32 loadFlags; # nsIURI * referrer; # nsIInputStream * postData; # nsIInputStream * headers; # CODE: # webnavigation->LoadURI(uri, loadFlags, referrer, postData, headers); ## Reload(PRUint32 reloadFlags) void moz_dom_Reload (webnavigation, reloadFlags) nsIWebNavigation *webnavigation; PRUint32 reloadFlags; CODE: webnavigation->Reload(reloadFlags); ## Stop(PRUint32 stopFlags) void moz_dom_Stop (webnavigation, stopFlags) nsIWebNavigation *webnavigation; PRUint32 stopFlags; CODE: webnavigation->Stop(stopFlags); ## GetDocument(nsIDOMDocument * *aDocument) nsIDOMDocument * moz_dom_GetDocument (webnavigation) nsIWebNavigation *webnavigation; PREINIT: nsIDOMDocument * aDocument; CODE: webnavigation->GetDocument(&aDocument); RETVAL = aDocument; OUTPUT: RETVAL ## GetCurrentURI(nsIURI * *aCurrentURI) nsIURI * moz_dom_GetCurrentURI (webnavigation) nsIWebNavigation *webnavigation; PREINIT: nsIURI * aCurrentURI; CODE: webnavigation->GetCurrentURI(&aCurrentURI); RETVAL = aCurrentURI; OUTPUT: RETVAL ## GetReferringURI(nsIURI * *aReferringURI) nsIURI * moz_dom_GetReferringURI (webnavigation) nsIWebNavigation *webnavigation; PREINIT: nsIURI * aReferringURI; CODE: webnavigation->GetReferringURI(&aReferringURI); RETVAL = aReferringURI; OUTPUT: RETVAL #=for apidoc Mozilla::DOM::WebNavigation::GetSessionHistory # #=for signature $sessionhistory = $webnavigation->GetSessionHistory() # # * The session history object used to store the session history for the # * session. # #=cut # ### GetSessionHistory(nsISHistory * *aSessionHistory) #nsISHistory * #moz_dom_GetSessionHistory (webnavigation) # nsIWebNavigation *webnavigation; # PREINIT: # nsISHistory * aSessionHistory; # CODE: # webnavigation->GetSessionHistory(&aSessionHistory); # RETVAL = aSessionHistory; # OUTPUT: # RETVAL # #=for apidoc Mozilla::DOM::WebNavigation::SetSessionHistory # #=for signature $webnavigation->SetSessionHistory($sessionhistory) # # # #=cut # ### SetSessionHistory(nsISHistory * aSessionHistory) #void #moz_dom_SetSessionHistory (webnavigation, aSessionHistory) # nsIWebNavigation *webnavigation; # nsISHistory * aSessionHistory; # CODE: # webnavigation->SetSessionHistory(aSessionHistory); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::URI PREFIX = moz_dom_ # /usr/include/mozilla/nsIURI.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IURI_IID) static nsIID nsIURI::GetIID() CODE: const nsIID &id = nsIURI::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetSpec(nsACString & aSpec) nsEmbedCString moz_dom_GetSpec (uri) nsIURI *uri; PREINIT: nsEmbedCString aSpec; CODE: uri->GetSpec(aSpec); RETVAL = aSpec; OUTPUT: RETVAL ## SetSpec(const nsACString & aSpec) void moz_dom_SetSpec (uri, aSpec) nsIURI *uri; nsEmbedCString aSpec; CODE: uri->SetSpec(aSpec); ## GetPrePath(nsACString & aPrePath) nsEmbedCString moz_dom_GetPrePath (uri) nsIURI *uri; PREINIT: nsEmbedCString aPrePath; CODE: uri->GetPrePath(aPrePath); RETVAL = aPrePath; OUTPUT: RETVAL ## GetScheme(nsACString & aScheme) nsEmbedCString moz_dom_GetScheme (uri) nsIURI *uri; PREINIT: nsEmbedCString aScheme; CODE: uri->GetScheme(aScheme); RETVAL = aScheme; OUTPUT: RETVAL ## SetScheme(const nsACString & aScheme) void moz_dom_SetScheme (uri, aScheme) nsIURI *uri; nsEmbedCString aScheme; CODE: uri->SetScheme(aScheme); ## GetUserPass(nsACString & aUserPass) nsEmbedCString moz_dom_GetUserPass (uri) nsIURI *uri; PREINIT: nsEmbedCString aUserPass; CODE: uri->GetUserPass(aUserPass); RETVAL = aUserPass; OUTPUT: RETVAL ## SetUserPass(const nsACString & aUserPass) void moz_dom_SetUserPass (uri, aUserPass) nsIURI *uri; nsEmbedCString aUserPass; CODE: uri->SetUserPass(aUserPass); ## GetUsername(nsACString & aUsername) nsEmbedCString moz_dom_GetUsername (uri) nsIURI *uri; PREINIT: nsEmbedCString aUsername; CODE: uri->GetUsername(aUsername); RETVAL = aUsername; OUTPUT: RETVAL ## SetUsername(const nsACString & aUsername) void moz_dom_SetUsername (uri, aUsername) nsIURI *uri; nsEmbedCString aUsername; CODE: uri->SetUsername(aUsername); ## GetPassword(nsACString & aPassword) nsEmbedCString moz_dom_GetPassword (uri) nsIURI *uri; PREINIT: nsEmbedCString aPassword; CODE: uri->GetPassword(aPassword); RETVAL = aPassword; OUTPUT: RETVAL ## SetPassword(const nsACString & aPassword) void moz_dom_SetPassword (uri, aPassword) nsIURI *uri; nsEmbedCString aPassword; CODE: uri->SetPassword(aPassword); ## GetHostPort(nsACString & aHostPort) nsEmbedCString moz_dom_GetHostPort (uri) nsIURI *uri; PREINIT: nsEmbedCString aHostPort; CODE: uri->GetHostPort(aHostPort); RETVAL = aHostPort; OUTPUT: RETVAL ## SetHostPort(const nsACString & aHostPort) void moz_dom_SetHostPort (uri, aHostPort) nsIURI *uri; nsEmbedCString aHostPort; CODE: uri->SetHostPort(aHostPort); ## GetHost(nsACString & aHost) nsEmbedCString moz_dom_GetHost (uri) nsIURI *uri; PREINIT: nsEmbedCString aHost; CODE: uri->GetHost(aHost); RETVAL = aHost; OUTPUT: RETVAL ## SetHost(const nsACString & aHost) void moz_dom_SetHost (uri, aHost) nsIURI *uri; nsEmbedCString aHost; CODE: uri->SetHost(aHost); ## GetPort(PRInt32 *aPort) PRInt32 moz_dom_GetPort (uri) nsIURI *uri; PREINIT: PRInt32 aPort; CODE: uri->GetPort(&aPort); RETVAL = aPort; OUTPUT: RETVAL ## SetPort(PRInt32 aPort) void moz_dom_SetPort (uri, aPort) nsIURI *uri; PRInt32 aPort; CODE: uri->SetPort(aPort); ## GetPath(nsACString & aPath) nsEmbedCString moz_dom_GetPath (uri) nsIURI *uri; PREINIT: nsEmbedCString aPath; CODE: uri->GetPath(aPath); RETVAL = aPath; OUTPUT: RETVAL ## SetPath(const nsACString & aPath) void moz_dom_SetPath (uri, aPath) nsIURI *uri; nsEmbedCString aPath; CODE: uri->SetPath(aPath); ## Equals(nsIURI *other, PRBool *_retval) PRBool moz_dom_Equals (uri, other) nsIURI *uri; nsIURI * other; PREINIT: PRBool _retval; CODE: uri->Equals(other, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## SchemeIs(const char *scheme, PRBool *_retval) PRBool moz_dom_SchemeIs (uri, scheme) nsIURI *uri; const char * scheme; PREINIT: PRBool _retval; CODE: uri->SchemeIs(scheme, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## Clone(nsIURI **_retval) nsIURI * moz_dom_Clone (uri) nsIURI *uri; PREINIT: nsIURI * _retval; CODE: uri->Clone(&_retval); RETVAL = _retval; OUTPUT: RETVAL ## Resolve(const nsACString & relativePath, nsACString & _retval) nsEmbedCString moz_dom_Resolve (uri, relativePath) nsIURI *uri; nsEmbedCString relativePath; PREINIT: nsEmbedCString _retval; CODE: uri->Resolve(relativePath, _retval); RETVAL = _retval; OUTPUT: RETVAL ## GetAsciiSpec(nsACString & aAsciiSpec) nsEmbedCString moz_dom_GetAsciiSpec (uri) nsIURI *uri; PREINIT: nsEmbedCString aAsciiSpec; CODE: uri->GetAsciiSpec(aAsciiSpec); RETVAL = aAsciiSpec; OUTPUT: RETVAL ## GetAsciiHost(nsACString & aAsciiHost) nsEmbedCString moz_dom_GetAsciiHost (uri) nsIURI *uri; PREINIT: nsEmbedCString aAsciiHost; CODE: uri->GetAsciiHost(aAsciiHost); RETVAL = aAsciiHost; OUTPUT: RETVAL ## GetOriginCharset(nsACString & aOriginCharset) nsEmbedCString moz_dom_GetOriginCharset (uri) nsIURI *uri; PREINIT: nsEmbedCString aOriginCharset; CODE: uri->GetOriginCharset(aOriginCharset); RETVAL = aOriginCharset; OUTPUT: RETVAL # ----------------------------------------------------------------------------- # nsIDOMHTML*Element ! # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLAnchorElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLAnchorElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLANCHORELEMENT_IID) static nsIID nsIDOMHTMLAnchorElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLAnchorElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAccessKey(nsAString & aAccessKey) nsEmbedString moz_dom_GetAccessKey (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString accesskey; CODE: htmlanchorelement->GetAccessKey(accesskey); RETVAL = accesskey; OUTPUT: RETVAL ## SetAccessKey(const nsAString & aAccessKey) void moz_dom_SetAccessKey (htmlanchorelement, accesskey) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString accesskey; CODE: htmlanchorelement->SetAccessKey(accesskey); ## GetCharset(nsAString & aCharset) nsEmbedString moz_dom_GetCharset (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString charset; CODE: htmlanchorelement->GetCharset(charset); RETVAL = charset; OUTPUT: RETVAL ## SetCharset(const nsAString & aCharset) void moz_dom_SetCharset (htmlanchorelement, charset) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString charset; CODE: htmlanchorelement->SetCharset(charset); ## GetCoords(nsAString & aCoords) nsEmbedString moz_dom_GetCoords (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString coords; CODE: htmlanchorelement->GetCoords(coords); RETVAL = coords; OUTPUT: RETVAL ## SetCoords(const nsAString & aCoords) void moz_dom_SetCoords (htmlanchorelement, coords) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString coords; CODE: htmlanchorelement->SetCoords(coords); ## GetHref(nsAString & aHref) nsEmbedString moz_dom_GetHref (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString href; CODE: htmlanchorelement->GetHref(href); RETVAL = href; OUTPUT: RETVAL ## SetHref(const nsAString & aHref) void moz_dom_SetHref (htmlanchorelement, href) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString href; CODE: htmlanchorelement->SetHref(href); ## GetHreflang(nsAString & aHreflang) nsEmbedString moz_dom_GetHreflang (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString hreflang; CODE: htmlanchorelement->GetHreflang(hreflang); RETVAL = hreflang; OUTPUT: RETVAL ## SetHreflang(const nsAString & aHreflang) void moz_dom_SetHreflang (htmlanchorelement, hreflang) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString hreflang; CODE: htmlanchorelement->SetHreflang(hreflang); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString name; CODE: htmlanchorelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlanchorelement, name) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString name; CODE: htmlanchorelement->SetName(name); ## GetRel(nsAString & aRel) nsEmbedString moz_dom_GetRel (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString rel; CODE: htmlanchorelement->GetRel(rel); RETVAL = rel; OUTPUT: RETVAL ## SetRel(const nsAString & aRel) void moz_dom_SetRel (htmlanchorelement, rel) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString rel; CODE: htmlanchorelement->SetRel(rel); ## GetRev(nsAString & aRev) nsEmbedString moz_dom_GetRev (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString rev; CODE: htmlanchorelement->GetRev(rev); RETVAL = rev; OUTPUT: RETVAL ## SetRev(const nsAString & aRev) void moz_dom_SetRev (htmlanchorelement, rev) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString rev; CODE: htmlanchorelement->SetRev(rev); ## GetShape(nsAString & aShape) nsEmbedString moz_dom_GetShape (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString shape; CODE: htmlanchorelement->GetShape(shape); RETVAL = shape; OUTPUT: RETVAL ## SetShape(const nsAString & aShape) void moz_dom_SetShape (htmlanchorelement, shape) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString shape; CODE: htmlanchorelement->SetShape(shape); ## GetTabIndex(PRInt32 *aTabIndex) PRInt32 moz_dom_GetTabIndex (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: PRInt32 tabindex; CODE: htmlanchorelement->GetTabIndex(&tabindex); RETVAL = tabindex; OUTPUT: RETVAL ## SetTabIndex(PRInt32 aTabIndex) void moz_dom_SetTabIndex (htmlanchorelement, tabindex) nsIDOMHTMLAnchorElement *htmlanchorelement; PRInt32 tabindex; CODE: htmlanchorelement->SetTabIndex(tabindex); ## GetTarget(nsAString & aTarget) nsEmbedString moz_dom_GetTarget (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString target; CODE: htmlanchorelement->GetTarget(target); RETVAL = target; OUTPUT: RETVAL ## SetTarget(const nsAString & aTarget) void moz_dom_SetTarget (htmlanchorelement, target) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString target; CODE: htmlanchorelement->SetTarget(target); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; PREINIT: nsEmbedString type; CODE: htmlanchorelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlanchorelement, type) nsIDOMHTMLAnchorElement *htmlanchorelement; nsEmbedString type; CODE: htmlanchorelement->SetType(type); ## Blur(void) void moz_dom_Blur (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; CODE: htmlanchorelement->Blur(); ## Focus(void) void moz_dom_Focus (htmlanchorelement) nsIDOMHTMLAnchorElement *htmlanchorelement; CODE: htmlanchorelement->Focus(); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLAppletElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLAppletElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLAPPLETELEMENT_IID) static nsIID nsIDOMHTMLAppletElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLAppletElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString align; CODE: htmlappletelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmlappletelement, align) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString align; CODE: htmlappletelement->SetAlign(align); ## GetAlt(nsAString & aAlt) nsEmbedString moz_dom_GetAlt (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString alt; CODE: htmlappletelement->GetAlt(alt); RETVAL = alt; OUTPUT: RETVAL ## SetAlt(const nsAString & aAlt) void moz_dom_SetAlt (htmlappletelement, alt) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString alt; CODE: htmlappletelement->SetAlt(alt); ## GetArchive(nsAString & aArchive) nsEmbedString moz_dom_GetArchive (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString archive; CODE: htmlappletelement->GetArchive(archive); RETVAL = archive; OUTPUT: RETVAL ## SetArchive(const nsAString & aArchive) void moz_dom_SetArchive (htmlappletelement, archive) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString archive; CODE: htmlappletelement->SetArchive(archive); ## GetCode(nsAString & aCode) nsEmbedString moz_dom_GetCode (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString code; CODE: htmlappletelement->GetCode(code); RETVAL = code; OUTPUT: RETVAL ## SetCode(const nsAString & aCode) void moz_dom_SetCode (htmlappletelement, code) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString code; CODE: htmlappletelement->SetCode(code); ## GetCodeBase(nsAString & aCodeBase) nsEmbedString moz_dom_GetCodeBase (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString codebase; CODE: htmlappletelement->GetCodeBase(codebase); RETVAL = codebase; OUTPUT: RETVAL ## SetCodeBase(const nsAString & aCodeBase) void moz_dom_SetCodeBase (htmlappletelement, codebase) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString codebase; CODE: htmlappletelement->SetCodeBase(codebase); ## GetHeight(nsAString & aHeight) nsEmbedString moz_dom_GetHeight (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString height; CODE: htmlappletelement->GetHeight(height); RETVAL = height; OUTPUT: RETVAL ## SetHeight(const nsAString & aHeight) void moz_dom_SetHeight (htmlappletelement, height) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString height; CODE: htmlappletelement->SetHeight(height); ## GetHspace(PRInt32 *aHspace) PRInt32 moz_dom_GetHspace (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: PRInt32 hspace; CODE: htmlappletelement->GetHspace(&hspace); RETVAL = hspace; OUTPUT: RETVAL ## SetHspace(PRInt32 aHspace) void moz_dom_SetHspace (htmlappletelement, hspace) nsIDOMHTMLAppletElement *htmlappletelement; PRInt32 hspace; CODE: htmlappletelement->SetHspace(hspace); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString name; CODE: htmlappletelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlappletelement, name) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString name; CODE: htmlappletelement->SetName(name); ## GetObject(nsAString & aObject) nsEmbedString moz_dom_GetObject (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString object; CODE: htmlappletelement->GetObject(object); RETVAL = object; OUTPUT: RETVAL ## SetObject(const nsAString & aObject) void moz_dom_SetObject (htmlappletelement, object) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString object; CODE: htmlappletelement->SetObject(object); ## GetVspace(PRInt32 *aVspace) PRInt32 moz_dom_GetVspace (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: PRInt32 vspace; CODE: htmlappletelement->GetVspace(&vspace); RETVAL = vspace; OUTPUT: RETVAL ## SetVspace(PRInt32 aVspace) void moz_dom_SetVspace (htmlappletelement, vspace) nsIDOMHTMLAppletElement *htmlappletelement; PRInt32 vspace; CODE: htmlappletelement->SetVspace(vspace); ## GetWidth(nsAString & aWidth) nsEmbedString moz_dom_GetWidth (htmlappletelement) nsIDOMHTMLAppletElement *htmlappletelement; PREINIT: nsEmbedString width; CODE: htmlappletelement->GetWidth(width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(const nsAString & aWidth) void moz_dom_SetWidth (htmlappletelement, width) nsIDOMHTMLAppletElement *htmlappletelement; nsEmbedString width; CODE: htmlappletelement->SetWidth(width); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLAreaElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLAreaElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLAREAELEMENT_IID) static nsIID nsIDOMHTMLAreaElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLAreaElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAccessKey(nsAString & aAccessKey) nsEmbedString moz_dom_GetAccessKey (htmlareaelement) nsIDOMHTMLAreaElement *htmlareaelement; PREINIT: nsEmbedString accesskey; CODE: htmlareaelement->GetAccessKey(accesskey); RETVAL = accesskey; OUTPUT: RETVAL ## SetAccessKey(const nsAString & aAccessKey) void moz_dom_SetAccessKey (htmlareaelement, accesskey) nsIDOMHTMLAreaElement *htmlareaelement; nsEmbedString accesskey; CODE: htmlareaelement->SetAccessKey(accesskey); ## GetAlt(nsAString & aAlt) nsEmbedString moz_dom_GetAlt (htmlareaelement) nsIDOMHTMLAreaElement *htmlareaelement; PREINIT: nsEmbedString alt; CODE: htmlareaelement->GetAlt(alt); RETVAL = alt; OUTPUT: RETVAL ## SetAlt(const nsAString & aAlt) void moz_dom_SetAlt (htmlareaelement, alt) nsIDOMHTMLAreaElement *htmlareaelement; nsEmbedString alt; CODE: htmlareaelement->SetAlt(alt); ## GetCoords(nsAString & aCoords) nsEmbedString moz_dom_GetCoords (htmlareaelement) nsIDOMHTMLAreaElement *htmlareaelement; PREINIT: nsEmbedString coords; CODE: htmlareaelement->GetCoords(coords); RETVAL = coords; OUTPUT: RETVAL ## SetCoords(const nsAString & aCoords) void moz_dom_SetCoords (htmlareaelement, coords) nsIDOMHTMLAreaElement *htmlareaelement; nsEmbedString coords; CODE: htmlareaelement->SetCoords(coords); ## GetHref(nsAString & aHref) nsEmbedString moz_dom_GetHref (htmlareaelement) nsIDOMHTMLAreaElement *htmlareaelement; PREINIT: nsEmbedString href; CODE: htmlareaelement->GetHref(href); RETVAL = href; OUTPUT: RETVAL ## SetHref(const nsAString & aHref) void moz_dom_SetHref (htmlareaelement, href) nsIDOMHTMLAreaElement *htmlareaelement; nsEmbedString href; CODE: htmlareaelement->SetHref(href); ## GetNoHref(PRBool *aNoHref) PRBool moz_dom_GetNoHref (htmlareaelement) nsIDOMHTMLAreaElement *htmlareaelement; PREINIT: PRBool nohref; CODE: htmlareaelement->GetNoHref(&nohref); RETVAL = nohref; OUTPUT: RETVAL ## SetNoHref(PRBool aNoHref) void moz_dom_SetNoHref (htmlareaelement, nohref) nsIDOMHTMLAreaElement *htmlareaelement; PRBool nohref; CODE: htmlareaelement->SetNoHref(nohref); ## GetShape(nsAString & aShape) nsEmbedString moz_dom_GetShape (htmlareaelement) nsIDOMHTMLAreaElement *htmlareaelement; PREINIT: nsEmbedString shape; CODE: htmlareaelement->GetShape(shape); RETVAL = shape; OUTPUT: RETVAL ## SetShape(const nsAString & aShape) void moz_dom_SetShape (htmlareaelement, shape) nsIDOMHTMLAreaElement *htmlareaelement; nsEmbedString shape; CODE: htmlareaelement->SetShape(shape); ## GetTabIndex(PRInt32 *aTabIndex) PRInt32 moz_dom_GetTabIndex (htmlareaelement) nsIDOMHTMLAreaElement *htmlareaelement; PREINIT: PRInt32 tabindex; CODE: htmlareaelement->GetTabIndex(&tabindex); RETVAL = tabindex; OUTPUT: RETVAL ## SetTabIndex(PRInt32 aTabIndex) void moz_dom_SetTabIndex (htmlareaelement, tabindex) nsIDOMHTMLAreaElement *htmlareaelement; PRInt32 tabindex; CODE: htmlareaelement->SetTabIndex(tabindex); ## GetTarget(nsAString & aTarget) nsEmbedString moz_dom_GetTarget (htmlareaelement) nsIDOMHTMLAreaElement *htmlareaelement; PREINIT: nsEmbedString target; CODE: htmlareaelement->GetTarget(target); RETVAL = target; OUTPUT: RETVAL ## SetTarget(const nsAString & aTarget) void moz_dom_SetTarget (htmlareaelement, target) nsIDOMHTMLAreaElement *htmlareaelement; nsEmbedString target; CODE: htmlareaelement->SetTarget(target); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLBRElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLBRElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLBRELEMENT_IID) static nsIID nsIDOMHTMLBRElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLBRElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetClear(nsAString & aClear) nsEmbedString moz_dom_GetClear (htmlbrelement) nsIDOMHTMLBRElement *htmlbrelement; PREINIT: nsEmbedString clear; CODE: htmlbrelement->GetClear(clear); RETVAL = clear; OUTPUT: RETVAL ## SetClear(const nsAString & aClear) void moz_dom_SetClear (htmlbrelement, clear) nsIDOMHTMLBRElement *htmlbrelement; nsEmbedString clear; CODE: htmlbrelement->SetClear(clear); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLBaseElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLBaseElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLBASEELEMENT_IID) static nsIID nsIDOMHTMLBaseElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLBaseElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetHref(nsAString & aHref) nsEmbedString moz_dom_GetHref (htmlbaseelement) nsIDOMHTMLBaseElement *htmlbaseelement; PREINIT: nsEmbedString href; CODE: htmlbaseelement->GetHref(href); RETVAL = href; OUTPUT: RETVAL ## SetHref(const nsAString & aHref) void moz_dom_SetHref (htmlbaseelement, href) nsIDOMHTMLBaseElement *htmlbaseelement; nsEmbedString href; CODE: htmlbaseelement->SetHref(href); ## GetTarget(nsAString & aTarget) nsEmbedString moz_dom_GetTarget (htmlbaseelement) nsIDOMHTMLBaseElement *htmlbaseelement; PREINIT: nsEmbedString target; CODE: htmlbaseelement->GetTarget(target); RETVAL = target; OUTPUT: RETVAL ## SetTarget(const nsAString & aTarget) void moz_dom_SetTarget (htmlbaseelement, target) nsIDOMHTMLBaseElement *htmlbaseelement; nsEmbedString target; CODE: htmlbaseelement->SetTarget(target); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLBaseFontElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLBaseFontElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLBASEFONTELEMENT_IID) static nsIID nsIDOMHTMLBaseFontElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLBaseFontElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetColor(nsAString & aColor) nsEmbedString moz_dom_GetColor (htmlbasefontelement) nsIDOMHTMLBaseFontElement *htmlbasefontelement; PREINIT: nsEmbedString color; CODE: htmlbasefontelement->GetColor(color); RETVAL = color; OUTPUT: RETVAL ## SetColor(const nsAString & aColor) void moz_dom_SetColor (htmlbasefontelement, color) nsIDOMHTMLBaseFontElement *htmlbasefontelement; nsEmbedString color; CODE: htmlbasefontelement->SetColor(color); ## GetFace(nsAString & aFace) nsEmbedString moz_dom_GetFace (htmlbasefontelement) nsIDOMHTMLBaseFontElement *htmlbasefontelement; PREINIT: nsEmbedString face; CODE: htmlbasefontelement->GetFace(face); RETVAL = face; OUTPUT: RETVAL ## SetFace(const nsAString & aFace) void moz_dom_SetFace (htmlbasefontelement, face) nsIDOMHTMLBaseFontElement *htmlbasefontelement; nsEmbedString face; CODE: htmlbasefontelement->SetFace(face); ## GetSize(PRInt32 *aSize) PRInt32 moz_dom_GetSize (htmlbasefontelement) nsIDOMHTMLBaseFontElement *htmlbasefontelement; PREINIT: PRInt32 size; CODE: htmlbasefontelement->GetSize(&size); RETVAL = size; OUTPUT: RETVAL ## SetSize(PRInt32 aSize) void moz_dom_SetSize (htmlbasefontelement, size) nsIDOMHTMLBaseFontElement *htmlbasefontelement; PRInt32 size; CODE: htmlbasefontelement->SetSize(size); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLBodyElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLBodyElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLBODYELEMENT_IID) static nsIID nsIDOMHTMLBodyElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLBodyElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetALink(nsAString & aALink) nsEmbedString moz_dom_GetALink (htmlbodyelement) nsIDOMHTMLBodyElement *htmlbodyelement; PREINIT: nsEmbedString alink; CODE: htmlbodyelement->GetALink(alink); RETVAL = alink; OUTPUT: RETVAL ## SetALink(const nsAString & aALink) void moz_dom_SetALink (htmlbodyelement, alink) nsIDOMHTMLBodyElement *htmlbodyelement; nsEmbedString alink; CODE: htmlbodyelement->SetALink(alink); ## GetBackground(nsAString & aBackground) nsEmbedString moz_dom_GetBackground (htmlbodyelement) nsIDOMHTMLBodyElement *htmlbodyelement; PREINIT: nsEmbedString background; CODE: htmlbodyelement->GetBackground(background); RETVAL = background; OUTPUT: RETVAL ## SetBackground(const nsAString & aBackground) void moz_dom_SetBackground (htmlbodyelement, background) nsIDOMHTMLBodyElement *htmlbodyelement; nsEmbedString background; CODE: htmlbodyelement->SetBackground(background); ## GetBgColor(nsAString & aBgColor) nsEmbedString moz_dom_GetBgColor (htmlbodyelement) nsIDOMHTMLBodyElement *htmlbodyelement; PREINIT: nsEmbedString bgcolor; CODE: htmlbodyelement->GetBgColor(bgcolor); RETVAL = bgcolor; OUTPUT: RETVAL ## SetBgColor(const nsAString & aBgColor) void moz_dom_SetBgColor (htmlbodyelement, bgcolor) nsIDOMHTMLBodyElement *htmlbodyelement; nsEmbedString bgcolor; CODE: htmlbodyelement->SetBgColor(bgcolor); ## GetLink(nsAString & aLink) nsEmbedString moz_dom_GetLink (htmlbodyelement) nsIDOMHTMLBodyElement *htmlbodyelement; PREINIT: nsEmbedString link; CODE: htmlbodyelement->GetLink(link); RETVAL = link; OUTPUT: RETVAL ## SetLink(const nsAString & aLink) void moz_dom_SetLink (htmlbodyelement, link) nsIDOMHTMLBodyElement *htmlbodyelement; nsEmbedString link; CODE: htmlbodyelement->SetLink(link); ## GetText(nsAString & aText) nsEmbedString moz_dom_GetText (htmlbodyelement) nsIDOMHTMLBodyElement *htmlbodyelement; PREINIT: nsEmbedString text; CODE: htmlbodyelement->GetText(text); RETVAL = text; OUTPUT: RETVAL ## SetText(const nsAString & aText) void moz_dom_SetText (htmlbodyelement, text) nsIDOMHTMLBodyElement *htmlbodyelement; nsEmbedString text; CODE: htmlbodyelement->SetText(text); ## GetVLink(nsAString & aVLink) nsEmbedString moz_dom_GetVLink (htmlbodyelement) nsIDOMHTMLBodyElement *htmlbodyelement; PREINIT: nsEmbedString vlink; CODE: htmlbodyelement->GetVLink(vlink); RETVAL = vlink; OUTPUT: RETVAL ## SetVLink(const nsAString & aVLink) void moz_dom_SetVLink (htmlbodyelement, vlink) nsIDOMHTMLBodyElement *htmlbodyelement; nsEmbedString vlink; CODE: htmlbodyelement->SetVLink(vlink); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLButtonElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLButtonElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLBUTTONELEMENT_IID) static nsIID nsIDOMHTMLButtonElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLButtonElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmlbuttonelement) nsIDOMHTMLButtonElement *htmlbuttonelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmlbuttonelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetAccessKey(nsAString & aAccessKey) nsEmbedString moz_dom_GetAccessKey (htmlbuttonelement) nsIDOMHTMLButtonElement *htmlbuttonelement; PREINIT: nsEmbedString accesskey; CODE: htmlbuttonelement->GetAccessKey(accesskey); RETVAL = accesskey; OUTPUT: RETVAL ## SetAccessKey(const nsAString & aAccessKey) void moz_dom_SetAccessKey (htmlbuttonelement, accesskey) nsIDOMHTMLButtonElement *htmlbuttonelement; nsEmbedString accesskey; CODE: htmlbuttonelement->SetAccessKey(accesskey); ## GetDisabled(PRBool *aDisabled) PRBool moz_dom_GetDisabled (htmlbuttonelement) nsIDOMHTMLButtonElement *htmlbuttonelement; PREINIT: PRBool disabled; CODE: htmlbuttonelement->GetDisabled(&disabled); RETVAL = disabled; OUTPUT: RETVAL ## SetDisabled(PRBool aDisabled) void moz_dom_SetDisabled (htmlbuttonelement, disabled) nsIDOMHTMLButtonElement *htmlbuttonelement; PRBool disabled; CODE: htmlbuttonelement->SetDisabled(disabled); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlbuttonelement) nsIDOMHTMLButtonElement *htmlbuttonelement; PREINIT: nsEmbedString name; CODE: htmlbuttonelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlbuttonelement, name) nsIDOMHTMLButtonElement *htmlbuttonelement; nsEmbedString name; CODE: htmlbuttonelement->SetName(name); ## GetTabIndex(PRInt32 *aTabIndex) PRInt32 moz_dom_GetTabIndex (htmlbuttonelement) nsIDOMHTMLButtonElement *htmlbuttonelement; PREINIT: PRInt32 tabindex; CODE: htmlbuttonelement->GetTabIndex(&tabindex); RETVAL = tabindex; OUTPUT: RETVAL ## SetTabIndex(PRInt32 aTabIndex) void moz_dom_SetTabIndex (htmlbuttonelement, tabindex) nsIDOMHTMLButtonElement *htmlbuttonelement; PRInt32 tabindex; CODE: htmlbuttonelement->SetTabIndex(tabindex); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlbuttonelement) nsIDOMHTMLButtonElement *htmlbuttonelement; PREINIT: nsEmbedString type; CODE: htmlbuttonelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## GetValue(nsAString & aValue) nsEmbedString moz_dom_GetValue (htmlbuttonelement) nsIDOMHTMLButtonElement *htmlbuttonelement; PREINIT: nsEmbedString value; CODE: htmlbuttonelement->GetValue(value); RETVAL = value; OUTPUT: RETVAL ## SetValue(const nsAString & aValue) void moz_dom_SetValue (htmlbuttonelement, value) nsIDOMHTMLButtonElement *htmlbuttonelement; nsEmbedString value; CODE: htmlbuttonelement->SetValue(value); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLCollection PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLCollection.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLCOLLECTION_IID) static nsIID nsIDOMHTMLCollection::GetIID() CODE: const nsIID &id = nsIDOMHTMLCollection::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetLength(PRUint32 *aLength) PRUint32 moz_dom_GetLength (htmlcollection) nsIDOMHTMLCollection *htmlcollection; PREINIT: PRUint32 length; CODE: htmlcollection->GetLength(&length); RETVAL = length; OUTPUT: RETVAL ## Item(PRUint32 index, nsIDOMNode **_retval) nsIDOMNode * moz_dom_Item (htmlcollection, index) nsIDOMHTMLCollection *htmlcollection; PRUint32 index; PREINIT: nsIDOMNode * retval; CODE: htmlcollection->Item(index, &retval); RETVAL = retval; OUTPUT: RETVAL ## NamedItem(const nsAString & name, nsIDOMNode **_retval) nsIDOMNode * moz_dom_NamedItem (htmlcollection, name) nsIDOMHTMLCollection *htmlcollection; nsEmbedString name; PREINIT: nsIDOMNode * retval; CODE: htmlcollection->NamedItem(name, &retval); RETVAL = retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLDListElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLDListElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLDLISTELEMENT_IID) static nsIID nsIDOMHTMLDListElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLDListElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCompact(PRBool *aCompact) PRBool moz_dom_GetCompact (htmldlistelement) nsIDOMHTMLDListElement *htmldlistelement; PREINIT: PRBool compact; CODE: htmldlistelement->GetCompact(&compact); RETVAL = compact; OUTPUT: RETVAL ## SetCompact(PRBool aCompact) void moz_dom_SetCompact (htmldlistelement, compact) nsIDOMHTMLDListElement *htmldlistelement; PRBool compact; CODE: htmldlistelement->SetCompact(compact); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLDirectoryElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLDirectoryElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLDIRECTORYELEMENT_IID) static nsIID nsIDOMHTMLDirectoryElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLDirectoryElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCompact(PRBool *aCompact) PRBool moz_dom_GetCompact (htmldirectoryelement) nsIDOMHTMLDirectoryElement *htmldirectoryelement; PREINIT: PRBool compact; CODE: htmldirectoryelement->GetCompact(&compact); RETVAL = compact; OUTPUT: RETVAL ## SetCompact(PRBool aCompact) void moz_dom_SetCompact (htmldirectoryelement, compact) nsIDOMHTMLDirectoryElement *htmldirectoryelement; PRBool compact; CODE: htmldirectoryelement->SetCompact(compact); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLDivElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLDivElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLDIVELEMENT_IID) static nsIID nsIDOMHTMLDivElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLDivElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmldivelement) nsIDOMHTMLDivElement *htmldivelement; PREINIT: nsEmbedString align; CODE: htmldivelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmldivelement, align) nsIDOMHTMLDivElement *htmldivelement; nsEmbedString align; CODE: htmldivelement->SetAlign(align); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLELEMENT_IID) static nsIID nsIDOMHTMLElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetId(nsAString & aId) nsEmbedString moz_dom_GetId (htmlelement) nsIDOMHTMLElement *htmlelement; PREINIT: nsEmbedString id; CODE: htmlelement->GetId(id); RETVAL = id; OUTPUT: RETVAL ## SetId(const nsAString & aId) void moz_dom_SetId (htmlelement, id) nsIDOMHTMLElement *htmlelement; nsEmbedString id; CODE: htmlelement->SetId(id); ## GetTitle(nsAString & aTitle) nsEmbedString moz_dom_GetTitle (htmlelement) nsIDOMHTMLElement *htmlelement; PREINIT: nsEmbedString title; CODE: htmlelement->GetTitle(title); RETVAL = title; OUTPUT: RETVAL ## SetTitle(const nsAString & aTitle) void moz_dom_SetTitle (htmlelement, title) nsIDOMHTMLElement *htmlelement; nsEmbedString title; CODE: htmlelement->SetTitle(title); ## GetLang(nsAString & aLang) nsEmbedString moz_dom_GetLang (htmlelement) nsIDOMHTMLElement *htmlelement; PREINIT: nsEmbedString lang; CODE: htmlelement->GetLang(lang); RETVAL = lang; OUTPUT: RETVAL ## SetLang(const nsAString & aLang) void moz_dom_SetLang (htmlelement, lang) nsIDOMHTMLElement *htmlelement; nsEmbedString lang; CODE: htmlelement->SetLang(lang); ## GetDir(nsAString & aDir) nsEmbedString moz_dom_GetDir (htmlelement) nsIDOMHTMLElement *htmlelement; PREINIT: nsEmbedString dir; CODE: htmlelement->GetDir(dir); RETVAL = dir; OUTPUT: RETVAL ## SetDir(const nsAString & aDir) void moz_dom_SetDir (htmlelement, dir) nsIDOMHTMLElement *htmlelement; nsEmbedString dir; CODE: htmlelement->SetDir(dir); ## GetClassName(nsAString & aClassName) nsEmbedString moz_dom_GetClassName (htmlelement) nsIDOMHTMLElement *htmlelement; PREINIT: nsEmbedString classname; CODE: htmlelement->GetClassName(classname); RETVAL = classname; OUTPUT: RETVAL ## SetClassName(const nsAString & aClassName) void moz_dom_SetClassName (htmlelement, classname) nsIDOMHTMLElement *htmlelement; nsEmbedString classname; CODE: htmlelement->SetClassName(classname); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLELEMENT_IID) static nsIID nsIDOMNSHTMLElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetOffsetTop(PRInt32 *aOffsetTop) PRInt32 moz_dom_GetOffsetTop (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aOffsetTop; CODE: nshtmlelement->GetOffsetTop(&aOffsetTop); RETVAL = aOffsetTop; OUTPUT: RETVAL ## GetOffsetLeft(PRInt32 *aOffsetLeft) PRInt32 moz_dom_GetOffsetLeft (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aOffsetLeft; CODE: nshtmlelement->GetOffsetLeft(&aOffsetLeft); RETVAL = aOffsetLeft; OUTPUT: RETVAL ## GetOffsetWidth(PRInt32 *aOffsetWidth) PRInt32 moz_dom_GetOffsetWidth (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aOffsetWidth; CODE: nshtmlelement->GetOffsetWidth(&aOffsetWidth); RETVAL = aOffsetWidth; OUTPUT: RETVAL ## GetOffsetHeight(PRInt32 *aOffsetHeight) PRInt32 moz_dom_GetOffsetHeight (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aOffsetHeight; CODE: nshtmlelement->GetOffsetHeight(&aOffsetHeight); RETVAL = aOffsetHeight; OUTPUT: RETVAL ## GetOffsetParent(nsIDOMElement * *aOffsetParent) nsIDOMElement * moz_dom_GetOffsetParent (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: nsIDOMElement * aOffsetParent; CODE: nshtmlelement->GetOffsetParent(&aOffsetParent); RETVAL = aOffsetParent; OUTPUT: RETVAL ## GetInnerHTML(nsAString & aInnerHTML) nsEmbedString moz_dom_GetInnerHTML (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: nsEmbedString aInnerHTML; CODE: nshtmlelement->GetInnerHTML(aInnerHTML); RETVAL = aInnerHTML; OUTPUT: RETVAL ## SetInnerHTML(const nsAString & aInnerHTML) void moz_dom_SetInnerHTML (nshtmlelement, aInnerHTML) nsIDOMNSHTMLElement *nshtmlelement; nsEmbedString aInnerHTML; CODE: nshtmlelement->SetInnerHTML(aInnerHTML); ## GetScrollTop(PRInt32 *aScrollTop) PRInt32 moz_dom_GetScrollTop (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aScrollTop; CODE: nshtmlelement->GetScrollTop(&aScrollTop); RETVAL = aScrollTop; OUTPUT: RETVAL ## SetScrollTop(PRInt32 aScrollTop) void moz_dom_SetScrollTop (nshtmlelement, aScrollTop) nsIDOMNSHTMLElement *nshtmlelement; PRInt32 aScrollTop; CODE: nshtmlelement->SetScrollTop(aScrollTop); ## GetScrollLeft(PRInt32 *aScrollLeft) PRInt32 moz_dom_GetScrollLeft (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aScrollLeft; CODE: nshtmlelement->GetScrollLeft(&aScrollLeft); RETVAL = aScrollLeft; OUTPUT: RETVAL ## SetScrollLeft(PRInt32 aScrollLeft) void moz_dom_SetScrollLeft (nshtmlelement, aScrollLeft) nsIDOMNSHTMLElement *nshtmlelement; PRInt32 aScrollLeft; CODE: nshtmlelement->SetScrollLeft(aScrollLeft); ## GetScrollHeight(PRInt32 *aScrollHeight) PRInt32 moz_dom_GetScrollHeight (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aScrollHeight; CODE: nshtmlelement->GetScrollHeight(&aScrollHeight); RETVAL = aScrollHeight; OUTPUT: RETVAL ## GetScrollWidth(PRInt32 *aScrollWidth) PRInt32 moz_dom_GetScrollWidth (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aScrollWidth; CODE: nshtmlelement->GetScrollWidth(&aScrollWidth); RETVAL = aScrollWidth; OUTPUT: RETVAL ## GetClientHeight(PRInt32 *aClientHeight) PRInt32 moz_dom_GetClientHeight (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aClientHeight; CODE: nshtmlelement->GetClientHeight(&aClientHeight); RETVAL = aClientHeight; OUTPUT: RETVAL ## GetClientWidth(PRInt32 *aClientWidth) PRInt32 moz_dom_GetClientWidth (nshtmlelement) nsIDOMNSHTMLElement *nshtmlelement; PREINIT: PRInt32 aClientWidth; CODE: nshtmlelement->GetClientWidth(&aClientWidth); RETVAL = aClientWidth; OUTPUT: RETVAL ## ScrollIntoView(PRBool top) void moz_dom_ScrollIntoView (nshtmlelement, top) nsIDOMNSHTMLElement *nshtmlelement; PRBool top; CODE: nshtmlelement->ScrollIntoView(top); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLEmbedElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLEmbedElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLEMBEDELEMENT_IID) static nsIID nsIDOMHTMLEmbedElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLEmbedElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmlembedelement) nsIDOMHTMLEmbedElement *htmlembedelement; PREINIT: nsEmbedString align; CODE: htmlembedelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmlembedelement, align) nsIDOMHTMLEmbedElement *htmlembedelement; nsEmbedString align; CODE: htmlembedelement->SetAlign(align); ## GetHeight(nsAString & aHeight) nsEmbedString moz_dom_GetHeight (htmlembedelement) nsIDOMHTMLEmbedElement *htmlembedelement; PREINIT: nsEmbedString height; CODE: htmlembedelement->GetHeight(height); RETVAL = height; OUTPUT: RETVAL ## SetHeight(const nsAString & aHeight) void moz_dom_SetHeight (htmlembedelement, height) nsIDOMHTMLEmbedElement *htmlembedelement; nsEmbedString height; CODE: htmlembedelement->SetHeight(height); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlembedelement) nsIDOMHTMLEmbedElement *htmlembedelement; PREINIT: nsEmbedString name; CODE: htmlembedelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlembedelement, name) nsIDOMHTMLEmbedElement *htmlembedelement; nsEmbedString name; CODE: htmlembedelement->SetName(name); ## GetSrc(nsAString & aSrc) nsEmbedString moz_dom_GetSrc (htmlembedelement) nsIDOMHTMLEmbedElement *htmlembedelement; PREINIT: nsEmbedString src; CODE: htmlembedelement->GetSrc(src); RETVAL = src; OUTPUT: RETVAL ## SetSrc(const nsAString & aSrc) void moz_dom_SetSrc (htmlembedelement, src) nsIDOMHTMLEmbedElement *htmlembedelement; nsEmbedString src; CODE: htmlembedelement->SetSrc(src); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlembedelement) nsIDOMHTMLEmbedElement *htmlembedelement; PREINIT: nsEmbedString type; CODE: htmlembedelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlembedelement, type) nsIDOMHTMLEmbedElement *htmlembedelement; nsEmbedString type; CODE: htmlembedelement->SetType(type); ## GetWidth(nsAString & aWidth) nsEmbedString moz_dom_GetWidth (htmlembedelement) nsIDOMHTMLEmbedElement *htmlembedelement; PREINIT: nsEmbedString width; CODE: htmlembedelement->GetWidth(width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(const nsAString & aWidth) void moz_dom_SetWidth (htmlembedelement, width) nsIDOMHTMLEmbedElement *htmlembedelement; nsEmbedString width; CODE: htmlembedelement->SetWidth(width); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLFieldSetElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLFieldSetElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLFIELDSETELEMENT_IID) static nsIID nsIDOMHTMLFieldSetElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLFieldSetElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmlfieldsetelement) nsIDOMHTMLFieldSetElement *htmlfieldsetelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmlfieldsetelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLFontElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLFontElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLFONTELEMENT_IID) static nsIID nsIDOMHTMLFontElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLFontElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetColor(nsAString & aColor) nsEmbedString moz_dom_GetColor (htmlfontelement) nsIDOMHTMLFontElement *htmlfontelement; PREINIT: nsEmbedString color; CODE: htmlfontelement->GetColor(color); RETVAL = color; OUTPUT: RETVAL ## SetColor(const nsAString & aColor) void moz_dom_SetColor (htmlfontelement, color) nsIDOMHTMLFontElement *htmlfontelement; nsEmbedString color; CODE: htmlfontelement->SetColor(color); ## GetFace(nsAString & aFace) nsEmbedString moz_dom_GetFace (htmlfontelement) nsIDOMHTMLFontElement *htmlfontelement; PREINIT: nsEmbedString face; CODE: htmlfontelement->GetFace(face); RETVAL = face; OUTPUT: RETVAL ## SetFace(const nsAString & aFace) void moz_dom_SetFace (htmlfontelement, face) nsIDOMHTMLFontElement *htmlfontelement; nsEmbedString face; CODE: htmlfontelement->SetFace(face); ## GetSize(nsAString & aSize) nsEmbedString moz_dom_GetSize (htmlfontelement) nsIDOMHTMLFontElement *htmlfontelement; PREINIT: nsEmbedString size; CODE: htmlfontelement->GetSize(size); RETVAL = size; OUTPUT: RETVAL ## SetSize(const nsAString & aSize) void moz_dom_SetSize (htmlfontelement, size) nsIDOMHTMLFontElement *htmlfontelement; nsEmbedString size; CODE: htmlfontelement->SetSize(size); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLFormElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLFormElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLFORMELEMENT_IID) static nsIID nsIDOMHTMLFormElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLFormElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetElements(nsIDOMHTMLCollection * *aElements) nsIDOMHTMLCollection * moz_dom_GetElements_htmlcollection (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; PREINIT: nsIDOMHTMLCollection * elements; CODE: htmlformelement->GetElements(&elements); RETVAL = elements; OUTPUT: RETVAL ## GetLength(PRInt32 *aLength) PRInt32 moz_dom_GetLength (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; PREINIT: PRInt32 length; CODE: htmlformelement->GetLength(&length); RETVAL = length; OUTPUT: RETVAL ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; PREINIT: nsEmbedString name; CODE: htmlformelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlformelement, name) nsIDOMHTMLFormElement *htmlformelement; nsEmbedString name; CODE: htmlformelement->SetName(name); ## GetAcceptCharset(nsAString & aAcceptCharset) nsEmbedString moz_dom_GetAcceptCharset (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; PREINIT: nsEmbedString acceptcharset; CODE: htmlformelement->GetAcceptCharset(acceptcharset); RETVAL = acceptcharset; OUTPUT: RETVAL ## SetAcceptCharset(const nsAString & aAcceptCharset) void moz_dom_SetAcceptCharset (htmlformelement, acceptcharset) nsIDOMHTMLFormElement *htmlformelement; nsEmbedString acceptcharset; CODE: htmlformelement->SetAcceptCharset(acceptcharset); ## GetAction(nsAString & aAction) nsEmbedString moz_dom_GetAction (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; PREINIT: nsEmbedString action; CODE: htmlformelement->GetAction(action); RETVAL = action; OUTPUT: RETVAL ## SetAction(const nsAString & aAction) void moz_dom_SetAction (htmlformelement, action) nsIDOMHTMLFormElement *htmlformelement; nsEmbedString action; CODE: htmlformelement->SetAction(action); ## GetEnctype(nsAString & aEnctype) nsEmbedString moz_dom_GetEnctype (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; PREINIT: nsEmbedString enctype; CODE: htmlformelement->GetEnctype(enctype); RETVAL = enctype; OUTPUT: RETVAL ## SetEnctype(const nsAString & aEnctype) void moz_dom_SetEnctype (htmlformelement, enctype) nsIDOMHTMLFormElement *htmlformelement; nsEmbedString enctype; CODE: htmlformelement->SetEnctype(enctype); ## GetMethod(nsAString & aMethod) nsEmbedString moz_dom_GetMethod (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; PREINIT: nsEmbedString method; CODE: htmlformelement->GetMethod(method); RETVAL = method; OUTPUT: RETVAL ## SetMethod(const nsAString & aMethod) void moz_dom_SetMethod (htmlformelement, method) nsIDOMHTMLFormElement *htmlformelement; nsEmbedString method; CODE: htmlformelement->SetMethod(method); ## GetTarget(nsAString & aTarget) nsEmbedString moz_dom_GetTarget (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; PREINIT: nsEmbedString target; CODE: htmlformelement->GetTarget(target); RETVAL = target; OUTPUT: RETVAL ## SetTarget(const nsAString & aTarget) void moz_dom_SetTarget (htmlformelement, target) nsIDOMHTMLFormElement *htmlformelement; nsEmbedString target; CODE: htmlformelement->SetTarget(target); ## Submit(void) void moz_dom_Submit (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; CODE: htmlformelement->Submit(); ## Reset(void) void moz_dom_Reset (htmlformelement) nsIDOMHTMLFormElement *htmlformelement; CODE: htmlformelement->Reset(); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLFrameElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLFrameElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLFRAMEELEMENT_IID) static nsIID nsIDOMHTMLFrameElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLFrameElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetFrameBorder(nsAString & aFrameBorder) nsEmbedString moz_dom_GetFrameBorder (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: nsEmbedString frameborder; CODE: htmlframeelement->GetFrameBorder(frameborder); RETVAL = frameborder; OUTPUT: RETVAL ## SetFrameBorder(const nsAString & aFrameBorder) void moz_dom_SetFrameBorder (htmlframeelement, frameborder) nsIDOMHTMLFrameElement *htmlframeelement; nsEmbedString frameborder; CODE: htmlframeelement->SetFrameBorder(frameborder); ## GetLongDesc(nsAString & aLongDesc) nsEmbedString moz_dom_GetLongDesc (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: nsEmbedString longdesc; CODE: htmlframeelement->GetLongDesc(longdesc); RETVAL = longdesc; OUTPUT: RETVAL ## SetLongDesc(const nsAString & aLongDesc) void moz_dom_SetLongDesc (htmlframeelement, longdesc) nsIDOMHTMLFrameElement *htmlframeelement; nsEmbedString longdesc; CODE: htmlframeelement->SetLongDesc(longdesc); ## GetMarginHeight(nsAString & aMarginHeight) nsEmbedString moz_dom_GetMarginHeight (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: nsEmbedString marginheight; CODE: htmlframeelement->GetMarginHeight(marginheight); RETVAL = marginheight; OUTPUT: RETVAL ## SetMarginHeight(const nsAString & aMarginHeight) void moz_dom_SetMarginHeight (htmlframeelement, marginheight) nsIDOMHTMLFrameElement *htmlframeelement; nsEmbedString marginheight; CODE: htmlframeelement->SetMarginHeight(marginheight); ## GetMarginWidth(nsAString & aMarginWidth) nsEmbedString moz_dom_GetMarginWidth (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: nsEmbedString marginwidth; CODE: htmlframeelement->GetMarginWidth(marginwidth); RETVAL = marginwidth; OUTPUT: RETVAL ## SetMarginWidth(const nsAString & aMarginWidth) void moz_dom_SetMarginWidth (htmlframeelement, marginwidth) nsIDOMHTMLFrameElement *htmlframeelement; nsEmbedString marginwidth; CODE: htmlframeelement->SetMarginWidth(marginwidth); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: nsEmbedString name; CODE: htmlframeelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlframeelement, name) nsIDOMHTMLFrameElement *htmlframeelement; nsEmbedString name; CODE: htmlframeelement->SetName(name); ## GetNoResize(PRBool *aNoResize) PRBool moz_dom_GetNoResize (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: PRBool noresize; CODE: htmlframeelement->GetNoResize(&noresize); RETVAL = noresize; OUTPUT: RETVAL ## SetNoResize(PRBool aNoResize) void moz_dom_SetNoResize (htmlframeelement, noresize) nsIDOMHTMLFrameElement *htmlframeelement; PRBool noresize; CODE: htmlframeelement->SetNoResize(noresize); ## GetScrolling(nsAString & aScrolling) nsEmbedString moz_dom_GetScrolling (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: nsEmbedString scrolling; CODE: htmlframeelement->GetScrolling(scrolling); RETVAL = scrolling; OUTPUT: RETVAL ## SetScrolling(const nsAString & aScrolling) void moz_dom_SetScrolling (htmlframeelement, scrolling) nsIDOMHTMLFrameElement *htmlframeelement; nsEmbedString scrolling; CODE: htmlframeelement->SetScrolling(scrolling); ## GetSrc(nsAString & aSrc) nsEmbedString moz_dom_GetSrc (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: nsEmbedString src; CODE: htmlframeelement->GetSrc(src); RETVAL = src; OUTPUT: RETVAL ## SetSrc(const nsAString & aSrc) void moz_dom_SetSrc (htmlframeelement, src) nsIDOMHTMLFrameElement *htmlframeelement; nsEmbedString src; CODE: htmlframeelement->SetSrc(src); ## GetContentDocument(nsIDOMDocument * *aContentDocument) nsIDOMDocument * moz_dom_GetContentDocument (htmlframeelement) nsIDOMHTMLFrameElement *htmlframeelement; PREINIT: nsIDOMDocument * contentdocument; CODE: htmlframeelement->GetContentDocument(&contentdocument); RETVAL = contentdocument; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLFrameSetElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLFrameSetElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLFRAMESETELEMENT_IID) static nsIID nsIDOMHTMLFrameSetElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLFrameSetElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCols(nsAString & aCols) nsEmbedString moz_dom_GetCols (htmlframesetelement) nsIDOMHTMLFrameSetElement *htmlframesetelement; PREINIT: nsEmbedString cols; CODE: htmlframesetelement->GetCols(cols); RETVAL = cols; OUTPUT: RETVAL ## SetCols(const nsAString & aCols) void moz_dom_SetCols (htmlframesetelement, cols) nsIDOMHTMLFrameSetElement *htmlframesetelement; nsEmbedString cols; CODE: htmlframesetelement->SetCols(cols); ## GetRows(nsAString & aRows) nsEmbedString moz_dom_GetRows (htmlframesetelement) nsIDOMHTMLFrameSetElement *htmlframesetelement; PREINIT: nsEmbedString rows; CODE: htmlframesetelement->GetRows(rows); RETVAL = rows; OUTPUT: RETVAL ## SetRows(const nsAString & aRows) void moz_dom_SetRows (htmlframesetelement, rows) nsIDOMHTMLFrameSetElement *htmlframesetelement; nsEmbedString rows; CODE: htmlframesetelement->SetRows(rows); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLHRElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLHRElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLHRELEMENT_IID) static nsIID nsIDOMHTMLHRElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLHRElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmlhrelement) nsIDOMHTMLHRElement *htmlhrelement; PREINIT: nsEmbedString align; CODE: htmlhrelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmlhrelement, align) nsIDOMHTMLHRElement *htmlhrelement; nsEmbedString align; CODE: htmlhrelement->SetAlign(align); ## GetNoShade(PRBool *aNoShade) PRBool moz_dom_GetNoShade (htmlhrelement) nsIDOMHTMLHRElement *htmlhrelement; PREINIT: PRBool noshade; CODE: htmlhrelement->GetNoShade(&noshade); RETVAL = noshade; OUTPUT: RETVAL ## SetNoShade(PRBool aNoShade) void moz_dom_SetNoShade (htmlhrelement, noshade) nsIDOMHTMLHRElement *htmlhrelement; PRBool noshade; CODE: htmlhrelement->SetNoShade(noshade); ## GetSize(nsAString & aSize) nsEmbedString moz_dom_GetSize (htmlhrelement) nsIDOMHTMLHRElement *htmlhrelement; PREINIT: nsEmbedString size; CODE: htmlhrelement->GetSize(size); RETVAL = size; OUTPUT: RETVAL ## SetSize(const nsAString & aSize) void moz_dom_SetSize (htmlhrelement, size) nsIDOMHTMLHRElement *htmlhrelement; nsEmbedString size; CODE: htmlhrelement->SetSize(size); ## GetWidth(nsAString & aWidth) nsEmbedString moz_dom_GetWidth (htmlhrelement) nsIDOMHTMLHRElement *htmlhrelement; PREINIT: nsEmbedString width; CODE: htmlhrelement->GetWidth(width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(const nsAString & aWidth) void moz_dom_SetWidth (htmlhrelement, width) nsIDOMHTMLHRElement *htmlhrelement; nsEmbedString width; CODE: htmlhrelement->SetWidth(width); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLHeadElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLHeadElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLHEADELEMENT_IID) static nsIID nsIDOMHTMLHeadElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLHeadElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetProfile(nsAString & aProfile) nsEmbedString moz_dom_GetProfile (htmlheadelement) nsIDOMHTMLHeadElement *htmlheadelement; PREINIT: nsEmbedString profile; CODE: htmlheadelement->GetProfile(profile); RETVAL = profile; OUTPUT: RETVAL ## SetProfile(const nsAString & aProfile) void moz_dom_SetProfile (htmlheadelement, profile) nsIDOMHTMLHeadElement *htmlheadelement; nsEmbedString profile; CODE: htmlheadelement->SetProfile(profile); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLHeadingElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLHeadingElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLHEADINGELEMENT_IID) static nsIID nsIDOMHTMLHeadingElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLHeadingElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmlheadingelement) nsIDOMHTMLHeadingElement *htmlheadingelement; PREINIT: nsEmbedString align; CODE: htmlheadingelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmlheadingelement, align) nsIDOMHTMLHeadingElement *htmlheadingelement; nsEmbedString align; CODE: htmlheadingelement->SetAlign(align); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLHtmlElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLHtmlElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLHTMLELEMENT_IID) static nsIID nsIDOMHTMLHtmlElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLHtmlElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetVersion(nsAString & aVersion) nsEmbedString moz_dom_GetVersion (htmlhtmlelement) nsIDOMHTMLHtmlElement *htmlhtmlelement; PREINIT: nsEmbedString version; CODE: htmlhtmlelement->GetVersion(version); RETVAL = version; OUTPUT: RETVAL ## SetVersion(const nsAString & aVersion) void moz_dom_SetVersion (htmlhtmlelement, version) nsIDOMHTMLHtmlElement *htmlhtmlelement; nsEmbedString version; CODE: htmlhtmlelement->SetVersion(version); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLIFrameElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLIFrameElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLIFRAMEELEMENT_IID) static nsIID nsIDOMHTMLIFrameElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLIFrameElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString align; CODE: htmliframeelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmliframeelement, align) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString align; CODE: htmliframeelement->SetAlign(align); ## GetFrameBorder(nsAString & aFrameBorder) nsEmbedString moz_dom_GetFrameBorder (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString frameborder; CODE: htmliframeelement->GetFrameBorder(frameborder); RETVAL = frameborder; OUTPUT: RETVAL ## SetFrameBorder(const nsAString & aFrameBorder) void moz_dom_SetFrameBorder (htmliframeelement, frameborder) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString frameborder; CODE: htmliframeelement->SetFrameBorder(frameborder); ## GetHeight(nsAString & aHeight) nsEmbedString moz_dom_GetHeight (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString height; CODE: htmliframeelement->GetHeight(height); RETVAL = height; OUTPUT: RETVAL ## SetHeight(const nsAString & aHeight) void moz_dom_SetHeight (htmliframeelement, height) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString height; CODE: htmliframeelement->SetHeight(height); ## GetLongDesc(nsAString & aLongDesc) nsEmbedString moz_dom_GetLongDesc (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString longdesc; CODE: htmliframeelement->GetLongDesc(longdesc); RETVAL = longdesc; OUTPUT: RETVAL ## SetLongDesc(const nsAString & aLongDesc) void moz_dom_SetLongDesc (htmliframeelement, longdesc) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString longdesc; CODE: htmliframeelement->SetLongDesc(longdesc); ## GetMarginHeight(nsAString & aMarginHeight) nsEmbedString moz_dom_GetMarginHeight (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString marginheight; CODE: htmliframeelement->GetMarginHeight(marginheight); RETVAL = marginheight; OUTPUT: RETVAL ## SetMarginHeight(const nsAString & aMarginHeight) void moz_dom_SetMarginHeight (htmliframeelement, marginheight) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString marginheight; CODE: htmliframeelement->SetMarginHeight(marginheight); ## GetMarginWidth(nsAString & aMarginWidth) nsEmbedString moz_dom_GetMarginWidth (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString marginwidth; CODE: htmliframeelement->GetMarginWidth(marginwidth); RETVAL = marginwidth; OUTPUT: RETVAL ## SetMarginWidth(const nsAString & aMarginWidth) void moz_dom_SetMarginWidth (htmliframeelement, marginwidth) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString marginwidth; CODE: htmliframeelement->SetMarginWidth(marginwidth); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString name; CODE: htmliframeelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmliframeelement, name) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString name; CODE: htmliframeelement->SetName(name); ## GetScrolling(nsAString & aScrolling) nsEmbedString moz_dom_GetScrolling (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString scrolling; CODE: htmliframeelement->GetScrolling(scrolling); RETVAL = scrolling; OUTPUT: RETVAL ## SetScrolling(const nsAString & aScrolling) void moz_dom_SetScrolling (htmliframeelement, scrolling) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString scrolling; CODE: htmliframeelement->SetScrolling(scrolling); ## GetSrc(nsAString & aSrc) nsEmbedString moz_dom_GetSrc (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString src; CODE: htmliframeelement->GetSrc(src); RETVAL = src; OUTPUT: RETVAL ## SetSrc(const nsAString & aSrc) void moz_dom_SetSrc (htmliframeelement, src) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString src; CODE: htmliframeelement->SetSrc(src); ## GetWidth(nsAString & aWidth) nsEmbedString moz_dom_GetWidth (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsEmbedString width; CODE: htmliframeelement->GetWidth(width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(const nsAString & aWidth) void moz_dom_SetWidth (htmliframeelement, width) nsIDOMHTMLIFrameElement *htmliframeelement; nsEmbedString width; CODE: htmliframeelement->SetWidth(width); ## GetContentDocument(nsIDOMDocument * *aContentDocument) nsIDOMDocument * moz_dom_GetContentDocument (htmliframeelement) nsIDOMHTMLIFrameElement *htmliframeelement; PREINIT: nsIDOMDocument * contentdocument; CODE: htmliframeelement->GetContentDocument(&contentdocument); RETVAL = contentdocument; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLImageElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLImageElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLIMAGEELEMENT_IID) static nsIID nsIDOMHTMLImageElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLImageElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: nsEmbedString name; CODE: htmlimageelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlimageelement, name) nsIDOMHTMLImageElement *htmlimageelement; nsEmbedString name; CODE: htmlimageelement->SetName(name); ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: nsEmbedString align; CODE: htmlimageelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmlimageelement, align) nsIDOMHTMLImageElement *htmlimageelement; nsEmbedString align; CODE: htmlimageelement->SetAlign(align); ## GetAlt(nsAString & aAlt) nsEmbedString moz_dom_GetAlt (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: nsEmbedString alt; CODE: htmlimageelement->GetAlt(alt); RETVAL = alt; OUTPUT: RETVAL ## SetAlt(const nsAString & aAlt) void moz_dom_SetAlt (htmlimageelement, alt) nsIDOMHTMLImageElement *htmlimageelement; nsEmbedString alt; CODE: htmlimageelement->SetAlt(alt); ## GetBorder(nsAString & aBorder) nsEmbedString moz_dom_GetBorder (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: nsEmbedString border; CODE: htmlimageelement->GetBorder(border); RETVAL = border; OUTPUT: RETVAL ## SetBorder(const nsAString & aBorder) void moz_dom_SetBorder (htmlimageelement, border) nsIDOMHTMLImageElement *htmlimageelement; nsEmbedString border; CODE: htmlimageelement->SetBorder(border); ## GetHeight(PRInt32 *aHeight) PRInt32 moz_dom_GetHeight (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: PRInt32 height; CODE: htmlimageelement->GetHeight(&height); RETVAL = height; OUTPUT: RETVAL ## SetHeight(PRInt32 aHeight) void moz_dom_SetHeight (htmlimageelement, height) nsIDOMHTMLImageElement *htmlimageelement; PRInt32 height; CODE: htmlimageelement->SetHeight(height); ## GetHspace(PRInt32 *aHspace) PRInt32 moz_dom_GetHspace (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: PRInt32 hspace; CODE: htmlimageelement->GetHspace(&hspace); RETVAL = hspace; OUTPUT: RETVAL ## SetHspace(PRInt32 aHspace) void moz_dom_SetHspace (htmlimageelement, hspace) nsIDOMHTMLImageElement *htmlimageelement; PRInt32 hspace; CODE: htmlimageelement->SetHspace(hspace); ## GetIsMap(PRBool *aIsMap) PRBool moz_dom_GetIsMap (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: PRBool ismap; CODE: htmlimageelement->GetIsMap(&ismap); RETVAL = ismap; OUTPUT: RETVAL ## SetIsMap(PRBool aIsMap) void moz_dom_SetIsMap (htmlimageelement, ismap) nsIDOMHTMLImageElement *htmlimageelement; PRBool ismap; CODE: htmlimageelement->SetIsMap(ismap); ## GetLongDesc(nsAString & aLongDesc) nsEmbedString moz_dom_GetLongDesc (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: nsEmbedString longdesc; CODE: htmlimageelement->GetLongDesc(longdesc); RETVAL = longdesc; OUTPUT: RETVAL ## SetLongDesc(const nsAString & aLongDesc) void moz_dom_SetLongDesc (htmlimageelement, longdesc) nsIDOMHTMLImageElement *htmlimageelement; nsEmbedString longdesc; CODE: htmlimageelement->SetLongDesc(longdesc); ## GetSrc(nsAString & aSrc) nsEmbedString moz_dom_GetSrc (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: nsEmbedString src; CODE: htmlimageelement->GetSrc(src); RETVAL = src; OUTPUT: RETVAL ## SetSrc(const nsAString & aSrc) void moz_dom_SetSrc (htmlimageelement, src) nsIDOMHTMLImageElement *htmlimageelement; nsEmbedString src; CODE: htmlimageelement->SetSrc(src); ## GetUseMap(nsAString & aUseMap) nsEmbedString moz_dom_GetUseMap (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: nsEmbedString usemap; CODE: htmlimageelement->GetUseMap(usemap); RETVAL = usemap; OUTPUT: RETVAL ## SetUseMap(const nsAString & aUseMap) void moz_dom_SetUseMap (htmlimageelement, usemap) nsIDOMHTMLImageElement *htmlimageelement; nsEmbedString usemap; CODE: htmlimageelement->SetUseMap(usemap); ## GetVspace(PRInt32 *aVspace) PRInt32 moz_dom_GetVspace (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: PRInt32 vspace; CODE: htmlimageelement->GetVspace(&vspace); RETVAL = vspace; OUTPUT: RETVAL ## SetVspace(PRInt32 aVspace) void moz_dom_SetVspace (htmlimageelement, vspace) nsIDOMHTMLImageElement *htmlimageelement; PRInt32 vspace; CODE: htmlimageelement->SetVspace(vspace); ## GetWidth(PRInt32 *aWidth) PRInt32 moz_dom_GetWidth (htmlimageelement) nsIDOMHTMLImageElement *htmlimageelement; PREINIT: PRInt32 width; CODE: htmlimageelement->GetWidth(&width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(PRInt32 aWidth) void moz_dom_SetWidth (htmlimageelement, width) nsIDOMHTMLImageElement *htmlimageelement; PRInt32 width; CODE: htmlimageelement->SetWidth(width); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLInputElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLInputElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLINPUTELEMENT_IID) static nsIID nsIDOMHTMLInputElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLInputElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDefaultValue(nsAString & aDefaultValue) nsEmbedString moz_dom_GetDefaultValue (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString defaultvalue; CODE: htmlinputelement->GetDefaultValue(defaultvalue); RETVAL = defaultvalue; OUTPUT: RETVAL ## SetDefaultValue(const nsAString & aDefaultValue) void moz_dom_SetDefaultValue (htmlinputelement, defaultvalue) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString defaultvalue; CODE: htmlinputelement->SetDefaultValue(defaultvalue); ## GetDefaultChecked(PRBool *aDefaultChecked) PRBool moz_dom_GetDefaultChecked (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: PRBool defaultchecked; CODE: htmlinputelement->GetDefaultChecked(&defaultchecked); RETVAL = defaultchecked; OUTPUT: RETVAL ## SetDefaultChecked(PRBool aDefaultChecked) void moz_dom_SetDefaultChecked (htmlinputelement, defaultchecked) nsIDOMHTMLInputElement *htmlinputelement; PRBool defaultchecked; CODE: htmlinputelement->SetDefaultChecked(defaultchecked); ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmlinputelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetAccept(nsAString & aAccept) nsEmbedString moz_dom_GetAccept (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString accept; CODE: htmlinputelement->GetAccept(accept); RETVAL = accept; OUTPUT: RETVAL ## SetAccept(const nsAString & aAccept) void moz_dom_SetAccept (htmlinputelement, accept) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString accept; CODE: htmlinputelement->SetAccept(accept); ## GetAccessKey(nsAString & aAccessKey) nsEmbedString moz_dom_GetAccessKey (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString accesskey; CODE: htmlinputelement->GetAccessKey(accesskey); RETVAL = accesskey; OUTPUT: RETVAL ## SetAccessKey(const nsAString & aAccessKey) void moz_dom_SetAccessKey (htmlinputelement, accesskey) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString accesskey; CODE: htmlinputelement->SetAccessKey(accesskey); ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString align; CODE: htmlinputelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmlinputelement, align) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString align; CODE: htmlinputelement->SetAlign(align); ## GetAlt(nsAString & aAlt) nsEmbedString moz_dom_GetAlt (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString alt; CODE: htmlinputelement->GetAlt(alt); RETVAL = alt; OUTPUT: RETVAL ## SetAlt(const nsAString & aAlt) void moz_dom_SetAlt (htmlinputelement, alt) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString alt; CODE: htmlinputelement->SetAlt(alt); ## GetChecked(PRBool *aChecked) PRBool moz_dom_GetChecked (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: PRBool checked; CODE: htmlinputelement->GetChecked(&checked); RETVAL = checked; OUTPUT: RETVAL ## SetChecked(PRBool aChecked) void moz_dom_SetChecked (htmlinputelement, checked) nsIDOMHTMLInputElement *htmlinputelement; PRBool checked; CODE: htmlinputelement->SetChecked(checked); ## GetDisabled(PRBool *aDisabled) PRBool moz_dom_GetDisabled (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: PRBool disabled; CODE: htmlinputelement->GetDisabled(&disabled); RETVAL = disabled; OUTPUT: RETVAL ## SetDisabled(PRBool aDisabled) void moz_dom_SetDisabled (htmlinputelement, disabled) nsIDOMHTMLInputElement *htmlinputelement; PRBool disabled; CODE: htmlinputelement->SetDisabled(disabled); ## GetMaxLength(PRInt32 *aMaxLength) PRInt32 moz_dom_GetMaxLength (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: PRInt32 maxlength; CODE: htmlinputelement->GetMaxLength(&maxlength); RETVAL = maxlength; OUTPUT: RETVAL ## SetMaxLength(PRInt32 aMaxLength) void moz_dom_SetMaxLength (htmlinputelement, maxlength) nsIDOMHTMLInputElement *htmlinputelement; PRInt32 maxlength; CODE: htmlinputelement->SetMaxLength(maxlength); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString name; CODE: htmlinputelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlinputelement, name) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString name; CODE: htmlinputelement->SetName(name); ## GetReadOnly(PRBool *aReadOnly) PRBool moz_dom_GetReadOnly (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: PRBool readonly; CODE: htmlinputelement->GetReadOnly(&readonly); RETVAL = readonly; OUTPUT: RETVAL ## SetReadOnly(PRBool aReadOnly) void moz_dom_SetReadOnly (htmlinputelement, readonly) nsIDOMHTMLInputElement *htmlinputelement; PRBool readonly; CODE: htmlinputelement->SetReadOnly(readonly); ## GetSize(PRUint32 *aSize) PRUint32 moz_dom_GetSize (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: PRUint32 size; CODE: htmlinputelement->GetSize(&size); RETVAL = size; OUTPUT: RETVAL ## SetSize(PRUint32 aSize) void moz_dom_SetSize (htmlinputelement, size) nsIDOMHTMLInputElement *htmlinputelement; PRUint32 size; CODE: htmlinputelement->SetSize(size); ## GetSrc(nsAString & aSrc) nsEmbedString moz_dom_GetSrc (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString src; CODE: htmlinputelement->GetSrc(src); RETVAL = src; OUTPUT: RETVAL ## SetSrc(const nsAString & aSrc) void moz_dom_SetSrc (htmlinputelement, src) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString src; CODE: htmlinputelement->SetSrc(src); ## GetTabIndex(PRInt32 *aTabIndex) PRInt32 moz_dom_GetTabIndex (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: PRInt32 tabindex; CODE: htmlinputelement->GetTabIndex(&tabindex); RETVAL = tabindex; OUTPUT: RETVAL ## SetTabIndex(PRInt32 aTabIndex) void moz_dom_SetTabIndex (htmlinputelement, tabindex) nsIDOMHTMLInputElement *htmlinputelement; PRInt32 tabindex; CODE: htmlinputelement->SetTabIndex(tabindex); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString type; CODE: htmlinputelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlinputelement, type) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString type; CODE: htmlinputelement->SetType(type); ## GetUseMap(nsAString & aUseMap) nsEmbedString moz_dom_GetUseMap (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString usemap; CODE: htmlinputelement->GetUseMap(usemap); RETVAL = usemap; OUTPUT: RETVAL ## SetUseMap(const nsAString & aUseMap) void moz_dom_SetUseMap (htmlinputelement, usemap) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString usemap; CODE: htmlinputelement->SetUseMap(usemap); ## GetValue(nsAString & aValue) nsEmbedString moz_dom_GetValue (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; PREINIT: nsEmbedString value; CODE: htmlinputelement->GetValue(value); RETVAL = value; OUTPUT: RETVAL ## SetValue(const nsAString & aValue) void moz_dom_SetValue (htmlinputelement, value) nsIDOMHTMLInputElement *htmlinputelement; nsEmbedString value; CODE: htmlinputelement->SetValue(value); ## Blur(void) void moz_dom_Blur (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; CODE: htmlinputelement->Blur(); ## Focus(void) void moz_dom_Focus (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; CODE: htmlinputelement->Focus(); ## Select(void) void moz_dom_Select (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; CODE: htmlinputelement->Select(); ## Click(void) void moz_dom_Click (htmlinputelement) nsIDOMHTMLInputElement *htmlinputelement; CODE: htmlinputelement->Click(); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLIsIndexElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLIsIndexElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLISINDEXELEMENT_IID) static nsIID nsIDOMHTMLIsIndexElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLIsIndexElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmlisindexelement) nsIDOMHTMLIsIndexElement *htmlisindexelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmlisindexelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetPrompt(nsAString & aPrompt) nsEmbedString moz_dom_GetPrompt (htmlisindexelement) nsIDOMHTMLIsIndexElement *htmlisindexelement; PREINIT: nsEmbedString prompt; CODE: htmlisindexelement->GetPrompt(prompt); RETVAL = prompt; OUTPUT: RETVAL ## SetPrompt(const nsAString & aPrompt) void moz_dom_SetPrompt (htmlisindexelement, prompt) nsIDOMHTMLIsIndexElement *htmlisindexelement; nsEmbedString prompt; CODE: htmlisindexelement->SetPrompt(prompt); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLLIElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLLIElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLLIELEMENT_IID) static nsIID nsIDOMHTMLLIElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLLIElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmllielement) nsIDOMHTMLLIElement *htmllielement; PREINIT: nsEmbedString type; CODE: htmllielement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmllielement, type) nsIDOMHTMLLIElement *htmllielement; nsEmbedString type; CODE: htmllielement->SetType(type); ## GetValue(PRInt32 *aValue) PRInt32 moz_dom_GetValue (htmllielement) nsIDOMHTMLLIElement *htmllielement; PREINIT: PRInt32 value; CODE: htmllielement->GetValue(&value); RETVAL = value; OUTPUT: RETVAL ## SetValue(PRInt32 aValue) void moz_dom_SetValue (htmllielement, value) nsIDOMHTMLLIElement *htmllielement; PRInt32 value; CODE: htmllielement->SetValue(value); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLLabelElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLLabelElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLLABELELEMENT_IID) static nsIID nsIDOMHTMLLabelElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLLabelElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmllabelelement) nsIDOMHTMLLabelElement *htmllabelelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmllabelelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetAccessKey(nsAString & aAccessKey) nsEmbedString moz_dom_GetAccessKey (htmllabelelement) nsIDOMHTMLLabelElement *htmllabelelement; PREINIT: nsEmbedString accesskey; CODE: htmllabelelement->GetAccessKey(accesskey); RETVAL = accesskey; OUTPUT: RETVAL ## SetAccessKey(const nsAString & aAccessKey) void moz_dom_SetAccessKey (htmllabelelement, accesskey) nsIDOMHTMLLabelElement *htmllabelelement; nsEmbedString accesskey; CODE: htmllabelelement->SetAccessKey(accesskey); ## GetHtmlFor(nsAString & aHtmlFor) nsEmbedString moz_dom_GetHtmlFor (htmllabelelement) nsIDOMHTMLLabelElement *htmllabelelement; PREINIT: nsEmbedString htmlfor; CODE: htmllabelelement->GetHtmlFor(htmlfor); RETVAL = htmlfor; OUTPUT: RETVAL ## SetHtmlFor(const nsAString & aHtmlFor) void moz_dom_SetHtmlFor (htmllabelelement, htmlfor) nsIDOMHTMLLabelElement *htmllabelelement; nsEmbedString htmlfor; CODE: htmllabelelement->SetHtmlFor(htmlfor); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLLegendElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLLegendElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLLEGENDELEMENT_IID) static nsIID nsIDOMHTMLLegendElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLLegendElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmllegendelement) nsIDOMHTMLLegendElement *htmllegendelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmllegendelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetAccessKey(nsAString & aAccessKey) nsEmbedString moz_dom_GetAccessKey (htmllegendelement) nsIDOMHTMLLegendElement *htmllegendelement; PREINIT: nsEmbedString accesskey; CODE: htmllegendelement->GetAccessKey(accesskey); RETVAL = accesskey; OUTPUT: RETVAL ## SetAccessKey(const nsAString & aAccessKey) void moz_dom_SetAccessKey (htmllegendelement, accesskey) nsIDOMHTMLLegendElement *htmllegendelement; nsEmbedString accesskey; CODE: htmllegendelement->SetAccessKey(accesskey); ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmllegendelement) nsIDOMHTMLLegendElement *htmllegendelement; PREINIT: nsEmbedString align; CODE: htmllegendelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmllegendelement, align) nsIDOMHTMLLegendElement *htmllegendelement; nsEmbedString align; CODE: htmllegendelement->SetAlign(align); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLLinkElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLLinkElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLLINKELEMENT_IID) static nsIID nsIDOMHTMLLinkElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLLinkElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDisabled(PRBool *aDisabled) PRBool moz_dom_GetDisabled (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: PRBool disabled; CODE: htmllinkelement->GetDisabled(&disabled); RETVAL = disabled; OUTPUT: RETVAL ## SetDisabled(PRBool aDisabled) void moz_dom_SetDisabled (htmllinkelement, disabled) nsIDOMHTMLLinkElement *htmllinkelement; PRBool disabled; CODE: htmllinkelement->SetDisabled(disabled); ## GetCharset(nsAString & aCharset) nsEmbedString moz_dom_GetCharset (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: nsEmbedString charset; CODE: htmllinkelement->GetCharset(charset); RETVAL = charset; OUTPUT: RETVAL ## SetCharset(const nsAString & aCharset) void moz_dom_SetCharset (htmllinkelement, charset) nsIDOMHTMLLinkElement *htmllinkelement; nsEmbedString charset; CODE: htmllinkelement->SetCharset(charset); ## GetHref(nsAString & aHref) nsEmbedString moz_dom_GetHref (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: nsEmbedString href; CODE: htmllinkelement->GetHref(href); RETVAL = href; OUTPUT: RETVAL ## SetHref(const nsAString & aHref) void moz_dom_SetHref (htmllinkelement, href) nsIDOMHTMLLinkElement *htmllinkelement; nsEmbedString href; CODE: htmllinkelement->SetHref(href); ## GetHreflang(nsAString & aHreflang) nsEmbedString moz_dom_GetHreflang (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: nsEmbedString hreflang; CODE: htmllinkelement->GetHreflang(hreflang); RETVAL = hreflang; OUTPUT: RETVAL ## SetHreflang(const nsAString & aHreflang) void moz_dom_SetHreflang (htmllinkelement, hreflang) nsIDOMHTMLLinkElement *htmllinkelement; nsEmbedString hreflang; CODE: htmllinkelement->SetHreflang(hreflang); ## GetMedia(nsAString & aMedia) nsEmbedString moz_dom_GetMedia (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: nsEmbedString media; CODE: htmllinkelement->GetMedia(media); RETVAL = media; OUTPUT: RETVAL ## SetMedia(const nsAString & aMedia) void moz_dom_SetMedia (htmllinkelement, media) nsIDOMHTMLLinkElement *htmllinkelement; nsEmbedString media; CODE: htmllinkelement->SetMedia(media); ## GetRel(nsAString & aRel) nsEmbedString moz_dom_GetRel (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: nsEmbedString rel; CODE: htmllinkelement->GetRel(rel); RETVAL = rel; OUTPUT: RETVAL ## SetRel(const nsAString & aRel) void moz_dom_SetRel (htmllinkelement, rel) nsIDOMHTMLLinkElement *htmllinkelement; nsEmbedString rel; CODE: htmllinkelement->SetRel(rel); ## GetRev(nsAString & aRev) nsEmbedString moz_dom_GetRev (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: nsEmbedString rev; CODE: htmllinkelement->GetRev(rev); RETVAL = rev; OUTPUT: RETVAL ## SetRev(const nsAString & aRev) void moz_dom_SetRev (htmllinkelement, rev) nsIDOMHTMLLinkElement *htmllinkelement; nsEmbedString rev; CODE: htmllinkelement->SetRev(rev); ## GetTarget(nsAString & aTarget) nsEmbedString moz_dom_GetTarget (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: nsEmbedString target; CODE: htmllinkelement->GetTarget(target); RETVAL = target; OUTPUT: RETVAL ## SetTarget(const nsAString & aTarget) void moz_dom_SetTarget (htmllinkelement, target) nsIDOMHTMLLinkElement *htmllinkelement; nsEmbedString target; CODE: htmllinkelement->SetTarget(target); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmllinkelement) nsIDOMHTMLLinkElement *htmllinkelement; PREINIT: nsEmbedString type; CODE: htmllinkelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmllinkelement, type) nsIDOMHTMLLinkElement *htmllinkelement; nsEmbedString type; CODE: htmllinkelement->SetType(type); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLMapElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLMapElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLMAPELEMENT_IID) static nsIID nsIDOMHTMLMapElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLMapElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAreas(nsIDOMHTMLCollection * *aAreas) nsIDOMHTMLCollection * moz_dom_GetAreas_htmlcollection (htmlmapelement) nsIDOMHTMLMapElement *htmlmapelement; PREINIT: nsIDOMHTMLCollection * areas; CODE: htmlmapelement->GetAreas(&areas); RETVAL = areas; OUTPUT: RETVAL ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlmapelement) nsIDOMHTMLMapElement *htmlmapelement; PREINIT: nsEmbedString name; CODE: htmlmapelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlmapelement, name) nsIDOMHTMLMapElement *htmlmapelement; nsEmbedString name; CODE: htmlmapelement->SetName(name); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLMenuElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLMenuElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLMENUELEMENT_IID) static nsIID nsIDOMHTMLMenuElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLMenuElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCompact(PRBool *aCompact) PRBool moz_dom_GetCompact (htmlmenuelement) nsIDOMHTMLMenuElement *htmlmenuelement; PREINIT: PRBool compact; CODE: htmlmenuelement->GetCompact(&compact); RETVAL = compact; OUTPUT: RETVAL ## SetCompact(PRBool aCompact) void moz_dom_SetCompact (htmlmenuelement, compact) nsIDOMHTMLMenuElement *htmlmenuelement; PRBool compact; CODE: htmlmenuelement->SetCompact(compact); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLMetaElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLMetaElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLMETAELEMENT_IID) static nsIID nsIDOMHTMLMetaElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLMetaElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetContent(nsAString & aContent) nsEmbedString moz_dom_GetContent (htmlmetaelement) nsIDOMHTMLMetaElement *htmlmetaelement; PREINIT: nsEmbedString content; CODE: htmlmetaelement->GetContent(content); RETVAL = content; OUTPUT: RETVAL ## SetContent(const nsAString & aContent) void moz_dom_SetContent (htmlmetaelement, content) nsIDOMHTMLMetaElement *htmlmetaelement; nsEmbedString content; CODE: htmlmetaelement->SetContent(content); ## GetHttpEquiv(nsAString & aHttpEquiv) nsEmbedString moz_dom_GetHttpEquiv (htmlmetaelement) nsIDOMHTMLMetaElement *htmlmetaelement; PREINIT: nsEmbedString httpequiv; CODE: htmlmetaelement->GetHttpEquiv(httpequiv); RETVAL = httpequiv; OUTPUT: RETVAL ## SetHttpEquiv(const nsAString & aHttpEquiv) void moz_dom_SetHttpEquiv (htmlmetaelement, httpequiv) nsIDOMHTMLMetaElement *htmlmetaelement; nsEmbedString httpequiv; CODE: htmlmetaelement->SetHttpEquiv(httpequiv); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlmetaelement) nsIDOMHTMLMetaElement *htmlmetaelement; PREINIT: nsEmbedString name; CODE: htmlmetaelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlmetaelement, name) nsIDOMHTMLMetaElement *htmlmetaelement; nsEmbedString name; CODE: htmlmetaelement->SetName(name); ## GetScheme(nsAString & aScheme) nsEmbedString moz_dom_GetScheme (htmlmetaelement) nsIDOMHTMLMetaElement *htmlmetaelement; PREINIT: nsEmbedString scheme; CODE: htmlmetaelement->GetScheme(scheme); RETVAL = scheme; OUTPUT: RETVAL ## SetScheme(const nsAString & aScheme) void moz_dom_SetScheme (htmlmetaelement, scheme) nsIDOMHTMLMetaElement *htmlmetaelement; nsEmbedString scheme; CODE: htmlmetaelement->SetScheme(scheme); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLModElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLModElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLMODELEMENT_IID) static nsIID nsIDOMHTMLModElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLModElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCite(nsAString & aCite) nsEmbedString moz_dom_GetCite (htmlmodelement) nsIDOMHTMLModElement *htmlmodelement; PREINIT: nsEmbedString cite; CODE: htmlmodelement->GetCite(cite); RETVAL = cite; OUTPUT: RETVAL ## SetCite(const nsAString & aCite) void moz_dom_SetCite (htmlmodelement, cite) nsIDOMHTMLModElement *htmlmodelement; nsEmbedString cite; CODE: htmlmodelement->SetCite(cite); ## GetDateTime(nsAString & aDateTime) nsEmbedString moz_dom_GetDateTime (htmlmodelement) nsIDOMHTMLModElement *htmlmodelement; PREINIT: nsEmbedString datetime; CODE: htmlmodelement->GetDateTime(datetime); RETVAL = datetime; OUTPUT: RETVAL ## SetDateTime(const nsAString & aDateTime) void moz_dom_SetDateTime (htmlmodelement, datetime) nsIDOMHTMLModElement *htmlmodelement; nsEmbedString datetime; CODE: htmlmodelement->SetDateTime(datetime); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLOListElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLOListElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLOLISTELEMENT_IID) static nsIID nsIDOMHTMLOListElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLOListElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCompact(PRBool *aCompact) PRBool moz_dom_GetCompact (htmlolistelement) nsIDOMHTMLOListElement *htmlolistelement; PREINIT: PRBool compact; CODE: htmlolistelement->GetCompact(&compact); RETVAL = compact; OUTPUT: RETVAL ## SetCompact(PRBool aCompact) void moz_dom_SetCompact (htmlolistelement, compact) nsIDOMHTMLOListElement *htmlolistelement; PRBool compact; CODE: htmlolistelement->SetCompact(compact); ## GetStart(PRInt32 *aStart) PRInt32 moz_dom_GetStart (htmlolistelement) nsIDOMHTMLOListElement *htmlolistelement; PREINIT: PRInt32 start; CODE: htmlolistelement->GetStart(&start); RETVAL = start; OUTPUT: RETVAL ## SetStart(PRInt32 aStart) void moz_dom_SetStart (htmlolistelement, start) nsIDOMHTMLOListElement *htmlolistelement; PRInt32 start; CODE: htmlolistelement->SetStart(start); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlolistelement) nsIDOMHTMLOListElement *htmlolistelement; PREINIT: nsEmbedString type; CODE: htmlolistelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlolistelement, type) nsIDOMHTMLOListElement *htmlolistelement; nsEmbedString type; CODE: htmlolistelement->SetType(type); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLObjectElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLObjectElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLOBJECTELEMENT_IID) static nsIID nsIDOMHTMLObjectElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLObjectElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmlobjectelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetCode(nsAString & aCode) nsEmbedString moz_dom_GetCode (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString code; CODE: htmlobjectelement->GetCode(code); RETVAL = code; OUTPUT: RETVAL ## SetCode(const nsAString & aCode) void moz_dom_SetCode (htmlobjectelement, code) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString code; CODE: htmlobjectelement->SetCode(code); ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString align; CODE: htmlobjectelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmlobjectelement, align) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString align; CODE: htmlobjectelement->SetAlign(align); ## GetArchive(nsAString & aArchive) nsEmbedString moz_dom_GetArchive (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString archive; CODE: htmlobjectelement->GetArchive(archive); RETVAL = archive; OUTPUT: RETVAL ## SetArchive(const nsAString & aArchive) void moz_dom_SetArchive (htmlobjectelement, archive) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString archive; CODE: htmlobjectelement->SetArchive(archive); ## GetBorder(nsAString & aBorder) nsEmbedString moz_dom_GetBorder (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString border; CODE: htmlobjectelement->GetBorder(border); RETVAL = border; OUTPUT: RETVAL ## SetBorder(const nsAString & aBorder) void moz_dom_SetBorder (htmlobjectelement, border) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString border; CODE: htmlobjectelement->SetBorder(border); ## GetCodeBase(nsAString & aCodeBase) nsEmbedString moz_dom_GetCodeBase (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString codebase; CODE: htmlobjectelement->GetCodeBase(codebase); RETVAL = codebase; OUTPUT: RETVAL ## SetCodeBase(const nsAString & aCodeBase) void moz_dom_SetCodeBase (htmlobjectelement, codebase) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString codebase; CODE: htmlobjectelement->SetCodeBase(codebase); ## GetCodeType(nsAString & aCodeType) nsEmbedString moz_dom_GetCodeType (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString codetype; CODE: htmlobjectelement->GetCodeType(codetype); RETVAL = codetype; OUTPUT: RETVAL ## SetCodeType(const nsAString & aCodeType) void moz_dom_SetCodeType (htmlobjectelement, codetype) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString codetype; CODE: htmlobjectelement->SetCodeType(codetype); ## GetData(nsAString & aData) nsEmbedString moz_dom_GetData (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString data; CODE: htmlobjectelement->GetData(data); RETVAL = data; OUTPUT: RETVAL ## SetData(const nsAString & aData) void moz_dom_SetData (htmlobjectelement, data) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString data; CODE: htmlobjectelement->SetData(data); ## GetDeclare(PRBool *aDeclare) PRBool moz_dom_GetDeclare (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: PRBool declare; CODE: htmlobjectelement->GetDeclare(&declare); RETVAL = declare; OUTPUT: RETVAL ## SetDeclare(PRBool aDeclare) void moz_dom_SetDeclare (htmlobjectelement, declare) nsIDOMHTMLObjectElement *htmlobjectelement; PRBool declare; CODE: htmlobjectelement->SetDeclare(declare); ## GetHeight(nsAString & aHeight) nsEmbedString moz_dom_GetHeight (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString height; CODE: htmlobjectelement->GetHeight(height); RETVAL = height; OUTPUT: RETVAL ## SetHeight(const nsAString & aHeight) void moz_dom_SetHeight (htmlobjectelement, height) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString height; CODE: htmlobjectelement->SetHeight(height); ## GetHspace(PRInt32 *aHspace) PRInt32 moz_dom_GetHspace (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: PRInt32 hspace; CODE: htmlobjectelement->GetHspace(&hspace); RETVAL = hspace; OUTPUT: RETVAL ## SetHspace(PRInt32 aHspace) void moz_dom_SetHspace (htmlobjectelement, hspace) nsIDOMHTMLObjectElement *htmlobjectelement; PRInt32 hspace; CODE: htmlobjectelement->SetHspace(hspace); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString name; CODE: htmlobjectelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlobjectelement, name) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString name; CODE: htmlobjectelement->SetName(name); ## GetStandby(nsAString & aStandby) nsEmbedString moz_dom_GetStandby (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString standby; CODE: htmlobjectelement->GetStandby(standby); RETVAL = standby; OUTPUT: RETVAL ## SetStandby(const nsAString & aStandby) void moz_dom_SetStandby (htmlobjectelement, standby) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString standby; CODE: htmlobjectelement->SetStandby(standby); ## GetTabIndex(PRInt32 *aTabIndex) PRInt32 moz_dom_GetTabIndex (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: PRInt32 tabindex; CODE: htmlobjectelement->GetTabIndex(&tabindex); RETVAL = tabindex; OUTPUT: RETVAL ## SetTabIndex(PRInt32 aTabIndex) void moz_dom_SetTabIndex (htmlobjectelement, tabindex) nsIDOMHTMLObjectElement *htmlobjectelement; PRInt32 tabindex; CODE: htmlobjectelement->SetTabIndex(tabindex); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString type; CODE: htmlobjectelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlobjectelement, type) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString type; CODE: htmlobjectelement->SetType(type); ## GetUseMap(nsAString & aUseMap) nsEmbedString moz_dom_GetUseMap (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString usemap; CODE: htmlobjectelement->GetUseMap(usemap); RETVAL = usemap; OUTPUT: RETVAL ## SetUseMap(const nsAString & aUseMap) void moz_dom_SetUseMap (htmlobjectelement, usemap) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString usemap; CODE: htmlobjectelement->SetUseMap(usemap); ## GetVspace(PRInt32 *aVspace) PRInt32 moz_dom_GetVspace (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: PRInt32 vspace; CODE: htmlobjectelement->GetVspace(&vspace); RETVAL = vspace; OUTPUT: RETVAL ## SetVspace(PRInt32 aVspace) void moz_dom_SetVspace (htmlobjectelement, vspace) nsIDOMHTMLObjectElement *htmlobjectelement; PRInt32 vspace; CODE: htmlobjectelement->SetVspace(vspace); ## GetWidth(nsAString & aWidth) nsEmbedString moz_dom_GetWidth (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsEmbedString width; CODE: htmlobjectelement->GetWidth(width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(const nsAString & aWidth) void moz_dom_SetWidth (htmlobjectelement, width) nsIDOMHTMLObjectElement *htmlobjectelement; nsEmbedString width; CODE: htmlobjectelement->SetWidth(width); ## GetContentDocument(nsIDOMDocument * *aContentDocument) nsIDOMDocument * moz_dom_GetContentDocument (htmlobjectelement) nsIDOMHTMLObjectElement *htmlobjectelement; PREINIT: nsIDOMDocument * contentdocument; CODE: htmlobjectelement->GetContentDocument(&contentdocument); RETVAL = contentdocument; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLOptGroupElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLOptGroupElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLOPTGROUPELEMENT_IID) static nsIID nsIDOMHTMLOptGroupElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLOptGroupElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDisabled(PRBool *aDisabled) PRBool moz_dom_GetDisabled (htmloptgroupelement) nsIDOMHTMLOptGroupElement *htmloptgroupelement; PREINIT: PRBool disabled; CODE: htmloptgroupelement->GetDisabled(&disabled); RETVAL = disabled; OUTPUT: RETVAL ## SetDisabled(PRBool aDisabled) void moz_dom_SetDisabled (htmloptgroupelement, disabled) nsIDOMHTMLOptGroupElement *htmloptgroupelement; PRBool disabled; CODE: htmloptgroupelement->SetDisabled(disabled); ## GetLabel(nsAString & aLabel) nsEmbedString moz_dom_GetLabel (htmloptgroupelement) nsIDOMHTMLOptGroupElement *htmloptgroupelement; PREINIT: nsEmbedString label; CODE: htmloptgroupelement->GetLabel(label); RETVAL = label; OUTPUT: RETVAL ## SetLabel(const nsAString & aLabel) void moz_dom_SetLabel (htmloptgroupelement, label) nsIDOMHTMLOptGroupElement *htmloptgroupelement; nsEmbedString label; CODE: htmloptgroupelement->SetLabel(label); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLOptionElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLOptionElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLOPTIONELEMENT_IID) static nsIID nsIDOMHTMLOptionElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLOptionElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmloptionelement) nsIDOMHTMLOptionElement *htmloptionelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmloptionelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetDefaultSelected(PRBool *aDefaultSelected) PRBool moz_dom_GetDefaultSelected (htmloptionelement) nsIDOMHTMLOptionElement *htmloptionelement; PREINIT: PRBool defaultselected; CODE: htmloptionelement->GetDefaultSelected(&defaultselected); RETVAL = defaultselected; OUTPUT: RETVAL ## SetDefaultSelected(PRBool aDefaultSelected) void moz_dom_SetDefaultSelected (htmloptionelement, defaultselected) nsIDOMHTMLOptionElement *htmloptionelement; PRBool defaultselected; CODE: htmloptionelement->SetDefaultSelected(defaultselected); ## GetText(nsAString & aText) nsEmbedString moz_dom_GetText (htmloptionelement) nsIDOMHTMLOptionElement *htmloptionelement; PREINIT: nsEmbedString text; CODE: htmloptionelement->GetText(text); RETVAL = text; OUTPUT: RETVAL ## GetIndex(PRInt32 *aIndex) PRInt32 moz_dom_GetIndex (htmloptionelement) nsIDOMHTMLOptionElement *htmloptionelement; PREINIT: PRInt32 index; CODE: htmloptionelement->GetIndex(&index); RETVAL = index; OUTPUT: RETVAL ## GetDisabled(PRBool *aDisabled) PRBool moz_dom_GetDisabled (htmloptionelement) nsIDOMHTMLOptionElement *htmloptionelement; PREINIT: PRBool disabled; CODE: htmloptionelement->GetDisabled(&disabled); RETVAL = disabled; OUTPUT: RETVAL ## SetDisabled(PRBool aDisabled) void moz_dom_SetDisabled (htmloptionelement, disabled) nsIDOMHTMLOptionElement *htmloptionelement; PRBool disabled; CODE: htmloptionelement->SetDisabled(disabled); ## GetLabel(nsAString & aLabel) nsEmbedString moz_dom_GetLabel (htmloptionelement) nsIDOMHTMLOptionElement *htmloptionelement; PREINIT: nsEmbedString label; CODE: htmloptionelement->GetLabel(label); RETVAL = label; OUTPUT: RETVAL ## SetLabel(const nsAString & aLabel) void moz_dom_SetLabel (htmloptionelement, label) nsIDOMHTMLOptionElement *htmloptionelement; nsEmbedString label; CODE: htmloptionelement->SetLabel(label); ## GetSelected(PRBool *aSelected) PRBool moz_dom_GetSelected (htmloptionelement) nsIDOMHTMLOptionElement *htmloptionelement; PREINIT: PRBool selected; CODE: htmloptionelement->GetSelected(&selected); RETVAL = selected; OUTPUT: RETVAL ## SetSelected(PRBool aSelected) void moz_dom_SetSelected (htmloptionelement, selected) nsIDOMHTMLOptionElement *htmloptionelement; PRBool selected; CODE: htmloptionelement->SetSelected(selected); ## GetValue(nsAString & aValue) nsEmbedString moz_dom_GetValue (htmloptionelement) nsIDOMHTMLOptionElement *htmloptionelement; PREINIT: nsEmbedString value; CODE: htmloptionelement->GetValue(value); RETVAL = value; OUTPUT: RETVAL ## SetValue(const nsAString & aValue) void moz_dom_SetValue (htmloptionelement, value) nsIDOMHTMLOptionElement *htmloptionelement; nsEmbedString value; CODE: htmloptionelement->SetValue(value); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLOptionsCollection PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLOptionsCollection.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLOPTIONSCOLLECTION_IID) static nsIID nsIDOMHTMLOptionsCollection::GetIID() CODE: const nsIID &id = nsIDOMHTMLOptionsCollection::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetLength(PRUint32 *aLength) PRUint32 moz_dom_GetLength (htmloptionscollection) nsIDOMHTMLOptionsCollection *htmloptionscollection; PREINIT: PRUint32 length; CODE: htmloptionscollection->GetLength(&length); RETVAL = length; OUTPUT: RETVAL ## SetLength(PRUint32 aLength) void moz_dom_SetLength (htmloptionscollection, length) nsIDOMHTMLOptionsCollection *htmloptionscollection; PRUint32 length; CODE: htmloptionscollection->SetLength(length); ## Item(PRUint32 index, nsIDOMNode **_retval) nsIDOMNode * moz_dom_Item (htmloptionscollection, index) nsIDOMHTMLOptionsCollection *htmloptionscollection; PRUint32 index; PREINIT: nsIDOMNode * retval; CODE: htmloptionscollection->Item(index, &retval); RETVAL = retval; OUTPUT: RETVAL ## NamedItem(const nsAString & name, nsIDOMNode **_retval) nsIDOMNode * moz_dom_NamedItem (htmloptionscollection, name) nsIDOMHTMLOptionsCollection *htmloptionscollection; nsEmbedString name; PREINIT: nsIDOMNode * retval; CODE: htmloptionscollection->NamedItem(name, &retval); RETVAL = retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLParagraphElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLParagraphElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLPARAGRAPHELEMENT_IID) static nsIID nsIDOMHTMLParagraphElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLParagraphElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmlparagraphelement) nsIDOMHTMLParagraphElement *htmlparagraphelement; PREINIT: nsEmbedString align; CODE: htmlparagraphelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmlparagraphelement, align) nsIDOMHTMLParagraphElement *htmlparagraphelement; nsEmbedString align; CODE: htmlparagraphelement->SetAlign(align); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLParamElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLParamElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLPARAMELEMENT_IID) static nsIID nsIDOMHTMLParamElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLParamElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlparamelement) nsIDOMHTMLParamElement *htmlparamelement; PREINIT: nsEmbedString name; CODE: htmlparamelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlparamelement, name) nsIDOMHTMLParamElement *htmlparamelement; nsEmbedString name; CODE: htmlparamelement->SetName(name); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlparamelement) nsIDOMHTMLParamElement *htmlparamelement; PREINIT: nsEmbedString type; CODE: htmlparamelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlparamelement, type) nsIDOMHTMLParamElement *htmlparamelement; nsEmbedString type; CODE: htmlparamelement->SetType(type); ## GetValue(nsAString & aValue) nsEmbedString moz_dom_GetValue (htmlparamelement) nsIDOMHTMLParamElement *htmlparamelement; PREINIT: nsEmbedString value; CODE: htmlparamelement->GetValue(value); RETVAL = value; OUTPUT: RETVAL ## SetValue(const nsAString & aValue) void moz_dom_SetValue (htmlparamelement, value) nsIDOMHTMLParamElement *htmlparamelement; nsEmbedString value; CODE: htmlparamelement->SetValue(value); ## GetValueType(nsAString & aValueType) nsEmbedString moz_dom_GetValueType (htmlparamelement) nsIDOMHTMLParamElement *htmlparamelement; PREINIT: nsEmbedString valuetype; CODE: htmlparamelement->GetValueType(valuetype); RETVAL = valuetype; OUTPUT: RETVAL ## SetValueType(const nsAString & aValueType) void moz_dom_SetValueType (htmlparamelement, valuetype) nsIDOMHTMLParamElement *htmlparamelement; nsEmbedString valuetype; CODE: htmlparamelement->SetValueType(valuetype); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLPreElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLPreElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLPREELEMENT_IID) static nsIID nsIDOMHTMLPreElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLPreElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetWidth(PRInt32 *aWidth) PRInt32 moz_dom_GetWidth (htmlpreelement) nsIDOMHTMLPreElement *htmlpreelement; PREINIT: PRInt32 width; CODE: htmlpreelement->GetWidth(&width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(PRInt32 aWidth) void moz_dom_SetWidth (htmlpreelement, width) nsIDOMHTMLPreElement *htmlpreelement; PRInt32 width; CODE: htmlpreelement->SetWidth(width); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLQuoteElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLQuoteElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLQUOTEELEMENT_IID) static nsIID nsIDOMHTMLQuoteElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLQuoteElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCite(nsAString & aCite) nsEmbedString moz_dom_GetCite (htmlquoteelement) nsIDOMHTMLQuoteElement *htmlquoteelement; PREINIT: nsEmbedString cite; CODE: htmlquoteelement->GetCite(cite); RETVAL = cite; OUTPUT: RETVAL ## SetCite(const nsAString & aCite) void moz_dom_SetCite (htmlquoteelement, cite) nsIDOMHTMLQuoteElement *htmlquoteelement; nsEmbedString cite; CODE: htmlquoteelement->SetCite(cite); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLScriptElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLScriptElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLSCRIPTELEMENT_IID) static nsIID nsIDOMHTMLScriptElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLScriptElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetText(nsAString & aText) nsEmbedString moz_dom_GetText (htmlscriptelement) nsIDOMHTMLScriptElement *htmlscriptelement; PREINIT: nsEmbedString text; CODE: htmlscriptelement->GetText(text); RETVAL = text; OUTPUT: RETVAL ## SetText(const nsAString & aText) void moz_dom_SetText (htmlscriptelement, text) nsIDOMHTMLScriptElement *htmlscriptelement; nsEmbedString text; CODE: htmlscriptelement->SetText(text); ## GetHtmlFor(nsAString & aHtmlFor) nsEmbedString moz_dom_GetHtmlFor (htmlscriptelement) nsIDOMHTMLScriptElement *htmlscriptelement; PREINIT: nsEmbedString htmlfor; CODE: htmlscriptelement->GetHtmlFor(htmlfor); RETVAL = htmlfor; OUTPUT: RETVAL ## SetHtmlFor(const nsAString & aHtmlFor) void moz_dom_SetHtmlFor (htmlscriptelement, htmlfor) nsIDOMHTMLScriptElement *htmlscriptelement; nsEmbedString htmlfor; CODE: htmlscriptelement->SetHtmlFor(htmlfor); ## GetEvent(nsAString & aEvent) nsEmbedString moz_dom_GetEvent (htmlscriptelement) nsIDOMHTMLScriptElement *htmlscriptelement; PREINIT: nsEmbedString event; CODE: htmlscriptelement->GetEvent(event); RETVAL = event; OUTPUT: RETVAL ## SetEvent(const nsAString & aEvent) void moz_dom_SetEvent (htmlscriptelement, event) nsIDOMHTMLScriptElement *htmlscriptelement; nsEmbedString event; CODE: htmlscriptelement->SetEvent(event); ## GetCharset(nsAString & aCharset) nsEmbedString moz_dom_GetCharset (htmlscriptelement) nsIDOMHTMLScriptElement *htmlscriptelement; PREINIT: nsEmbedString charset; CODE: htmlscriptelement->GetCharset(charset); RETVAL = charset; OUTPUT: RETVAL ## SetCharset(const nsAString & aCharset) void moz_dom_SetCharset (htmlscriptelement, charset) nsIDOMHTMLScriptElement *htmlscriptelement; nsEmbedString charset; CODE: htmlscriptelement->SetCharset(charset); ## GetDefer(PRBool *aDefer) PRBool moz_dom_GetDefer (htmlscriptelement) nsIDOMHTMLScriptElement *htmlscriptelement; PREINIT: PRBool defer; CODE: htmlscriptelement->GetDefer(&defer); RETVAL = defer; OUTPUT: RETVAL ## SetDefer(PRBool aDefer) void moz_dom_SetDefer (htmlscriptelement, defer) nsIDOMHTMLScriptElement *htmlscriptelement; PRBool defer; CODE: htmlscriptelement->SetDefer(defer); ## GetSrc(nsAString & aSrc) nsEmbedString moz_dom_GetSrc (htmlscriptelement) nsIDOMHTMLScriptElement *htmlscriptelement; PREINIT: nsEmbedString src; CODE: htmlscriptelement->GetSrc(src); RETVAL = src; OUTPUT: RETVAL ## SetSrc(const nsAString & aSrc) void moz_dom_SetSrc (htmlscriptelement, src) nsIDOMHTMLScriptElement *htmlscriptelement; nsEmbedString src; CODE: htmlscriptelement->SetSrc(src); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlscriptelement) nsIDOMHTMLScriptElement *htmlscriptelement; PREINIT: nsEmbedString type; CODE: htmlscriptelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlscriptelement, type) nsIDOMHTMLScriptElement *htmlscriptelement; nsEmbedString type; CODE: htmlscriptelement->SetType(type); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLSelectElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLSelectElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLSELECTELEMENT_IID) static nsIID nsIDOMHTMLSelectElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLSelectElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: nsEmbedString type; CODE: htmlselectelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## GetSelectedIndex(PRInt32 *aSelectedIndex) PRInt32 moz_dom_GetSelectedIndex (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: PRInt32 selectedindex; CODE: htmlselectelement->GetSelectedIndex(&selectedindex); RETVAL = selectedindex; OUTPUT: RETVAL ## SetSelectedIndex(PRInt32 aSelectedIndex) void moz_dom_SetSelectedIndex (htmlselectelement, selectedindex) nsIDOMHTMLSelectElement *htmlselectelement; PRInt32 selectedindex; CODE: htmlselectelement->SetSelectedIndex(selectedindex); ## GetValue(nsAString & aValue) nsEmbedString moz_dom_GetValue (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: nsEmbedString value; CODE: htmlselectelement->GetValue(value); RETVAL = value; OUTPUT: RETVAL ## SetValue(const nsAString & aValue) void moz_dom_SetValue (htmlselectelement, value) nsIDOMHTMLSelectElement *htmlselectelement; nsEmbedString value; CODE: htmlselectelement->SetValue(value); ## GetLength(PRUint32 *aLength) PRUint32 moz_dom_GetLength (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: PRUint32 length; CODE: htmlselectelement->GetLength(&length); RETVAL = length; OUTPUT: RETVAL ## SetLength(PRUint32 aLength) void moz_dom_SetLength (htmlselectelement, length) nsIDOMHTMLSelectElement *htmlselectelement; PRUint32 length; CODE: htmlselectelement->SetLength(length); ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmlselectelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetOptions(nsIDOMHTMLOptionsCollection * *aOptions) nsIDOMHTMLOptionsCollection * moz_dom_GetOptions_optionscollection (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: nsIDOMHTMLOptionsCollection * options; CODE: htmlselectelement->GetOptions(&options); RETVAL = options; OUTPUT: RETVAL ## GetDisabled(PRBool *aDisabled) PRBool moz_dom_GetDisabled (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: PRBool disabled; CODE: htmlselectelement->GetDisabled(&disabled); RETVAL = disabled; OUTPUT: RETVAL ## SetDisabled(PRBool aDisabled) void moz_dom_SetDisabled (htmlselectelement, disabled) nsIDOMHTMLSelectElement *htmlselectelement; PRBool disabled; CODE: htmlselectelement->SetDisabled(disabled); ## GetMultiple(PRBool *aMultiple) PRBool moz_dom_GetMultiple (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: PRBool multiple; CODE: htmlselectelement->GetMultiple(&multiple); RETVAL = multiple; OUTPUT: RETVAL ## SetMultiple(PRBool aMultiple) void moz_dom_SetMultiple (htmlselectelement, multiple) nsIDOMHTMLSelectElement *htmlselectelement; PRBool multiple; CODE: htmlselectelement->SetMultiple(multiple); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: nsEmbedString name; CODE: htmlselectelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmlselectelement, name) nsIDOMHTMLSelectElement *htmlselectelement; nsEmbedString name; CODE: htmlselectelement->SetName(name); ## GetSize(PRInt32 *aSize) PRInt32 moz_dom_GetSize (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: PRInt32 size; CODE: htmlselectelement->GetSize(&size); RETVAL = size; OUTPUT: RETVAL ## SetSize(PRInt32 aSize) void moz_dom_SetSize (htmlselectelement, size) nsIDOMHTMLSelectElement *htmlselectelement; PRInt32 size; CODE: htmlselectelement->SetSize(size); ## GetTabIndex(PRInt32 *aTabIndex) PRInt32 moz_dom_GetTabIndex (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; PREINIT: PRInt32 tabindex; CODE: htmlselectelement->GetTabIndex(&tabindex); RETVAL = tabindex; OUTPUT: RETVAL ## SetTabIndex(PRInt32 aTabIndex) void moz_dom_SetTabIndex (htmlselectelement, tabindex) nsIDOMHTMLSelectElement *htmlselectelement; PRInt32 tabindex; CODE: htmlselectelement->SetTabIndex(tabindex); ## Add(nsIDOMHTMLElement *element, nsIDOMHTMLElement *before) void moz_dom_Add (htmlselectelement, element, before) nsIDOMHTMLSelectElement *htmlselectelement; nsIDOMHTMLElement * element; nsIDOMHTMLElement * before; CODE: htmlselectelement->Add(element, before); ## Remove(PRInt32 index) void moz_dom_Remove (htmlselectelement, index) nsIDOMHTMLSelectElement *htmlselectelement; PRInt32 index; CODE: htmlselectelement->Remove(index); ## Blur(void) void moz_dom_Blur (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; CODE: htmlselectelement->Blur(); ## Focus(void) void moz_dom_Focus (htmlselectelement) nsIDOMHTMLSelectElement *htmlselectelement; CODE: htmlselectelement->Focus(); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLStyleElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLStyleElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLSTYLEELEMENT_IID) static nsIID nsIDOMHTMLStyleElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLStyleElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDisabled(PRBool *aDisabled) PRBool moz_dom_GetDisabled (htmlstyleelement) nsIDOMHTMLStyleElement *htmlstyleelement; PREINIT: PRBool disabled; CODE: htmlstyleelement->GetDisabled(&disabled); RETVAL = disabled; OUTPUT: RETVAL ## SetDisabled(PRBool aDisabled) void moz_dom_SetDisabled (htmlstyleelement, disabled) nsIDOMHTMLStyleElement *htmlstyleelement; PRBool disabled; CODE: htmlstyleelement->SetDisabled(disabled); ## GetMedia(nsAString & aMedia) nsEmbedString moz_dom_GetMedia (htmlstyleelement) nsIDOMHTMLStyleElement *htmlstyleelement; PREINIT: nsEmbedString media; CODE: htmlstyleelement->GetMedia(media); RETVAL = media; OUTPUT: RETVAL ## SetMedia(const nsAString & aMedia) void moz_dom_SetMedia (htmlstyleelement, media) nsIDOMHTMLStyleElement *htmlstyleelement; nsEmbedString media; CODE: htmlstyleelement->SetMedia(media); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlstyleelement) nsIDOMHTMLStyleElement *htmlstyleelement; PREINIT: nsEmbedString type; CODE: htmlstyleelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlstyleelement, type) nsIDOMHTMLStyleElement *htmlstyleelement; nsEmbedString type; CODE: htmlstyleelement->SetType(type); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLTableCaptionElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLTableCaptionElem.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLTABLECAPTIONELEMENT_IID) static nsIID nsIDOMHTMLTableCaptionElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLTableCaptionElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmltablecaptionelement) nsIDOMHTMLTableCaptionElement *htmltablecaptionelement; PREINIT: nsEmbedString align; CODE: htmltablecaptionelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmltablecaptionelement, align) nsIDOMHTMLTableCaptionElement *htmltablecaptionelement; nsEmbedString align; CODE: htmltablecaptionelement->SetAlign(align); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLTableCellElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLTableCellElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLTABLECELLELEMENT_IID) static nsIID nsIDOMHTMLTableCellElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLTableCellElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCellIndex(PRInt32 *aCellIndex) PRInt32 moz_dom_GetCellIndex (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: PRInt32 cellindex; CODE: htmltablecellelement->GetCellIndex(&cellindex); RETVAL = cellindex; OUTPUT: RETVAL ## GetAbbr(nsAString & aAbbr) nsEmbedString moz_dom_GetAbbr (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString abbr; CODE: htmltablecellelement->GetAbbr(abbr); RETVAL = abbr; OUTPUT: RETVAL ## SetAbbr(const nsAString & aAbbr) void moz_dom_SetAbbr (htmltablecellelement, abbr) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString abbr; CODE: htmltablecellelement->SetAbbr(abbr); ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString align; CODE: htmltablecellelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmltablecellelement, align) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString align; CODE: htmltablecellelement->SetAlign(align); ## GetAxis(nsAString & aAxis) nsEmbedString moz_dom_GetAxis (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString axis; CODE: htmltablecellelement->GetAxis(axis); RETVAL = axis; OUTPUT: RETVAL ## SetAxis(const nsAString & aAxis) void moz_dom_SetAxis (htmltablecellelement, axis) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString axis; CODE: htmltablecellelement->SetAxis(axis); ## GetBgColor(nsAString & aBgColor) nsEmbedString moz_dom_GetBgColor (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString bgcolor; CODE: htmltablecellelement->GetBgColor(bgcolor); RETVAL = bgcolor; OUTPUT: RETVAL ## SetBgColor(const nsAString & aBgColor) void moz_dom_SetBgColor (htmltablecellelement, bgcolor) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString bgcolor; CODE: htmltablecellelement->SetBgColor(bgcolor); ## GetCh(nsAString & aCh) nsEmbedString moz_dom_GetCh (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString ch; CODE: htmltablecellelement->GetCh(ch); RETVAL = ch; OUTPUT: RETVAL ## SetCh(const nsAString & aCh) void moz_dom_SetCh (htmltablecellelement, ch) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString ch; CODE: htmltablecellelement->SetCh(ch); ## GetChOff(nsAString & aChOff) nsEmbedString moz_dom_GetChOff (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString choff; CODE: htmltablecellelement->GetChOff(choff); RETVAL = choff; OUTPUT: RETVAL ## SetChOff(const nsAString & aChOff) void moz_dom_SetChOff (htmltablecellelement, choff) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString choff; CODE: htmltablecellelement->SetChOff(choff); ## GetColSpan(PRInt32 *aColSpan) PRInt32 moz_dom_GetColSpan (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: PRInt32 colspan; CODE: htmltablecellelement->GetColSpan(&colspan); RETVAL = colspan; OUTPUT: RETVAL ## SetColSpan(PRInt32 aColSpan) void moz_dom_SetColSpan (htmltablecellelement, colspan) nsIDOMHTMLTableCellElement *htmltablecellelement; PRInt32 colspan; CODE: htmltablecellelement->SetColSpan(colspan); ## GetHeaders(nsAString & aHeaders) nsEmbedString moz_dom_GetHeaders (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString headers; CODE: htmltablecellelement->GetHeaders(headers); RETVAL = headers; OUTPUT: RETVAL ## SetHeaders(const nsAString & aHeaders) void moz_dom_SetHeaders (htmltablecellelement, headers) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString headers; CODE: htmltablecellelement->SetHeaders(headers); ## GetHeight(nsAString & aHeight) nsEmbedString moz_dom_GetHeight (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString height; CODE: htmltablecellelement->GetHeight(height); RETVAL = height; OUTPUT: RETVAL ## SetHeight(const nsAString & aHeight) void moz_dom_SetHeight (htmltablecellelement, height) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString height; CODE: htmltablecellelement->SetHeight(height); ## GetNoWrap(PRBool *aNoWrap) PRBool moz_dom_GetNoWrap (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: PRBool nowrap; CODE: htmltablecellelement->GetNoWrap(&nowrap); RETVAL = nowrap; OUTPUT: RETVAL ## SetNoWrap(PRBool aNoWrap) void moz_dom_SetNoWrap (htmltablecellelement, nowrap) nsIDOMHTMLTableCellElement *htmltablecellelement; PRBool nowrap; CODE: htmltablecellelement->SetNoWrap(nowrap); ## GetRowSpan(PRInt32 *aRowSpan) PRInt32 moz_dom_GetRowSpan (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: PRInt32 rowspan; CODE: htmltablecellelement->GetRowSpan(&rowspan); RETVAL = rowspan; OUTPUT: RETVAL ## SetRowSpan(PRInt32 aRowSpan) void moz_dom_SetRowSpan (htmltablecellelement, rowspan) nsIDOMHTMLTableCellElement *htmltablecellelement; PRInt32 rowspan; CODE: htmltablecellelement->SetRowSpan(rowspan); ## GetScope(nsAString & aScope) nsEmbedString moz_dom_GetScope (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString scope; CODE: htmltablecellelement->GetScope(scope); RETVAL = scope; OUTPUT: RETVAL ## SetScope(const nsAString & aScope) void moz_dom_SetScope (htmltablecellelement, scope) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString scope; CODE: htmltablecellelement->SetScope(scope); ## GetVAlign(nsAString & aVAlign) nsEmbedString moz_dom_GetVAlign (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString valign; CODE: htmltablecellelement->GetVAlign(valign); RETVAL = valign; OUTPUT: RETVAL ## SetVAlign(const nsAString & aVAlign) void moz_dom_SetVAlign (htmltablecellelement, valign) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString valign; CODE: htmltablecellelement->SetVAlign(valign); ## GetWidth(nsAString & aWidth) nsEmbedString moz_dom_GetWidth (htmltablecellelement) nsIDOMHTMLTableCellElement *htmltablecellelement; PREINIT: nsEmbedString width; CODE: htmltablecellelement->GetWidth(width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(const nsAString & aWidth) void moz_dom_SetWidth (htmltablecellelement, width) nsIDOMHTMLTableCellElement *htmltablecellelement; nsEmbedString width; CODE: htmltablecellelement->SetWidth(width); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLTableColElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLTableColElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLTABLECOLELEMENT_IID) static nsIID nsIDOMHTMLTableColElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLTableColElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmltablecolelement) nsIDOMHTMLTableColElement *htmltablecolelement; PREINIT: nsEmbedString align; CODE: htmltablecolelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmltablecolelement, align) nsIDOMHTMLTableColElement *htmltablecolelement; nsEmbedString align; CODE: htmltablecolelement->SetAlign(align); ## GetCh(nsAString & aCh) nsEmbedString moz_dom_GetCh (htmltablecolelement) nsIDOMHTMLTableColElement *htmltablecolelement; PREINIT: nsEmbedString ch; CODE: htmltablecolelement->GetCh(ch); RETVAL = ch; OUTPUT: RETVAL ## SetCh(const nsAString & aCh) void moz_dom_SetCh (htmltablecolelement, ch) nsIDOMHTMLTableColElement *htmltablecolelement; nsEmbedString ch; CODE: htmltablecolelement->SetCh(ch); ## GetChOff(nsAString & aChOff) nsEmbedString moz_dom_GetChOff (htmltablecolelement) nsIDOMHTMLTableColElement *htmltablecolelement; PREINIT: nsEmbedString choff; CODE: htmltablecolelement->GetChOff(choff); RETVAL = choff; OUTPUT: RETVAL ## SetChOff(const nsAString & aChOff) void moz_dom_SetChOff (htmltablecolelement, choff) nsIDOMHTMLTableColElement *htmltablecolelement; nsEmbedString choff; CODE: htmltablecolelement->SetChOff(choff); ## GetSpan(PRInt32 *aSpan) PRInt32 moz_dom_GetSpan (htmltablecolelement) nsIDOMHTMLTableColElement *htmltablecolelement; PREINIT: PRInt32 span; CODE: htmltablecolelement->GetSpan(&span); RETVAL = span; OUTPUT: RETVAL ## SetSpan(PRInt32 aSpan) void moz_dom_SetSpan (htmltablecolelement, span) nsIDOMHTMLTableColElement *htmltablecolelement; PRInt32 span; CODE: htmltablecolelement->SetSpan(span); ## GetVAlign(nsAString & aVAlign) nsEmbedString moz_dom_GetVAlign (htmltablecolelement) nsIDOMHTMLTableColElement *htmltablecolelement; PREINIT: nsEmbedString valign; CODE: htmltablecolelement->GetVAlign(valign); RETVAL = valign; OUTPUT: RETVAL ## SetVAlign(const nsAString & aVAlign) void moz_dom_SetVAlign (htmltablecolelement, valign) nsIDOMHTMLTableColElement *htmltablecolelement; nsEmbedString valign; CODE: htmltablecolelement->SetVAlign(valign); ## GetWidth(nsAString & aWidth) nsEmbedString moz_dom_GetWidth (htmltablecolelement) nsIDOMHTMLTableColElement *htmltablecolelement; PREINIT: nsEmbedString width; CODE: htmltablecolelement->GetWidth(width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(const nsAString & aWidth) void moz_dom_SetWidth (htmltablecolelement, width) nsIDOMHTMLTableColElement *htmltablecolelement; nsEmbedString width; CODE: htmltablecolelement->SetWidth(width); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLTableElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLTableElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLTABLEELEMENT_IID) static nsIID nsIDOMHTMLTableElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLTableElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCaption(nsIDOMHTMLTableCaptionElement * *aCaption) nsIDOMHTMLTableCaptionElement * moz_dom_GetCaption (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsIDOMHTMLTableCaptionElement * caption; CODE: htmltableelement->GetCaption(&caption); RETVAL = caption; OUTPUT: RETVAL ## SetCaption(nsIDOMHTMLTableCaptionElement * aCaption) void moz_dom_SetCaption (htmltableelement, caption) nsIDOMHTMLTableElement *htmltableelement; nsIDOMHTMLTableCaptionElement * caption; CODE: htmltableelement->SetCaption(caption); ## GetTHead(nsIDOMHTMLTableSectionElement * *aTHead) nsIDOMHTMLTableSectionElement * moz_dom_GetTHead (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsIDOMHTMLTableSectionElement * thead; CODE: htmltableelement->GetTHead(&thead); RETVAL = thead; OUTPUT: RETVAL ## SetTHead(nsIDOMHTMLTableSectionElement * aTHead) void moz_dom_SetTHead (htmltableelement, thead) nsIDOMHTMLTableElement *htmltableelement; nsIDOMHTMLTableSectionElement * thead; CODE: htmltableelement->SetTHead(thead); ## GetTFoot(nsIDOMHTMLTableSectionElement * *aTFoot) nsIDOMHTMLTableSectionElement * moz_dom_GetTFoot (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsIDOMHTMLTableSectionElement * tfoot; CODE: htmltableelement->GetTFoot(&tfoot); RETVAL = tfoot; OUTPUT: RETVAL ## SetTFoot(nsIDOMHTMLTableSectionElement * aTFoot) void moz_dom_SetTFoot (htmltableelement, tfoot) nsIDOMHTMLTableElement *htmltableelement; nsIDOMHTMLTableSectionElement * tfoot; CODE: htmltableelement->SetTFoot(tfoot); ## GetRows(nsIDOMHTMLCollection * *aRows) nsIDOMHTMLCollection * moz_dom_GetRows_htmlcollection (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsIDOMHTMLCollection * rows; CODE: htmltableelement->GetRows(&rows); RETVAL = rows; OUTPUT: RETVAL ## GetTBodies(nsIDOMHTMLCollection * *aTBodies) nsIDOMHTMLCollection * moz_dom_GetTBodies_htmlcollection (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsIDOMHTMLCollection * tbodies; CODE: htmltableelement->GetTBodies(&tbodies); RETVAL = tbodies; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString align; CODE: htmltableelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmltableelement, align) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString align; CODE: htmltableelement->SetAlign(align); ## GetBgColor(nsAString & aBgColor) nsEmbedString moz_dom_GetBgColor (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString bgcolor; CODE: htmltableelement->GetBgColor(bgcolor); RETVAL = bgcolor; OUTPUT: RETVAL ## SetBgColor(const nsAString & aBgColor) void moz_dom_SetBgColor (htmltableelement, bgcolor) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString bgcolor; CODE: htmltableelement->SetBgColor(bgcolor); ## GetBorder(nsAString & aBorder) nsEmbedString moz_dom_GetBorder (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString border; CODE: htmltableelement->GetBorder(border); RETVAL = border; OUTPUT: RETVAL ## SetBorder(const nsAString & aBorder) void moz_dom_SetBorder (htmltableelement, border) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString border; CODE: htmltableelement->SetBorder(border); ## GetCellPadding(nsAString & aCellPadding) nsEmbedString moz_dom_GetCellPadding (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString cellpadding; CODE: htmltableelement->GetCellPadding(cellpadding); RETVAL = cellpadding; OUTPUT: RETVAL ## SetCellPadding(const nsAString & aCellPadding) void moz_dom_SetCellPadding (htmltableelement, cellpadding) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString cellpadding; CODE: htmltableelement->SetCellPadding(cellpadding); ## GetCellSpacing(nsAString & aCellSpacing) nsEmbedString moz_dom_GetCellSpacing (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString cellspacing; CODE: htmltableelement->GetCellSpacing(cellspacing); RETVAL = cellspacing; OUTPUT: RETVAL ## SetCellSpacing(const nsAString & aCellSpacing) void moz_dom_SetCellSpacing (htmltableelement, cellspacing) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString cellspacing; CODE: htmltableelement->SetCellSpacing(cellspacing); ## GetFrame(nsAString & aFrame) nsEmbedString moz_dom_GetFrame (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString frame; CODE: htmltableelement->GetFrame(frame); RETVAL = frame; OUTPUT: RETVAL ## SetFrame(const nsAString & aFrame) void moz_dom_SetFrame (htmltableelement, frame) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString frame; CODE: htmltableelement->SetFrame(frame); ## GetRules(nsAString & aRules) nsEmbedString moz_dom_GetRules (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString rules; CODE: htmltableelement->GetRules(rules); RETVAL = rules; OUTPUT: RETVAL ## SetRules(const nsAString & aRules) void moz_dom_SetRules (htmltableelement, rules) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString rules; CODE: htmltableelement->SetRules(rules); ## GetSummary(nsAString & aSummary) nsEmbedString moz_dom_GetSummary (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString summary; CODE: htmltableelement->GetSummary(summary); RETVAL = summary; OUTPUT: RETVAL ## SetSummary(const nsAString & aSummary) void moz_dom_SetSummary (htmltableelement, summary) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString summary; CODE: htmltableelement->SetSummary(summary); ## GetWidth(nsAString & aWidth) nsEmbedString moz_dom_GetWidth (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsEmbedString width; CODE: htmltableelement->GetWidth(width); RETVAL = width; OUTPUT: RETVAL ## SetWidth(const nsAString & aWidth) void moz_dom_SetWidth (htmltableelement, width) nsIDOMHTMLTableElement *htmltableelement; nsEmbedString width; CODE: htmltableelement->SetWidth(width); ## CreateTHead(nsIDOMHTMLElement **_retval) nsIDOMHTMLElement * moz_dom_CreateTHead (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsIDOMHTMLElement * retval; CODE: htmltableelement->CreateTHead(&retval); RETVAL = retval; OUTPUT: RETVAL ## DeleteTHead(void) void moz_dom_DeleteTHead (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; CODE: htmltableelement->DeleteTHead(); ## CreateTFoot(nsIDOMHTMLElement **_retval) nsIDOMHTMLElement * moz_dom_CreateTFoot (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsIDOMHTMLElement * retval; CODE: htmltableelement->CreateTFoot(&retval); RETVAL = retval; OUTPUT: RETVAL ## DeleteTFoot(void) void moz_dom_DeleteTFoot (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; CODE: htmltableelement->DeleteTFoot(); ## CreateCaption(nsIDOMHTMLElement **_retval) nsIDOMHTMLElement * moz_dom_CreateCaption (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; PREINIT: nsIDOMHTMLElement * retval; CODE: htmltableelement->CreateCaption(&retval); RETVAL = retval; OUTPUT: RETVAL ## DeleteCaption(void) void moz_dom_DeleteCaption (htmltableelement) nsIDOMHTMLTableElement *htmltableelement; CODE: htmltableelement->DeleteCaption(); ## InsertRow(PRInt32 index, nsIDOMHTMLElement **_retval) nsIDOMHTMLElement * moz_dom_InsertRow (htmltableelement, index) nsIDOMHTMLTableElement *htmltableelement; PRInt32 index; PREINIT: nsIDOMHTMLElement * retval; CODE: htmltableelement->InsertRow(index, &retval); RETVAL = retval; OUTPUT: RETVAL ## DeleteRow(PRInt32 index) void moz_dom_DeleteRow (htmltableelement, index) nsIDOMHTMLTableElement *htmltableelement; PRInt32 index; CODE: htmltableelement->DeleteRow(index); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLTableRowElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLTableRowElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLTABLEROWELEMENT_IID) static nsIID nsIDOMHTMLTableRowElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLTableRowElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetRowIndex(PRInt32 *aRowIndex) PRInt32 moz_dom_GetRowIndex (htmltablerowelement) nsIDOMHTMLTableRowElement *htmltablerowelement; PREINIT: PRInt32 rowindex; CODE: htmltablerowelement->GetRowIndex(&rowindex); RETVAL = rowindex; OUTPUT: RETVAL ## GetSectionRowIndex(PRInt32 *aSectionRowIndex) PRInt32 moz_dom_GetSectionRowIndex (htmltablerowelement) nsIDOMHTMLTableRowElement *htmltablerowelement; PREINIT: PRInt32 sectionrowindex; CODE: htmltablerowelement->GetSectionRowIndex(§ionrowindex); RETVAL = sectionrowindex; OUTPUT: RETVAL ## GetCells(nsIDOMHTMLCollection * *aCells) nsIDOMHTMLCollection * moz_dom_GetCells_htmlcollection (htmltablerowelement) nsIDOMHTMLTableRowElement *htmltablerowelement; PREINIT: nsIDOMHTMLCollection * cells; CODE: htmltablerowelement->GetCells(&cells); RETVAL = cells; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmltablerowelement) nsIDOMHTMLTableRowElement *htmltablerowelement; PREINIT: nsEmbedString align; CODE: htmltablerowelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmltablerowelement, align) nsIDOMHTMLTableRowElement *htmltablerowelement; nsEmbedString align; CODE: htmltablerowelement->SetAlign(align); ## GetBgColor(nsAString & aBgColor) nsEmbedString moz_dom_GetBgColor (htmltablerowelement) nsIDOMHTMLTableRowElement *htmltablerowelement; PREINIT: nsEmbedString bgcolor; CODE: htmltablerowelement->GetBgColor(bgcolor); RETVAL = bgcolor; OUTPUT: RETVAL ## SetBgColor(const nsAString & aBgColor) void moz_dom_SetBgColor (htmltablerowelement, bgcolor) nsIDOMHTMLTableRowElement *htmltablerowelement; nsEmbedString bgcolor; CODE: htmltablerowelement->SetBgColor(bgcolor); ## GetCh(nsAString & aCh) nsEmbedString moz_dom_GetCh (htmltablerowelement) nsIDOMHTMLTableRowElement *htmltablerowelement; PREINIT: nsEmbedString ch; CODE: htmltablerowelement->GetCh(ch); RETVAL = ch; OUTPUT: RETVAL ## SetCh(const nsAString & aCh) void moz_dom_SetCh (htmltablerowelement, ch) nsIDOMHTMLTableRowElement *htmltablerowelement; nsEmbedString ch; CODE: htmltablerowelement->SetCh(ch); ## GetChOff(nsAString & aChOff) nsEmbedString moz_dom_GetChOff (htmltablerowelement) nsIDOMHTMLTableRowElement *htmltablerowelement; PREINIT: nsEmbedString choff; CODE: htmltablerowelement->GetChOff(choff); RETVAL = choff; OUTPUT: RETVAL ## SetChOff(const nsAString & aChOff) void moz_dom_SetChOff (htmltablerowelement, choff) nsIDOMHTMLTableRowElement *htmltablerowelement; nsEmbedString choff; CODE: htmltablerowelement->SetChOff(choff); ## GetVAlign(nsAString & aVAlign) nsEmbedString moz_dom_GetVAlign (htmltablerowelement) nsIDOMHTMLTableRowElement *htmltablerowelement; PREINIT: nsEmbedString valign; CODE: htmltablerowelement->GetVAlign(valign); RETVAL = valign; OUTPUT: RETVAL ## SetVAlign(const nsAString & aVAlign) void moz_dom_SetVAlign (htmltablerowelement, valign) nsIDOMHTMLTableRowElement *htmltablerowelement; nsEmbedString valign; CODE: htmltablerowelement->SetVAlign(valign); ## InsertCell(PRInt32 index, nsIDOMHTMLElement **_retval) nsIDOMHTMLElement * moz_dom_InsertCell (htmltablerowelement, index) nsIDOMHTMLTableRowElement *htmltablerowelement; PRInt32 index; PREINIT: nsIDOMHTMLElement * retval; CODE: htmltablerowelement->InsertCell(index, &retval); RETVAL = retval; OUTPUT: RETVAL ## DeleteCell(PRInt32 index) void moz_dom_DeleteCell (htmltablerowelement, index) nsIDOMHTMLTableRowElement *htmltablerowelement; PRInt32 index; CODE: htmltablerowelement->DeleteCell(index); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLTableSectionElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLTableSectionElem.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLTABLESECTIONELEMENT_IID) static nsIID nsIDOMHTMLTableSectionElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLTableSectionElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAlign(nsAString & aAlign) nsEmbedString moz_dom_GetAlign (htmltablesectionelement) nsIDOMHTMLTableSectionElement *htmltablesectionelement; PREINIT: nsEmbedString align; CODE: htmltablesectionelement->GetAlign(align); RETVAL = align; OUTPUT: RETVAL ## SetAlign(const nsAString & aAlign) void moz_dom_SetAlign (htmltablesectionelement, align) nsIDOMHTMLTableSectionElement *htmltablesectionelement; nsEmbedString align; CODE: htmltablesectionelement->SetAlign(align); ## GetCh(nsAString & aCh) nsEmbedString moz_dom_GetCh (htmltablesectionelement) nsIDOMHTMLTableSectionElement *htmltablesectionelement; PREINIT: nsEmbedString ch; CODE: htmltablesectionelement->GetCh(ch); RETVAL = ch; OUTPUT: RETVAL ## SetCh(const nsAString & aCh) void moz_dom_SetCh (htmltablesectionelement, ch) nsIDOMHTMLTableSectionElement *htmltablesectionelement; nsEmbedString ch; CODE: htmltablesectionelement->SetCh(ch); ## GetChOff(nsAString & aChOff) nsEmbedString moz_dom_GetChOff (htmltablesectionelement) nsIDOMHTMLTableSectionElement *htmltablesectionelement; PREINIT: nsEmbedString choff; CODE: htmltablesectionelement->GetChOff(choff); RETVAL = choff; OUTPUT: RETVAL ## SetChOff(const nsAString & aChOff) void moz_dom_SetChOff (htmltablesectionelement, choff) nsIDOMHTMLTableSectionElement *htmltablesectionelement; nsEmbedString choff; CODE: htmltablesectionelement->SetChOff(choff); ## GetVAlign(nsAString & aVAlign) nsEmbedString moz_dom_GetVAlign (htmltablesectionelement) nsIDOMHTMLTableSectionElement *htmltablesectionelement; PREINIT: nsEmbedString valign; CODE: htmltablesectionelement->GetVAlign(valign); RETVAL = valign; OUTPUT: RETVAL ## SetVAlign(const nsAString & aVAlign) void moz_dom_SetVAlign (htmltablesectionelement, valign) nsIDOMHTMLTableSectionElement *htmltablesectionelement; nsEmbedString valign; CODE: htmltablesectionelement->SetVAlign(valign); ## GetRows(nsIDOMHTMLCollection * *aRows) nsIDOMHTMLCollection * moz_dom_GetRows_htmlcollection (htmltablesectionelement) nsIDOMHTMLTableSectionElement *htmltablesectionelement; PREINIT: nsIDOMHTMLCollection * rows; CODE: htmltablesectionelement->GetRows(&rows); RETVAL = rows; OUTPUT: RETVAL ## InsertRow(PRInt32 index, nsIDOMHTMLElement **_retval) nsIDOMHTMLElement * moz_dom_InsertRow (htmltablesectionelement, index) nsIDOMHTMLTableSectionElement *htmltablesectionelement; PRInt32 index; PREINIT: nsIDOMHTMLElement * retval; CODE: htmltablesectionelement->InsertRow(index, &retval); RETVAL = retval; OUTPUT: RETVAL ## DeleteRow(PRInt32 index) void moz_dom_DeleteRow (htmltablesectionelement, index) nsIDOMHTMLTableSectionElement *htmltablesectionelement; PRInt32 index; CODE: htmltablesectionelement->DeleteRow(index); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLTextAreaElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLTextAreaElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLTEXTAREAELEMENT_IID) static nsIID nsIDOMHTMLTextAreaElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLTextAreaElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetDefaultValue(nsAString & aDefaultValue) nsEmbedString moz_dom_GetDefaultValue (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: nsEmbedString defaultvalue; CODE: htmltextareaelement->GetDefaultValue(defaultvalue); RETVAL = defaultvalue; OUTPUT: RETVAL ## SetDefaultValue(const nsAString & aDefaultValue) void moz_dom_SetDefaultValue (htmltextareaelement, defaultvalue) nsIDOMHTMLTextAreaElement *htmltextareaelement; nsEmbedString defaultvalue; CODE: htmltextareaelement->SetDefaultValue(defaultvalue); ## GetForm(nsIDOMHTMLFormElement * *aForm) nsIDOMHTMLFormElement * moz_dom_GetForm (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: nsIDOMHTMLFormElement * form; CODE: htmltextareaelement->GetForm(&form); RETVAL = form; OUTPUT: RETVAL ## GetAccessKey(nsAString & aAccessKey) nsEmbedString moz_dom_GetAccessKey (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: nsEmbedString accesskey; CODE: htmltextareaelement->GetAccessKey(accesskey); RETVAL = accesskey; OUTPUT: RETVAL ## SetAccessKey(const nsAString & aAccessKey) void moz_dom_SetAccessKey (htmltextareaelement, accesskey) nsIDOMHTMLTextAreaElement *htmltextareaelement; nsEmbedString accesskey; CODE: htmltextareaelement->SetAccessKey(accesskey); ## GetCols(PRInt32 *aCols) PRInt32 moz_dom_GetCols (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: PRInt32 cols; CODE: htmltextareaelement->GetCols(&cols); RETVAL = cols; OUTPUT: RETVAL ## SetCols(PRInt32 aCols) void moz_dom_SetCols (htmltextareaelement, cols) nsIDOMHTMLTextAreaElement *htmltextareaelement; PRInt32 cols; CODE: htmltextareaelement->SetCols(cols); ## GetDisabled(PRBool *aDisabled) PRBool moz_dom_GetDisabled (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: PRBool disabled; CODE: htmltextareaelement->GetDisabled(&disabled); RETVAL = disabled; OUTPUT: RETVAL ## SetDisabled(PRBool aDisabled) void moz_dom_SetDisabled (htmltextareaelement, disabled) nsIDOMHTMLTextAreaElement *htmltextareaelement; PRBool disabled; CODE: htmltextareaelement->SetDisabled(disabled); ## GetName(nsAString & aName) nsEmbedString moz_dom_GetName (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: nsEmbedString name; CODE: htmltextareaelement->GetName(name); RETVAL = name; OUTPUT: RETVAL ## SetName(const nsAString & aName) void moz_dom_SetName (htmltextareaelement, name) nsIDOMHTMLTextAreaElement *htmltextareaelement; nsEmbedString name; CODE: htmltextareaelement->SetName(name); ## GetReadOnly(PRBool *aReadOnly) PRBool moz_dom_GetReadOnly (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: PRBool readonly; CODE: htmltextareaelement->GetReadOnly(&readonly); RETVAL = readonly; OUTPUT: RETVAL ## SetReadOnly(PRBool aReadOnly) void moz_dom_SetReadOnly (htmltextareaelement, readonly) nsIDOMHTMLTextAreaElement *htmltextareaelement; PRBool readonly; CODE: htmltextareaelement->SetReadOnly(readonly); ## GetRows(PRInt32 *aRows) PRInt32 moz_dom_GetRows (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: PRInt32 rows; CODE: htmltextareaelement->GetRows(&rows); RETVAL = rows; OUTPUT: RETVAL ## SetRows(PRInt32 aRows) void moz_dom_SetRows (htmltextareaelement, rows) nsIDOMHTMLTextAreaElement *htmltextareaelement; PRInt32 rows; CODE: htmltextareaelement->SetRows(rows); ## GetTabIndex(PRInt32 *aTabIndex) PRInt32 moz_dom_GetTabIndex (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: PRInt32 tabindex; CODE: htmltextareaelement->GetTabIndex(&tabindex); RETVAL = tabindex; OUTPUT: RETVAL ## SetTabIndex(PRInt32 aTabIndex) void moz_dom_SetTabIndex (htmltextareaelement, tabindex) nsIDOMHTMLTextAreaElement *htmltextareaelement; PRInt32 tabindex; CODE: htmltextareaelement->SetTabIndex(tabindex); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: nsEmbedString type; CODE: htmltextareaelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## GetValue(nsAString & aValue) nsEmbedString moz_dom_GetValue (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; PREINIT: nsEmbedString value; CODE: htmltextareaelement->GetValue(value); RETVAL = value; OUTPUT: RETVAL ## SetValue(const nsAString & aValue) void moz_dom_SetValue (htmltextareaelement, value) nsIDOMHTMLTextAreaElement *htmltextareaelement; nsEmbedString value; CODE: htmltextareaelement->SetValue(value); ## Blur(void) void moz_dom_Blur (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; CODE: htmltextareaelement->Blur(); ## Focus(void) void moz_dom_Focus (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; CODE: htmltextareaelement->Focus(); ## Select(void) void moz_dom_Select (htmltextareaelement) nsIDOMHTMLTextAreaElement *htmltextareaelement; CODE: htmltextareaelement->Select(); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLTitleElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLTitleElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLTITLEELEMENT_IID) static nsIID nsIDOMHTMLTitleElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLTitleElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetText(nsAString & aText) nsEmbedString moz_dom_GetText (htmltitleelement) nsIDOMHTMLTitleElement *htmltitleelement; PREINIT: nsEmbedString text; CODE: htmltitleelement->GetText(text); RETVAL = text; OUTPUT: RETVAL ## SetText(const nsAString & aText) void moz_dom_SetText (htmltitleelement, text) nsIDOMHTMLTitleElement *htmltitleelement; nsEmbedString text; CODE: htmltitleelement->SetText(text); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::HTMLUListElement PREFIX = moz_dom_ # /usr/include/mozilla/nsIDOMHTMLUListElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHTMLULISTELEMENT_IID) static nsIID nsIDOMHTMLUListElement::GetIID() CODE: const nsIID &id = nsIDOMHTMLUListElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetCompact(PRBool *aCompact) PRBool moz_dom_GetCompact (htmlulistelement) nsIDOMHTMLUListElement *htmlulistelement; PREINIT: PRBool compact; CODE: htmlulistelement->GetCompact(&compact); RETVAL = compact; OUTPUT: RETVAL ## SetCompact(PRBool aCompact) void moz_dom_SetCompact (htmlulistelement, compact) nsIDOMHTMLUListElement *htmlulistelement; PRBool compact; CODE: htmlulistelement->SetCompact(compact); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (htmlulistelement) nsIDOMHTMLUListElement *htmlulistelement; PREINIT: nsEmbedString type; CODE: htmlulistelement->GetType(type); RETVAL = type; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (htmlulistelement, type) nsIDOMHTMLUListElement *htmlulistelement; nsEmbedString type; CODE: htmlulistelement->SetType(type); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLAnchorElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLAnchorElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLANCHORELEMENT_IID) static nsIID nsIDOMNSHTMLAnchorElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLAnchorElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetProtocol(nsAString & aProtocol) nsEmbedString moz_dom_GetProtocol (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString aProtocol; CODE: nshtmlanchorelement->GetProtocol(aProtocol); RETVAL = aProtocol; OUTPUT: RETVAL ## SetProtocol(const nsAString & aProtocol) void moz_dom_SetProtocol (nshtmlanchorelement, aProtocol) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; nsEmbedString aProtocol; CODE: nshtmlanchorelement->SetProtocol(aProtocol); ## GetHost(nsAString & aHost) nsEmbedString moz_dom_GetHost (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString aHost; CODE: nshtmlanchorelement->GetHost(aHost); RETVAL = aHost; OUTPUT: RETVAL ## SetHost(const nsAString & aHost) void moz_dom_SetHost (nshtmlanchorelement, aHost) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; nsEmbedString aHost; CODE: nshtmlanchorelement->SetHost(aHost); ## GetHostname(nsAString & aHostname) nsEmbedString moz_dom_GetHostname (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString aHostname; CODE: nshtmlanchorelement->GetHostname(aHostname); RETVAL = aHostname; OUTPUT: RETVAL ## SetHostname(const nsAString & aHostname) void moz_dom_SetHostname (nshtmlanchorelement, aHostname) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; nsEmbedString aHostname; CODE: nshtmlanchorelement->SetHostname(aHostname); ## GetPathname(nsAString & aPathname) nsEmbedString moz_dom_GetPathname (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString aPathname; CODE: nshtmlanchorelement->GetPathname(aPathname); RETVAL = aPathname; OUTPUT: RETVAL ## SetPathname(const nsAString & aPathname) void moz_dom_SetPathname (nshtmlanchorelement, aPathname) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; nsEmbedString aPathname; CODE: nshtmlanchorelement->SetPathname(aPathname); ## GetSearch(nsAString & aSearch) nsEmbedString moz_dom_GetSearch (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString aSearch; CODE: nshtmlanchorelement->GetSearch(aSearch); RETVAL = aSearch; OUTPUT: RETVAL ## SetSearch(const nsAString & aSearch) void moz_dom_SetSearch (nshtmlanchorelement, aSearch) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; nsEmbedString aSearch; CODE: nshtmlanchorelement->SetSearch(aSearch); ## GetPort(nsAString & aPort) nsEmbedString moz_dom_GetPort (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString aPort; CODE: nshtmlanchorelement->GetPort(aPort); RETVAL = aPort; OUTPUT: RETVAL ## SetPort(const nsAString & aPort) void moz_dom_SetPort (nshtmlanchorelement, aPort) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; nsEmbedString aPort; CODE: nshtmlanchorelement->SetPort(aPort); ## GetHash(nsAString & aHash) nsEmbedString moz_dom_GetHash (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString aHash; CODE: nshtmlanchorelement->GetHash(aHash); RETVAL = aHash; OUTPUT: RETVAL ## SetHash(const nsAString & aHash) void moz_dom_SetHash (nshtmlanchorelement, aHash) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; nsEmbedString aHash; CODE: nshtmlanchorelement->SetHash(aHash); ## GetText(nsAString & aText) nsEmbedString moz_dom_GetText (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString aText; CODE: nshtmlanchorelement->GetText(aText); RETVAL = aText; OUTPUT: RETVAL ## ToString(nsAString & _retval) nsEmbedString moz_dom_ToString (nshtmlanchorelement) nsIDOMNSHTMLAnchorElement *nshtmlanchorelement; PREINIT: nsEmbedString _retval; CODE: nshtmlanchorelement->ToString(_retval); RETVAL = _retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLAreaElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLAreaElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLAREAELEMENT_IID) static nsIID nsIDOMNSHTMLAreaElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLAreaElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetProtocol(nsAString & aProtocol) nsEmbedString moz_dom_GetProtocol (nshtmlareaelement) nsIDOMNSHTMLAreaElement *nshtmlareaelement; PREINIT: nsEmbedString aProtocol; CODE: nshtmlareaelement->GetProtocol(aProtocol); RETVAL = aProtocol; OUTPUT: RETVAL ## SetProtocol(const nsAString & aProtocol) void moz_dom_SetProtocol (nshtmlareaelement, aProtocol) nsIDOMNSHTMLAreaElement *nshtmlareaelement; nsEmbedString aProtocol; CODE: nshtmlareaelement->SetProtocol(aProtocol); ## GetHost(nsAString & aHost) nsEmbedString moz_dom_GetHost (nshtmlareaelement) nsIDOMNSHTMLAreaElement *nshtmlareaelement; PREINIT: nsEmbedString aHost; CODE: nshtmlareaelement->GetHost(aHost); RETVAL = aHost; OUTPUT: RETVAL ## SetHost(const nsAString & aHost) void moz_dom_SetHost (nshtmlareaelement, aHost) nsIDOMNSHTMLAreaElement *nshtmlareaelement; nsEmbedString aHost; CODE: nshtmlareaelement->SetHost(aHost); ## GetHostname(nsAString & aHostname) nsEmbedString moz_dom_GetHostname (nshtmlareaelement) nsIDOMNSHTMLAreaElement *nshtmlareaelement; PREINIT: nsEmbedString aHostname; CODE: nshtmlareaelement->GetHostname(aHostname); RETVAL = aHostname; OUTPUT: RETVAL ## SetHostname(const nsAString & aHostname) void moz_dom_SetHostname (nshtmlareaelement, aHostname) nsIDOMNSHTMLAreaElement *nshtmlareaelement; nsEmbedString aHostname; CODE: nshtmlareaelement->SetHostname(aHostname); ## GetPathname(nsAString & aPathname) nsEmbedString moz_dom_GetPathname (nshtmlareaelement) nsIDOMNSHTMLAreaElement *nshtmlareaelement; PREINIT: nsEmbedString aPathname; CODE: nshtmlareaelement->GetPathname(aPathname); RETVAL = aPathname; OUTPUT: RETVAL ## SetPathname(const nsAString & aPathname) void moz_dom_SetPathname (nshtmlareaelement, aPathname) nsIDOMNSHTMLAreaElement *nshtmlareaelement; nsEmbedString aPathname; CODE: nshtmlareaelement->SetPathname(aPathname); ## GetSearch(nsAString & aSearch) nsEmbedString moz_dom_GetSearch (nshtmlareaelement) nsIDOMNSHTMLAreaElement *nshtmlareaelement; PREINIT: nsEmbedString aSearch; CODE: nshtmlareaelement->GetSearch(aSearch); RETVAL = aSearch; OUTPUT: RETVAL ## SetSearch(const nsAString & aSearch) void moz_dom_SetSearch (nshtmlareaelement, aSearch) nsIDOMNSHTMLAreaElement *nshtmlareaelement; nsEmbedString aSearch; CODE: nshtmlareaelement->SetSearch(aSearch); ## GetPort(nsAString & aPort) nsEmbedString moz_dom_GetPort (nshtmlareaelement) nsIDOMNSHTMLAreaElement *nshtmlareaelement; PREINIT: nsEmbedString aPort; CODE: nshtmlareaelement->GetPort(aPort); RETVAL = aPort; OUTPUT: RETVAL ## SetPort(const nsAString & aPort) void moz_dom_SetPort (nshtmlareaelement, aPort) nsIDOMNSHTMLAreaElement *nshtmlareaelement; nsEmbedString aPort; CODE: nshtmlareaelement->SetPort(aPort); ## GetHash(nsAString & aHash) nsEmbedString moz_dom_GetHash (nshtmlareaelement) nsIDOMNSHTMLAreaElement *nshtmlareaelement; PREINIT: nsEmbedString aHash; CODE: nshtmlareaelement->GetHash(aHash); RETVAL = aHash; OUTPUT: RETVAL ## SetHash(const nsAString & aHash) void moz_dom_SetHash (nshtmlareaelement, aHash) nsIDOMNSHTMLAreaElement *nshtmlareaelement; nsEmbedString aHash; CODE: nshtmlareaelement->SetHash(aHash); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLButtonElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLButtonElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLBUTTONELEMENT_IID) static nsIID nsIDOMNSHTMLButtonElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLButtonElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## Blur(void) void moz_dom_Blur (nshtmlbuttonelement) nsIDOMNSHTMLButtonElement *nshtmlbuttonelement; CODE: nshtmlbuttonelement->Blur(); ## Focus(void) void moz_dom_Focus (nshtmlbuttonelement) nsIDOMNSHTMLButtonElement *nshtmlbuttonelement; CODE: nshtmlbuttonelement->Focus(); ## Click(void) void moz_dom_Click (nshtmlbuttonelement) nsIDOMNSHTMLButtonElement *nshtmlbuttonelement; CODE: nshtmlbuttonelement->Click(); ## GetType(nsAString & aType) nsEmbedString moz_dom_GetType (nshtmlbuttonelement) nsIDOMNSHTMLButtonElement *nshtmlbuttonelement; PREINIT: nsEmbedString aType; CODE: nshtmlbuttonelement->GetType(aType); RETVAL = aType; OUTPUT: RETVAL ## SetType(const nsAString & aType) void moz_dom_SetType (nshtmlbuttonelement, aType) nsIDOMNSHTMLButtonElement *nshtmlbuttonelement; nsEmbedString aType; CODE: nshtmlbuttonelement->SetType(aType); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLDocument PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLDocument.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLDOCUMENT_IID) static nsIID nsIDOMNSHTMLDocument::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLDocument::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetWidth(PRInt32 *aWidth) PRInt32 moz_dom_GetWidth (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: PRInt32 aWidth; CODE: nshtmldocument->GetWidth(&aWidth); RETVAL = aWidth; OUTPUT: RETVAL ## GetHeight(PRInt32 *aHeight) PRInt32 moz_dom_GetHeight (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: PRInt32 aHeight; CODE: nshtmldocument->GetHeight(&aHeight); RETVAL = aHeight; OUTPUT: RETVAL ## GetAlinkColor(nsAString & aAlinkColor) nsEmbedString moz_dom_GetAlinkColor (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString aAlinkColor; CODE: nshtmldocument->GetAlinkColor(aAlinkColor); RETVAL = aAlinkColor; OUTPUT: RETVAL ## SetAlinkColor(const nsAString & aAlinkColor) void moz_dom_SetAlinkColor (nshtmldocument, aAlinkColor) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString aAlinkColor; CODE: nshtmldocument->SetAlinkColor(aAlinkColor); ## GetLinkColor(nsAString & aLinkColor) nsEmbedString moz_dom_GetLinkColor (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString aLinkColor; CODE: nshtmldocument->GetLinkColor(aLinkColor); RETVAL = aLinkColor; OUTPUT: RETVAL ## SetLinkColor(const nsAString & aLinkColor) void moz_dom_SetLinkColor (nshtmldocument, aLinkColor) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString aLinkColor; CODE: nshtmldocument->SetLinkColor(aLinkColor); ## GetVlinkColor(nsAString & aVlinkColor) nsEmbedString moz_dom_GetVlinkColor (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString aVlinkColor; CODE: nshtmldocument->GetVlinkColor(aVlinkColor); RETVAL = aVlinkColor; OUTPUT: RETVAL ## SetVlinkColor(const nsAString & aVlinkColor) void moz_dom_SetVlinkColor (nshtmldocument, aVlinkColor) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString aVlinkColor; CODE: nshtmldocument->SetVlinkColor(aVlinkColor); ## GetBgColor(nsAString & aBgColor) nsEmbedString moz_dom_GetBgColor (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString aBgColor; CODE: nshtmldocument->GetBgColor(aBgColor); RETVAL = aBgColor; OUTPUT: RETVAL ## SetBgColor(const nsAString & aBgColor) void moz_dom_SetBgColor (nshtmldocument, aBgColor) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString aBgColor; CODE: nshtmldocument->SetBgColor(aBgColor); ## GetFgColor(nsAString & aFgColor) nsEmbedString moz_dom_GetFgColor (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString aFgColor; CODE: nshtmldocument->GetFgColor(aFgColor); RETVAL = aFgColor; OUTPUT: RETVAL ## SetFgColor(const nsAString & aFgColor) void moz_dom_SetFgColor (nshtmldocument, aFgColor) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString aFgColor; CODE: nshtmldocument->SetFgColor(aFgColor); ## GetDomain(nsAString & aDomain) nsEmbedString moz_dom_GetDomain (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString aDomain; CODE: nshtmldocument->GetDomain(aDomain); RETVAL = aDomain; OUTPUT: RETVAL ## SetDomain(const nsAString & aDomain) void moz_dom_SetDomain (nshtmldocument, aDomain) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString aDomain; CODE: nshtmldocument->SetDomain(aDomain); ## GetEmbeds(nsIDOMHTMLCollection * *aEmbeds) nsIDOMHTMLCollection * moz_dom_GetEmbeds_htmlcollection (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsIDOMHTMLCollection * aEmbeds; CODE: nshtmldocument->GetEmbeds(&aEmbeds); RETVAL = aEmbeds; OUTPUT: RETVAL ## GetSelection(nsAString & _retval) nsEmbedString moz_dom_GetSelection (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString _retval; CODE: nshtmldocument->GetSelection(_retval); RETVAL = _retval; OUTPUT: RETVAL ## Open(nsIDOMDocument **_retval) ## was: moz_dom_Open (nshtmldocument), nshtmldocument->Open(&_retval); nsIDOMDocument * moz_dom_Open (nshtmldocument, nsEmbedCString & contentType , PRBool & replace) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsIDOMDocument * _retval; CODE: nshtmldocument->Open(contentType, replace, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## Write(void) void moz_dom_Write (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; CODE: nshtmldocument->Write(); ## Writeln(void) void moz_dom_Writeln (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; CODE: nshtmldocument->Writeln(); ## Clear(void) void moz_dom_Clear (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; CODE: nshtmldocument->Clear(); ## see https://developer.mozilla.org/en/Gecko_1.9_Changes_affecting_websites #ifdef NOT_SUPPORTED_ANYMORE ## CaptureEvents(PRInt32 eventFlags) void moz_dom_CaptureEvents (nshtmldocument, eventFlags) nsIDOMNSHTMLDocument *nshtmldocument; PRInt32 eventFlags; CODE: nshtmldocument->CaptureEvents(eventFlags); ## ReleaseEvents(PRInt32 eventFlags) void moz_dom_ReleaseEvents (nshtmldocument, eventFlags) nsIDOMNSHTMLDocument *nshtmldocument; PRInt32 eventFlags; CODE: nshtmldocument->ReleaseEvents(eventFlags); ## RouteEvent(nsIDOMEvent *evt) void moz_dom_RouteEvent (nshtmldocument, evt) nsIDOMNSHTMLDocument *nshtmldocument; nsIDOMEvent * evt; CODE: nshtmldocument->RouteEvent(evt); #endif ## GetCompatMode(nsAString & aCompatMode) nsEmbedString moz_dom_GetCompatMode (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString aCompatMode; CODE: nshtmldocument->GetCompatMode(aCompatMode); RETVAL = aCompatMode; OUTPUT: RETVAL ## GetPlugins(nsIDOMHTMLCollection * *aPlugins) nsIDOMHTMLCollection * moz_dom_GetPlugins_htmlcollection (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsIDOMHTMLCollection * aPlugins; CODE: nshtmldocument->GetPlugins(&aPlugins); RETVAL = aPlugins; OUTPUT: RETVAL ## GetDesignMode(nsAString & aDesignMode) nsEmbedString moz_dom_GetDesignMode (nshtmldocument) nsIDOMNSHTMLDocument *nshtmldocument; PREINIT: nsEmbedString aDesignMode; CODE: nshtmldocument->GetDesignMode(aDesignMode); RETVAL = aDesignMode; OUTPUT: RETVAL ## SetDesignMode(const nsAString & aDesignMode) void moz_dom_SetDesignMode (nshtmldocument, aDesignMode) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString aDesignMode; CODE: nshtmldocument->SetDesignMode(aDesignMode); ## ExecCommand(const nsAString & commandID, PRBool doShowUI, const nsAString & value, PRBool *_retval) PRBool moz_dom_ExecCommand (nshtmldocument, commandID, doShowUI, value) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString commandID; PRBool doShowUI; nsEmbedString value; PREINIT: PRBool _retval; CODE: nshtmldocument->ExecCommand(commandID, doShowUI, value, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## ExecCommandShowHelp(const nsAString & commandID, PRBool *_retval) PRBool moz_dom_ExecCommandShowHelp (nshtmldocument, commandID) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString commandID; PREINIT: PRBool _retval; CODE: nshtmldocument->ExecCommandShowHelp(commandID, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## QueryCommandEnabled(const nsAString & commandID, PRBool *_retval) PRBool moz_dom_QueryCommandEnabled (nshtmldocument, commandID) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString commandID; PREINIT: PRBool _retval; CODE: nshtmldocument->QueryCommandEnabled(commandID, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## QueryCommandIndeterm(const nsAString & commandID, PRBool *_retval) PRBool moz_dom_QueryCommandIndeterm (nshtmldocument, commandID) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString commandID; PREINIT: PRBool _retval; CODE: nshtmldocument->QueryCommandIndeterm(commandID, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## QueryCommandState(const nsAString & commandID, PRBool *_retval) PRBool moz_dom_QueryCommandState (nshtmldocument, commandID) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString commandID; PREINIT: PRBool _retval; CODE: nshtmldocument->QueryCommandState(commandID, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## QueryCommandSupported(const nsAString & commandID, PRBool *_retval) PRBool moz_dom_QueryCommandSupported (nshtmldocument, commandID) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString commandID; PREINIT: PRBool _retval; CODE: nshtmldocument->QueryCommandSupported(commandID, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## QueryCommandText(const nsAString & commandID, nsAString & _retval) nsEmbedString moz_dom_QueryCommandText (nshtmldocument, commandID) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString commandID; PREINIT: nsEmbedString _retval; CODE: nshtmldocument->QueryCommandText(commandID, _retval); RETVAL = _retval; OUTPUT: RETVAL ## QueryCommandValue(const nsAString & commandID, nsAString & _retval) nsEmbedString moz_dom_QueryCommandValue (nshtmldocument, commandID) nsIDOMNSHTMLDocument *nshtmldocument; nsEmbedString commandID; PREINIT: nsEmbedString _retval; CODE: nshtmldocument->QueryCommandValue(commandID, _retval); RETVAL = _retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLFormElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLFormElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLFORMELEMENT_IID) static nsIID nsIDOMNSHTMLFormElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLFormElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetEncoding(nsAString & aEncoding) nsEmbedString moz_dom_GetEncoding (nshtmlformelement) nsIDOMNSHTMLFormElement *nshtmlformelement; PREINIT: nsEmbedString aEncoding; CODE: nshtmlformelement->GetEncoding(aEncoding); RETVAL = aEncoding; OUTPUT: RETVAL ## SetEncoding(const nsAString & aEncoding) void moz_dom_SetEncoding (nshtmlformelement, aEncoding) nsIDOMNSHTMLFormElement *nshtmlformelement; nsEmbedString aEncoding; CODE: nshtmlformelement->SetEncoding(aEncoding); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLFrameElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLFrameElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLFRAMEELEMENT_IID) static nsIID nsIDOMNSHTMLFrameElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLFrameElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetContentWindow(nsIDOMWindow * *aContentWindow) nsIDOMWindow * moz_dom_GetContentWindow (nshtmlframeelement) nsIDOMNSHTMLFrameElement *nshtmlframeelement; PREINIT: nsIDOMWindow * aContentWindow; CODE: nshtmlframeelement->GetContentWindow(&aContentWindow); RETVAL = aContentWindow; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLHRElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLHRElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLHRELEMENT_IID) static nsIID nsIDOMNSHTMLHRElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLHRElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetColor(nsAString & aColor) nsEmbedString moz_dom_GetColor (nshtmlhrelement) nsIDOMNSHTMLHRElement *nshtmlhrelement; PREINIT: nsEmbedString aColor; CODE: nshtmlhrelement->GetColor(aColor); RETVAL = aColor; OUTPUT: RETVAL ## SetColor(const nsAString & aColor) void moz_dom_SetColor (nshtmlhrelement, aColor) nsIDOMNSHTMLHRElement *nshtmlhrelement; nsEmbedString aColor; CODE: nshtmlhrelement->SetColor(aColor); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLImageElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLImageElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLIMAGEELEMENT_IID) static nsIID nsIDOMNSHTMLImageElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLImageElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetLowsrc(nsAString & aLowsrc) nsEmbedString moz_dom_GetLowsrc (nshtmlimageelement) nsIDOMNSHTMLImageElement *nshtmlimageelement; PREINIT: nsEmbedString aLowsrc; CODE: nshtmlimageelement->GetLowsrc(aLowsrc); RETVAL = aLowsrc; OUTPUT: RETVAL ## SetLowsrc(const nsAString & aLowsrc) void moz_dom_SetLowsrc (nshtmlimageelement, aLowsrc) nsIDOMNSHTMLImageElement *nshtmlimageelement; nsEmbedString aLowsrc; CODE: nshtmlimageelement->SetLowsrc(aLowsrc); ## GetComplete(PRBool *aComplete) PRBool moz_dom_GetComplete (nshtmlimageelement) nsIDOMNSHTMLImageElement *nshtmlimageelement; PREINIT: PRBool aComplete; CODE: nshtmlimageelement->GetComplete(&aComplete); RETVAL = aComplete; OUTPUT: RETVAL ## GetNaturalHeight(PRInt32 *aNaturalHeight) PRInt32 moz_dom_GetNaturalHeight (nshtmlimageelement) nsIDOMNSHTMLImageElement *nshtmlimageelement; PREINIT: PRInt32 aNaturalHeight; CODE: nshtmlimageelement->GetNaturalHeight(&aNaturalHeight); RETVAL = aNaturalHeight; OUTPUT: RETVAL ## GetNaturalWidth(PRInt32 *aNaturalWidth) PRInt32 moz_dom_GetNaturalWidth (nshtmlimageelement) nsIDOMNSHTMLImageElement *nshtmlimageelement; PREINIT: PRInt32 aNaturalWidth; CODE: nshtmlimageelement->GetNaturalWidth(&aNaturalWidth); RETVAL = aNaturalWidth; OUTPUT: RETVAL ## GetX(PRInt32 *aX) PRInt32 moz_dom_GetX (nshtmlimageelement) nsIDOMNSHTMLImageElement *nshtmlimageelement; PREINIT: PRInt32 aX; CODE: nshtmlimageelement->GetX(&aX); RETVAL = aX; OUTPUT: RETVAL ## GetY(PRInt32 *aY) PRInt32 moz_dom_GetY (nshtmlimageelement) nsIDOMNSHTMLImageElement *nshtmlimageelement; PREINIT: PRInt32 aY; CODE: nshtmlimageelement->GetY(&aY); RETVAL = aY; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLInputElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLInputElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLINPUTELEMENT_IID) static nsIID nsIDOMNSHTMLInputElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLInputElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ### GetControllers(nsIControllers * *aControllers) #nsIControllers * #moz_dom_GetControllers (nshtmlinputelement) # nsIDOMNSHTMLInputElement *nshtmlinputelement; # PREINIT: # nsIControllers * aControllers; # CODE: # nshtmlinputelement->GetControllers(&aControllers); # RETVAL = aControllers; # OUTPUT: # RETVAL ## GetTextLength(PRInt32 *aTextLength) PRInt32 moz_dom_GetTextLength (nshtmlinputelement) nsIDOMNSHTMLInputElement *nshtmlinputelement; PREINIT: PRInt32 aTextLength; CODE: nshtmlinputelement->GetTextLength(&aTextLength); RETVAL = aTextLength; OUTPUT: RETVAL ## GetSelectionStart(PRInt32 *aSelectionStart) PRInt32 moz_dom_GetSelectionStart (nshtmlinputelement) nsIDOMNSHTMLInputElement *nshtmlinputelement; PREINIT: PRInt32 aSelectionStart; CODE: nshtmlinputelement->GetSelectionStart(&aSelectionStart); RETVAL = aSelectionStart; OUTPUT: RETVAL ## SetSelectionStart(PRInt32 aSelectionStart) void moz_dom_SetSelectionStart (nshtmlinputelement, aSelectionStart) nsIDOMNSHTMLInputElement *nshtmlinputelement; PRInt32 aSelectionStart; CODE: nshtmlinputelement->SetSelectionStart(aSelectionStart); ## GetSelectionEnd(PRInt32 *aSelectionEnd) PRInt32 moz_dom_GetSelectionEnd (nshtmlinputelement) nsIDOMNSHTMLInputElement *nshtmlinputelement; PREINIT: PRInt32 aSelectionEnd; CODE: nshtmlinputelement->GetSelectionEnd(&aSelectionEnd); RETVAL = aSelectionEnd; OUTPUT: RETVAL ## SetSelectionEnd(PRInt32 aSelectionEnd) void moz_dom_SetSelectionEnd (nshtmlinputelement, aSelectionEnd) nsIDOMNSHTMLInputElement *nshtmlinputelement; PRInt32 aSelectionEnd; CODE: nshtmlinputelement->SetSelectionEnd(aSelectionEnd); ## SetSelectionRange(PRInt32 selectionStart, PRInt32 selectionEnd) void moz_dom_SetSelectionRange (nshtmlinputelement, selectionStart, selectionEnd) nsIDOMNSHTMLInputElement *nshtmlinputelement; PRInt32 selectionStart; PRInt32 selectionEnd; CODE: nshtmlinputelement->SetSelectionRange(selectionStart, selectionEnd); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLOptionElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLOptionElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLOPTIONELEMENT_IID) static nsIID nsIDOMNSHTMLOptionElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLOptionElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetText(nsAString & aText) nsEmbedString moz_dom_GetText (nshtmloptionelement) nsIDOMNSHTMLOptionElement *nshtmloptionelement; PREINIT: nsEmbedString aText; CODE: nshtmloptionelement->GetText(aText); RETVAL = aText; OUTPUT: RETVAL ## SetText(const nsAString & aText) void moz_dom_SetText (nshtmloptionelement, aText) nsIDOMNSHTMLOptionElement *nshtmloptionelement; nsEmbedString aText; CODE: nshtmloptionelement->SetText(aText); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLSelectElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLSelectElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLSELECTELEMENT_IID) static nsIID nsIDOMNSHTMLSelectElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLSelectElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## Item(PRUint32 index, nsIDOMNode **_retval) nsIDOMNode * moz_dom_Item (nshtmlselectelement, index) nsIDOMNSHTMLSelectElement *nshtmlselectelement; PRUint32 index; PREINIT: nsIDOMNode * _retval; CODE: nshtmlselectelement->Item(index, &_retval); RETVAL = _retval; OUTPUT: RETVAL ## NamedItem(const nsAString & name, nsIDOMNode **_retval) nsIDOMNode * moz_dom_NamedItem (nshtmlselectelement, name) nsIDOMNSHTMLSelectElement *nshtmlselectelement; nsEmbedString name; PREINIT: nsIDOMNode * _retval; CODE: nshtmlselectelement->NamedItem(name, &_retval); RETVAL = _retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::NSHTMLTextAreaElement PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNSHTMLTextAreaElement.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNSHTMLTEXTAREAELEMENT_IID) static nsIID nsIDOMNSHTMLTextAreaElement::GetIID() CODE: const nsIID &id = nsIDOMNSHTMLTextAreaElement::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ### GetControllers(nsIControllers * *aControllers) #nsIControllers * #moz_dom_GetControllers (nshtmltextareaelement) # nsIDOMNSHTMLTextAreaElement *nshtmltextareaelement; # PREINIT: # nsIControllers * aControllers; # CODE: # nshtmltextareaelement->GetControllers(&aControllers); # RETVAL = aControllers; # OUTPUT: # RETVAL ## GetTextLength(PRInt32 *aTextLength) PRInt32 moz_dom_GetTextLength (nshtmltextareaelement) nsIDOMNSHTMLTextAreaElement *nshtmltextareaelement; PREINIT: PRInt32 aTextLength; CODE: nshtmltextareaelement->GetTextLength(&aTextLength); RETVAL = aTextLength; OUTPUT: RETVAL ## GetSelectionStart(PRInt32 *aSelectionStart) PRInt32 moz_dom_GetSelectionStart (nshtmltextareaelement) nsIDOMNSHTMLTextAreaElement *nshtmltextareaelement; PREINIT: PRInt32 aSelectionStart; CODE: nshtmltextareaelement->GetSelectionStart(&aSelectionStart); RETVAL = aSelectionStart; OUTPUT: RETVAL ## SetSelectionStart(PRInt32 aSelectionStart) void moz_dom_SetSelectionStart (nshtmltextareaelement, aSelectionStart) nsIDOMNSHTMLTextAreaElement *nshtmltextareaelement; PRInt32 aSelectionStart; CODE: nshtmltextareaelement->SetSelectionStart(aSelectionStart); ## GetSelectionEnd(PRInt32 *aSelectionEnd) PRInt32 moz_dom_GetSelectionEnd (nshtmltextareaelement) nsIDOMNSHTMLTextAreaElement *nshtmltextareaelement; PREINIT: PRInt32 aSelectionEnd; CODE: nshtmltextareaelement->GetSelectionEnd(&aSelectionEnd); RETVAL = aSelectionEnd; OUTPUT: RETVAL ## SetSelectionEnd(PRInt32 aSelectionEnd) void moz_dom_SetSelectionEnd (nshtmltextareaelement, aSelectionEnd) nsIDOMNSHTMLTextAreaElement *nshtmltextareaelement; PRInt32 aSelectionEnd; CODE: nshtmltextareaelement->SetSelectionEnd(aSelectionEnd); ## SetSelectionRange(PRInt32 selectionStart, PRInt32 selectionEnd) void moz_dom_SetSelectionRange (nshtmltextareaelement, selectionStart, selectionEnd) nsIDOMNSHTMLTextAreaElement *nshtmltextareaelement; PRInt32 selectionStart; PRInt32 selectionEnd; CODE: nshtmltextareaelement->SetSelectionRange(selectionStart, selectionEnd); # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Navigator PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMNavigator.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMNAVIGATOR_IID) static nsIID nsIDOMNavigator::GetIID() CODE: const nsIID &id = nsIDOMNavigator::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetAppCodeName(nsAString & aAppCodeName) nsEmbedString moz_dom_GetAppCodeName (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aAppCodeName; CODE: navigator->GetAppCodeName(aAppCodeName); RETVAL = aAppCodeName; OUTPUT: RETVAL ## GetAppName(nsAString & aAppName) nsEmbedString moz_dom_GetAppName (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aAppName; CODE: navigator->GetAppName(aAppName); RETVAL = aAppName; OUTPUT: RETVAL ## GetAppVersion(nsAString & aAppVersion) nsEmbedString moz_dom_GetAppVersion (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aAppVersion; CODE: navigator->GetAppVersion(aAppVersion); RETVAL = aAppVersion; OUTPUT: RETVAL ## GetLanguage(nsAString & aLanguage) nsEmbedString moz_dom_GetLanguage (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aLanguage; CODE: navigator->GetLanguage(aLanguage); RETVAL = aLanguage; OUTPUT: RETVAL ### GetMimeTypes(nsIDOMMimeTypeArray * *aMimeTypes) #nsIDOMMimeTypeArray * #moz_dom_GetMimeTypes (navigator) # nsIDOMNavigator *navigator; # PREINIT: # nsIDOMMimeTypeArray * aMimeTypes; # CODE: # navigator->GetMimeTypes(&aMimeTypes); # RETVAL = aMimeTypes; # OUTPUT: # RETVAL ## GetPlatform(nsAString & aPlatform) nsEmbedString moz_dom_GetPlatform (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aPlatform; CODE: navigator->GetPlatform(aPlatform); RETVAL = aPlatform; OUTPUT: RETVAL ## GetOscpu(nsAString & aOscpu) nsEmbedString moz_dom_GetOscpu (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aOscpu; CODE: navigator->GetOscpu(aOscpu); RETVAL = aOscpu; OUTPUT: RETVAL ## GetVendor(nsAString & aVendor) nsEmbedString moz_dom_GetVendor (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aVendor; CODE: navigator->GetVendor(aVendor); RETVAL = aVendor; OUTPUT: RETVAL ## GetVendorSub(nsAString & aVendorSub) nsEmbedString moz_dom_GetVendorSub (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aVendorSub; CODE: navigator->GetVendorSub(aVendorSub); RETVAL = aVendorSub; OUTPUT: RETVAL ## GetProduct(nsAString & aProduct) nsEmbedString moz_dom_GetProduct (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aProduct; CODE: navigator->GetProduct(aProduct); RETVAL = aProduct; OUTPUT: RETVAL ## GetProductSub(nsAString & aProductSub) nsEmbedString moz_dom_GetProductSub (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aProductSub; CODE: navigator->GetProductSub(aProductSub); RETVAL = aProductSub; OUTPUT: RETVAL ### GetPlugins(nsIDOMPluginArray * *aPlugins) #nsIDOMPluginArray * #moz_dom_GetPlugins (navigator) # nsIDOMNavigator *navigator; # PREINIT: # nsIDOMPluginArray * aPlugins; # CODE: # navigator->GetPlugins(&aPlugins); # RETVAL = aPlugins; # OUTPUT: # RETVAL ## GetSecurityPolicy(nsAString & aSecurityPolicy) nsEmbedString moz_dom_GetSecurityPolicy (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aSecurityPolicy; CODE: navigator->GetSecurityPolicy(aSecurityPolicy); RETVAL = aSecurityPolicy; OUTPUT: RETVAL ## GetUserAgent(nsAString & aUserAgent) nsEmbedString moz_dom_GetUserAgent (navigator) nsIDOMNavigator *navigator; PREINIT: nsEmbedString aUserAgent; CODE: navigator->GetUserAgent(aUserAgent); RETVAL = aUserAgent; OUTPUT: RETVAL ## GetCookieEnabled(PRBool *aCookieEnabled) PRBool moz_dom_GetCookieEnabled (navigator) nsIDOMNavigator *navigator; PREINIT: PRBool aCookieEnabled; CODE: navigator->GetCookieEnabled(&aCookieEnabled); RETVAL = aCookieEnabled; OUTPUT: RETVAL ## JavaEnabled(PRBool *_retval) PRBool moz_dom_JavaEnabled (navigator) nsIDOMNavigator *navigator; PREINIT: PRBool _retval; CODE: navigator->JavaEnabled(&_retval); RETVAL = _retval; OUTPUT: RETVAL ## TaintEnabled(PRBool *_retval) PRBool moz_dom_TaintEnabled (navigator) nsIDOMNavigator *navigator; PREINIT: PRBool _retval; CODE: navigator->TaintEnabled(&_retval); RETVAL = _retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::History PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMHistory.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMHISTORY_IID) static nsIID nsIDOMHistory::GetIID() CODE: const nsIID &id = nsIDOMHistory::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetLength(PRInt32 *aLength) PRInt32 moz_dom_GetLength (history) nsIDOMHistory *history; PREINIT: PRInt32 aLength; CODE: history->GetLength(&aLength); RETVAL = aLength; OUTPUT: RETVAL ## GetCurrent(nsAString & aCurrent) nsEmbedString moz_dom_GetCurrent (history) nsIDOMHistory *history; PREINIT: nsEmbedString aCurrent; CODE: history->GetCurrent(aCurrent); RETVAL = aCurrent; OUTPUT: RETVAL ## GetPrevious(nsAString & aPrevious) nsEmbedString moz_dom_GetPrevious (history) nsIDOMHistory *history; PREINIT: nsEmbedString aPrevious; CODE: history->GetPrevious(aPrevious); RETVAL = aPrevious; OUTPUT: RETVAL ## GetNext(nsAString & aNext) nsEmbedString moz_dom_GetNext (history) nsIDOMHistory *history; PREINIT: nsEmbedString aNext; CODE: history->GetNext(aNext); RETVAL = aNext; OUTPUT: RETVAL ## Back(void) void moz_dom_Back (history) nsIDOMHistory *history; CODE: history->Back(); ## Forward(void) void moz_dom_Forward (history) nsIDOMHistory *history; CODE: history->Forward(); ## Go(PRInt32 aDelta) void moz_dom_Go (history, aDelta) nsIDOMHistory *history; PRInt32 aDelta; CODE: history->Go(aDelta); ## Item(PRUint32 index, nsAString & _retval) nsEmbedString moz_dom_Item (history, index) nsIDOMHistory *history; PRUint32 index; PREINIT: nsEmbedString _retval; CODE: history->Item(index, _retval); RETVAL = _retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Location PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMLocation.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMLOCATION_IID) static nsIID nsIDOMLocation::GetIID() CODE: const nsIID &id = nsIDOMLocation::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetHash(nsAString & aHash) nsEmbedString moz_dom_GetHash (location) nsIDOMLocation *location; PREINIT: nsEmbedString aHash; CODE: location->GetHash(aHash); RETVAL = aHash; OUTPUT: RETVAL ## SetHash(const nsAString & aHash) void moz_dom_SetHash (location, aHash) nsIDOMLocation *location; nsEmbedString aHash; CODE: location->SetHash(aHash); ## GetHost(nsAString & aHost) nsEmbedString moz_dom_GetHost (location) nsIDOMLocation *location; PREINIT: nsEmbedString aHost; CODE: location->GetHost(aHost); RETVAL = aHost; OUTPUT: RETVAL ## SetHost(const nsAString & aHost) void moz_dom_SetHost (location, aHost) nsIDOMLocation *location; nsEmbedString aHost; CODE: location->SetHost(aHost); ## GetHostname(nsAString & aHostname) nsEmbedString moz_dom_GetHostname (location) nsIDOMLocation *location; PREINIT: nsEmbedString aHostname; CODE: location->GetHostname(aHostname); RETVAL = aHostname; OUTPUT: RETVAL ## SetHostname(const nsAString & aHostname) void moz_dom_SetHostname (location, aHostname) nsIDOMLocation *location; nsEmbedString aHostname; CODE: location->SetHostname(aHostname); ## GetHref(nsAString & aHref) nsEmbedString moz_dom_GetHref (location) nsIDOMLocation *location; PREINIT: nsEmbedString aHref; CODE: location->GetHref(aHref); RETVAL = aHref; OUTPUT: RETVAL ## SetHref(const nsAString & aHref) void moz_dom_SetHref (location, aHref) nsIDOMLocation *location; nsEmbedString aHref; CODE: location->SetHref(aHref); ## GetPathname(nsAString & aPathname) nsEmbedString moz_dom_GetPathname (location) nsIDOMLocation *location; PREINIT: nsEmbedString aPathname; CODE: location->GetPathname(aPathname); RETVAL = aPathname; OUTPUT: RETVAL ## SetPathname(const nsAString & aPathname) void moz_dom_SetPathname (location, aPathname) nsIDOMLocation *location; nsEmbedString aPathname; CODE: location->SetPathname(aPathname); ## GetPort(nsAString & aPort) nsEmbedString moz_dom_GetPort (location) nsIDOMLocation *location; PREINIT: nsEmbedString aPort; CODE: location->GetPort(aPort); RETVAL = aPort; OUTPUT: RETVAL ## SetPort(const nsAString & aPort) void moz_dom_SetPort (location, aPort) nsIDOMLocation *location; nsEmbedString aPort; CODE: location->SetPort(aPort); ## GetProtocol(nsAString & aProtocol) nsEmbedString moz_dom_GetProtocol (location) nsIDOMLocation *location; PREINIT: nsEmbedString aProtocol; CODE: location->GetProtocol(aProtocol); RETVAL = aProtocol; OUTPUT: RETVAL ## SetProtocol(const nsAString & aProtocol) void moz_dom_SetProtocol (location, aProtocol) nsIDOMLocation *location; nsEmbedString aProtocol; CODE: location->SetProtocol(aProtocol); ## GetSearch(nsAString & aSearch) nsEmbedString moz_dom_GetSearch (location) nsIDOMLocation *location; PREINIT: nsEmbedString aSearch; CODE: location->GetSearch(aSearch); RETVAL = aSearch; OUTPUT: RETVAL ## SetSearch(const nsAString & aSearch) void moz_dom_SetSearch (location, aSearch) nsIDOMLocation *location; nsEmbedString aSearch; CODE: location->SetSearch(aSearch); ## Reload(PRBool forceget) void moz_dom_Reload (location, forceget) nsIDOMLocation *location; PRBool forceget; CODE: location->Reload(forceget); ## Replace(const nsAString & url) void moz_dom_Replace (location, url) nsIDOMLocation *location; nsEmbedString url; CODE: location->Replace(url); ## Assign(const nsAString & url) void moz_dom_Assign (location, url) nsIDOMLocation *location; nsEmbedString url; CODE: location->Assign(url); ## ToString(nsAString & _retval) nsEmbedString moz_dom_ToString (location) nsIDOMLocation *location; PREINIT: nsEmbedString _retval; CODE: location->ToString(_retval); RETVAL = _retval; OUTPUT: RETVAL # ----------------------------------------------------------------------------- MODULE = Mozilla::DOM PACKAGE = Mozilla::DOM::Screen PREFIX = moz_dom_ # /usr/include/mozilla/dom/nsIDOMScreen.h ## NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSCREEN_IID) static nsIID nsIDOMScreen::GetIID() CODE: const nsIID &id = nsIDOMScreen::GetIID(); RETVAL = (nsIID) id; OUTPUT: RETVAL ## GetTop(PRInt32 *aTop) PRInt32 moz_dom_GetTop (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aTop; CODE: screen->GetTop(&aTop); RETVAL = aTop; OUTPUT: RETVAL ## GetLeft(PRInt32 *aLeft) PRInt32 moz_dom_GetLeft (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aLeft; CODE: screen->GetLeft(&aLeft); RETVAL = aLeft; OUTPUT: RETVAL ## GetWidth(PRInt32 *aWidth) PRInt32 moz_dom_GetWidth (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aWidth; CODE: screen->GetWidth(&aWidth); RETVAL = aWidth; OUTPUT: RETVAL ## GetHeight(PRInt32 *aHeight) PRInt32 moz_dom_GetHeight (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aHeight; CODE: screen->GetHeight(&aHeight); RETVAL = aHeight; OUTPUT: RETVAL ## GetPixelDepth(PRInt32 *aPixelDepth) PRInt32 moz_dom_GetPixelDepth (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aPixelDepth; CODE: screen->GetPixelDepth(&aPixelDepth); RETVAL = aPixelDepth; OUTPUT: RETVAL ## GetColorDepth(PRInt32 *aColorDepth) PRInt32 moz_dom_GetColorDepth (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aColorDepth; CODE: screen->GetColorDepth(&aColorDepth); RETVAL = aColorDepth; OUTPUT: RETVAL ## GetAvailWidth(PRInt32 *aAvailWidth) PRInt32 moz_dom_GetAvailWidth (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aAvailWidth; CODE: screen->GetAvailWidth(&aAvailWidth); RETVAL = aAvailWidth; OUTPUT: RETVAL ## GetAvailHeight(PRInt32 *aAvailHeight) PRInt32 moz_dom_GetAvailHeight (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aAvailHeight; CODE: screen->GetAvailHeight(&aAvailHeight); RETVAL = aAvailHeight; OUTPUT: RETVAL ## GetAvailLeft(PRInt32 *aAvailLeft) PRInt32 moz_dom_GetAvailLeft (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aAvailLeft; CODE: screen->GetAvailLeft(&aAvailLeft); RETVAL = aAvailLeft; OUTPUT: RETVAL ## GetAvailTop(PRInt32 *aAvailTop) PRInt32 moz_dom_GetAvailTop (screen) nsIDOMScreen *screen; PREINIT: PRInt32 aAvailTop; CODE: screen->GetAvailTop(&aAvailTop); RETVAL = aAvailTop; OUTPUT: RETVAL