The W3C DOM spec and corresponding M-Business DOM calls

The table below lists interfaces, attributes, and methods from the W3C DOM spec, along with the corresponding M-Business DOM (ADOM) synopsis for JavaScript and C. The table is in alphabetical order by W3C interface name. Within each interface, attributes and methods are listed in alphabetical order by the W3C keyword.

Note

The JavaScript synopsis column in this table does not attempt to be exhaustive in detailing different JavaScript usages; it merely provides an example of one of the more common JavaScript usages.

Table 1. W3C DOM spec and corresponding M-Business DOM calls

W3C DOM spec IDL definition

M-Business JavaScript synopsis

M-Business C synopsis

Attr interface

readonly attribute
  DOMString name;

attrobj.name

ADOMString 
 ADOMgetName(
 ADOMAttr* attrobj);

readonly attribute 
 boolean specified;

attrobj.specified

ADOMBoolean 
 ADOMgetSpecified(
 ADOMAttr* attrobj);

attribute DOMString
 value;

attrobj.value

attrobj.value = value

ADOMString ADOMgetValue(
 ADOMAttr* attrobj);

void ADOMsetValue(
 ADOMAttr* attrobj, 
 ADOMString value);

CharacterData interface

void appendData(
 in DOMString arg) 
 raises(
 DOMException);

chardataobj.appendData(
 arg)

void ADOMappendData(
 ADOMCharacterdata*
 chardataobj,
 ADOMString arg);

attribute DOMString 
 data;
 // raises(
 DOMException)
 on setting
 // raises(
 DOMException)
 on retrieval

chardataobj.data

chardataobj.data = data

ADOMString 
 ADOMgetData(
 ADOMCharacterdata*
 chardataobj);

void ADOMsetData(
 ADOMCharacterdata*
 chardataobj,
 ADOMString data);

void deleteData(
 in unsigned long
 offset, in 
 unsigned long
 count) raises(
 DOMException);

chardataobj.deleteData(
 offset, count)

void ADOMdeleteData(
 ADOMCharacterdata* 
 chardataobj,
 ADOMUInt32 offset,
 ADOMUInt32 count);

void insertData(
 in unsigned long
 offset,in
 DOMString
 arg)raises(
 DOMException);

chardataobj.insertData(
 offset, arg)

void ADOMinsertData(
 ADOMCharacterdata*
 chardataobj,
 ADOMUInt32 offset,
 ADOMString arg);

readonly attribute
 unsigned long
 length;

chardataobj.length

ADOMUInt32 ADOMgetLength(
 ADOMCharacterdata*
 chardataobj);

void replaceData(
 in unsigned long
 offset, in 
 unsigned long
 count, in
 DOMString arg)
 raises(
 DOMException);

chardataobj.
 replaceData(offset,
 count, arg)

void ADOMreplaceData(
 ADOMCharacterdata*
 chardataobj,
 ADOMUInt32 offset,
 ADOMUInt32 count,
 ADOMString arg);

DOMString 
 substringData(
 in unsigned long
 offset, in
 unsigned long
 count) raises(
 DOMException);

chardataobj.
 substringData(offset,
 count)

ADOMString
 ADOMsubstringData(
 ADOMCharacterdata*
 chardataobj,
 ADOMUInt32 offset,
 ADOMUInt32 count);

Document interface

Element
 createElement(in
 DOMString tagName)
 raises(
 DOMException);

docobj.createElement(
 tagName)

ADOMElement*
 ADOMcreateElement(
 ADOMHTMLDocument*
 docobj, ADOMString
 tagName)

Text
 createTextNode(in 
 DOMString data);

docobj.createTextNode(
 data)

ADOMText*
 ADOMcreateTextNode(
 ADOMHTMLDocument*
 docobj, ADOMString data)

readonly attribute
 Element
 documentElement;

docobj.documentElement

ADOMElement*
 ADOMgetDocumentElement(
 ADOMHTMLDocument*
 docobj)

NodeList
 getElementsByTagName
 (in DOMString
 tagname);

docobj.
 getElementsByTagName(
 tagname)

static ADOMNodeList*
 ADOMgetElementsByTagName
 (ADOMHTMLDocument*
 docobj,
 ADOMString tagname)

readonly attribute
 DOMImplementation
 implementation;

docobj.implementation

DOMImplementation*
 ADOMgetImplementation(
 ADOMHTMLDocument*
 docobj);

DOMImplementation interface

boolean hasFeature(
 in DOMString
 feature,in 
 DOMString
 version);

implemobj.
 hasFeature(feature,
 version)

ADOMBoolean
 ADOMhasFeature(
 ADOMImplementation*
 implemobj,
 ADOMString feature,
 ADOMString version);

Element interface

DOMString
 getAttribute(
 in DOMString
 name);

elemobj.
 getAttribute(name)

ADOMString
 ADOMgetAttribute(
 ADOMElement* elemobj,
 ADOMString name);

Attr
 getAttributeNode(
 in DOMString
 name);

elemobj.
 getAttributeNode(name)

ADOMAttr*
 ADOMgetAttributeNode(
 ADOMElement* elemobj,
 ADOMString name);

NodeList 
 getElementsByTagName
 (in DOMString 
tagname);

elemobj.
 getElementsByTagName
 (tagname)

static ADOMNodeList*
 ADOMgetElementsByTagName
 (ADOMHTMLDocument*
 docobj, 
 ADOMString tagname)

void normalize();

elemobj.
 normalize()

void ADOMnormalize(
 ADOMElement* elemobj);

void 
 removeAttribute(
 in DOMString name)
 raises(
 DOMException);

elemobj.
 removeAttribute(name)

void ADOMremoveAttribute(
 ADOMElement* elemobj,
 ADOMString name);

Attr 
 removeAttributeNode
 (in Attr oldAttr)
 raises(
 DOMException);

elemobj.
 removeAttributeNode(
 oldAttr)

ADOMAttr* 
 ADOMremoveAttributeNode(
 ADOMElement* elemobj,
 Attr* oldAttr);

void setAttribute(
 in DOMString name,
 in DOMString value)
 raises(
 DOMException);

elemobj.
 setAttribute(
 name,value)

void ADOMsetAttribut(
 ADOMElement* elemobj,
 ADOMString name,
 ADOMString value);

Attr
 setAttributeNode(
 in Attr newAttr)
 raises(
 DOMException);

elemobj.
 setAttributeNode(
 newAttr)

ADOMAttr*
 ADOMsetAttributeNod(
 ADOMElement* elemobj,
 Attr* newAttr);

readonly attribute
 DOMString tagName;

elemobj.tagName

ADOMString
 ADOMgetTagName(
 ADOMElement* elemobj);

HTMLAnchorElement interface

attribute DOMString
 accessKey;

anchorelemobj.accessKey

anchorelemobj.
 accessKey = string

ADOMString
 ADOMgetAccessKey(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetAccessKey(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString string);

void blur();

anchorelemobj.blur()

void ADOMblur(
 ADOMHTMLAnchorElement*
 anchorelemobj);

attribute DOMString
 charset;

anchorelemobj.charset 

anchorelemobj.charset =
 string

ADOMString ADOMgetCharset(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetCharset(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString string);

attribute DOMString
 coords;

anchorelemobj.coords

anchorelemobj.coords =
 string

ADOMString ADOMgetCoords(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetCoords(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString string);

void focus();

anchorelemobj.focus()

void ADOMfocus(
 ADOMHTMLAnchorElement*
 anchorelemobj);

attribute DOMString
 href;

anchorelemobj.href

anchorelemobj.href =
 string

ADOMString DOMgetHref(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetHref(
 ADOMAnchorElement*
 anchorelemobj,
 ADOMString string);

attribute DOMString
 hreflang;

anchorelemobj.hreflang

anchorelemobj.
 hreflang = string

ADOMString
 ADOMgetHreflang(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetHreflang(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString string);

attribute DOMString
 name;

anchorelemobj.name

anchorelemobj.name=
 string

ADOMString ADOMgetName(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetName(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString string);

attribute DOMString 
 rel;

anchorelemobj.rel

anchorelemobj.rel  = 
 string

ADOMString ADOMgetRel(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetRel(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString string);

attribute DOMString
 rev;

anchorelemobj.rev

anchorelemobj.rev  = 
 string

ADOMString ADOMgetRev(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetRev(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString string);

attribute DOMString
 shape;

anchorelemobj.shape

anchorelemobj.shape  = 
 string

ADOMString ADOMgetShape(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetShape(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString string);

attribute long
 tabIndex;

anchorelemobj.tabIndex

anchorelemobj.
 tabIndex = tabindex

ADOMInt32 ADOMgetTabIndex(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetTabIndex(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMInt32 tabindex);

attribute DOMString 
 target;

anchorelemobj.target

anchorelemobj.target =
 string

ADOMString ADOMgetTarget(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetTarget(
 ADOMHTMLAnchorElement*
 anchorelemobj, 
 ADOMString string);

attribute DOMString
 type;

anchorelemobj.type 

anchorelemobj.type =
 type

ADOMString ADOMgetType(
 ADOMHTMLAnchorElement*
 anchorelemobj);

void ADOMsetType(
 ADOMHTMLAnchorElement*
 anchorelemobj,
 ADOMString type);

HTMLAreaElement interface

attribute DOMString
 accessKey;

areaelemobj.accessKey

areaelemobj.accessKey =
 string

ADOMString DOMgetAccessKey(
 ADOMHTMLAreaElement*
 areaelemobj);

void ADOMsetAccessKey(
 ADOMHTMLAreaElement*
 areaelemobj,
 ADOMString string);

attribute DOMString
 alt;

areaelemobj.alt

areaelemobj.alt =
 string

ADOMString DOMgetAlt(
 ADOMHTMLAreaElement*
 areaelemobj);

void ADOMsetAlt(
 ADOMHTMLAreaElement* 
 areaelemobj, 
 ADOMString string);

attribute DOMString
 coords;

areaelemobj.coords

areaelemobj.coords =
 string

ADOMString ADOMgetCoords(
 ADOMHTMLAreaElement* 
 areaelemobj);

void ADOMsetCoords(
 ADOMHTMLAreaElement*
 areaelemobj,
 ADOMString string);

attribute DOMString
 href;

areaelemobj.href

areaelemobj.href =
 string

ADOMString ADOMgetHref(
 ADOMHTMLAreaElement*
 areaelemobj);

void ADOMsetHref(
 ADOMHTMLAreaElement*
 areaelemobj,
 ADOMString string);

attribute boolean
 noHref;

areaelemobj.noHref

areaelemobj.noHref =
 bool

ADOMBoolean ADOMgetNoHref(
 ADOMHTMLAreaElement*
 areaelemobj);

void ADOMsetNoHref(
 ADOMHTMLAreaElement*
 areaelemobj,
 ADOMBoolean bool);

attribute DOMString
 shape;

areaelemobj.shape

areaelemobj.shape =
 string

ADOMString ADOMgetShape(
 ADOMHTMLAreaElement*
 areaelemobj);

void ADOMsetShape(
 ADOMHTMLAreaElement*
 areaelemobj,
 ADOMString string);

attribute long
 tabIndex;

areaelemobj.tabIndex

areaelemobj.tabIndex =
 tabindex

ADOMInt32 ADOMgetTabIndex(
 ADOMHTMLAreaElement* 
 areaelemobj);

void ADOMsetTabIndex(
 ADOMDOMImplementation*
 adomobj,
 ADOMInt32 tabindex);

attribute DOMString
 target;

areaelemobj.target

areaelemobj.target =
 string

ADOMString ADOMgetTarget(
 ADOMHTMLAreaElement*
 areaelemobj);

void ADOMsetTarget(
 ADOMHTMLAreaElement*
 areaelemobj,
 ADOMString string);

HTMLBodyElement interface

attribute DOMString  
 aLink;

bodyelemobj.aLink

bodyelemobj.aLink =
 string

ADOMString ADOMgetALink(
 ADOMHTMLBodyElement*
 bodyelemobj);

void ADOMsetALink(
 ADOMHTMLBodyElement*
 bodyelemobj,
 ADOMString string);

attribute DOMString
 background;

bodyelemobj.background

bodyelemobj.
 background = string

ADOMString 
 ADOMgetBackground(
 ADOMHTMLBodyElement*
 bodyelemobj);

void ADOMsetBackground(
 ADOMHTMLBodyElement*
 bodyelemobj,
 ADOMString string);

attribute DOMString
 bgColor;

bodyelemobj.bgColor

bodyelemobj.bgColor =
 string

ADOMString ADOMgetBgColor(
 ADOMHTMLBodyElement*
 bodyelemobj);

void ADOMsetBgColor(
 ADOMHTMLBodyElement*
 bodyelemobj,
 ADOMString string);

attribute DOMString
 link;

bodyelemobj.link

bodyelemobj.link =
 string

ADOMString ADOMgetLink(
 ADOMHTMLBodyElement*
 bodyelemobj);

void ADOMsetLink(
 ADOMHTMLBodyElement*
 bodyelemobj,
 ADOMString string);

attribute DOMString
 text;

bodyelemobj.text

bodyelemobj.text =
 string

ADOMString ADOMgetText(
 ADOMHTMLBodyElement*
 bodyelemobj);

void ADOMsetText(
 ADOMHTMLBodyElement*
 bodyelemobj,
 ADOMString string);

attribute DOMString
 vLink;

bodyelemobj.vLink

bodyelemobj.vLink =
 string

ADOMString ADOMgetVLink(
 ADOMHTMLBodyElement*
 bodyelemobj);

void ADOMsetVLink(
 ADOMHTMLBodyElement*
 bodyelemobj,
 ADOMString string);

HTMLBRElement interface

attribute DOMString
 clear;

breelemobj.clear

breelemobj.clear =
 string

ADOMString ADOMgetClear(
 ADOMHTMLBRElement*
 breelemobj);

void ADOMsetClear(
 ADOMHTMLBRElement*
 breelemobj,
 ADOMString string);

HTMLButtonElement interface

attribute DOMString
 accessKey;

btnelemobj.accessKey

btnelemobj.accessKey =
 string

ADOMString ADOMgetAccessKey(
 ADOMHTMLButtonElement*
 btnelemobj);

void ADOMsetAccessKey(
 ADOMHTMLButtonElement*
 btnelemobj,
 ADOMString string);

attribute boolean 
 disabled;

btnelemobj.disabled

btnelemobj.disabled =
 bool

ADOMBoolean ADOMgetDisabled(
 ADOMHTMLButtonElement*
 btnelemobj);

void ADOMsetDisabled(
 ADOMHTMLButtonElement*
 btnelemobj,
 ADOMBoolean bool);

readonly attribute 
 HTMLFormElement
 form;

btnelemobj.button.form

ADOMHTMLFormElement*
 ADOMgetForm(
 ADOMHTMLFormElement*
 formelemobj);

attribute DOMString
 name;

btnelemobj.name

btnelemobj.name =
 string

ADOMString ADOMgetName(
 ADOMHTMLButtonElement*
 btnelemobj);

void ADOMsetName(
 ADOMHTMLButtonElement* 
 btnelemobj,
 ADOMString string);

attribute long
 tabIndex;

btnelemobj.tabIndex

bnelemobj.tabIndex =
 tabindex

ADOMInt32 ADOMgetTabIndex(
 ADOMHTMLButtonElement*
 btnelemobj);

void ADOMsetTabIndex(
 ADOMHTMLButtonElement*
 btnelemobj,
 ADOMInt32 tabindex);

readonly attribute
 DOMString type;

btnelemobj.type

ADOMString ADOMgetType(
 ADOMHTMLButtonElement*
 btnelemobj);

attribute DOMString
 value;

btnelemobj.value

btnelemobj.value =
 value

ADOMString ADOMgetValue(
 ADOMHTMLButtonElement*
 btnelemobj);

void ADOMsetValue(
 ADOMHTMLButtonElement*
 btnelemobj,
 ADOMString value);

HTMLCollection interface

Node item(in
 unsigned long
 index);

collectobj.item(index)

ADOMNode* ADOMitem(
 ADOMHTMLCollection* 
 collectobj,
 ADOMUInt32 index);

readonly attribute
 unsigned long
 length;

collectobj.length

ADOMUInt32 ADOMgetLength(
 ADOMHTMLCollection*
 collectobj);

Node namedItem(in
 DOMString name);

collectobj.
 namedItem(name)

ADOMNode* ADOMnamedItem(
 ADOMHTMLCollection*
 collectobj,
 ADOMString name);

HTMLDirectoryElement interface

attribute boolean
 compact;

directoryobj.compact

directoryobj.compact
 = bool

ADOMBoolean ADOMgetCompact(
 ADOMHTMLDirectoryElement*
 direlemobj);

void ADOMsetCompact(
 ADOMHTMLDirectoryElement*
 direlemobj,
 ADOMBoolean bool);

HTMLDivElement interface

attribute DOMString
 align;

divobj.align

divobj.align = string

ADOMString ADOMgetAlign(
 ADOMDivElement*
 divelemobj);

void ADOMsetAlign(
 ADOMDivElement*
 divelemobj,
 ADOMString string);

HTMLDListElement interface

attribute boolean
 compact;

dliseobj.compact

dliseobj.compact = bool

ADOMBoolean ADOMgetCompact(
 ADOMHTMLDListElement*
 dlistelemobj);

void ADOMsetCompact(
 ADOMHTMLDListElement*
 dlistelemobj,
 ADOMBoolean bool);

HTMLDocument interface

readonly attribute
 HTMLCollection
 anchors;

docobj.anchors

ADOMHTMLCollection*
 ADOMgetAnchors(
 ADOMHTMLDocument*
 docobj);

readonly attribute
 HTMLCollection
 applets;

(always returns NULL)

docobj.applets

ADOMHTMLCollection*
 ADOMgetApplets(
 ADOMHTMLDocument*
 docobj);

attribute HTMLElement
 body;

(implemented as readonly)

docobj.body

ADOMHTMLElement*
 ADOMgetBody(
 ADOMHTMLDocument*
 docobj);

readonly attribute
 DOMString domain;

docobj.domain

ADOMString ADOMgetDomain(
 ADOMHTMLDocument*
 docobj);

readonly attribute
 HTMLCollection
 forms;

docobj.forms

ADOMHTMLCollection* 
 ADOMgetForms(
 ADOMHTMLDocument*
 docobj);

Element
 getElementById(
 DOMString
 elementId);

docobj.getElementById(
 elementId)

ADOMElement* 
 ADOMgetElementById(
 ADOMHTMLDocument*
 docobj,
 ADOMString elementId);

NodeList
 getElementsByName(
 DOMString
 elementName);

docobj.
 getElementsByName(
 elementName)

ADOMNodeList*
 ADOMgetElementsByName(
 ADOMHTMLDocument*
 docobj,
 ADOMString elementName);

readonly attribute
 HTMLCollection
 images;

docobj.images

ADOMHTMLCollection*
 ADOMgetImages(
 ADOMHTMLDocument*
 docobj);

readonly attribute
 HTMLCollection
 links;

docobj.links

ADOMHTMLCollection*
 ADOMgetLinks(
 ADOMHTMLDocument*
 docobj);

readonly attribute
 DOMString referrer;

docobj.referrer

ADOMString ADOMgetReferrer(
 ADOMHTMLDocument* docobj);

attribute DOMString
 title;

docobj.title

docobj.title = title

ADOMString ADOMgetTitle( 
 ADOMHTMLDocument*
 docobj);

void ADOMsetTitle(
 ADOMHTMLDocument*
 docobj,
 ADOMString title);

readonly attribute
 DOMString URL;

docobj.URL

ADOMString ADOMgetURL(
 ADOMHTMLDocument*
 docobj);

HTMLElement interface

attribute DOMString
 className;

htmlelemobj.className

htmlelemobj.
 className = string

ADOMString ADOMgetClassName(
 ADOMHTMLElement*
 htmlelemobj);

void ADOMsetClassName(
 ADOMHTMLElement*
 htmlelemobj,
 ADOMString string);

attribute DOMString 
 dir;

htmlelemobj.dir

htmlelemobj.dir =
 string

ADOMString ADOMgetDir(
 ADOMHTMLElement*
 htmlelemobj);

void ADOMsetDir(
 ADOMHTMLElement*
 htmlelemobj,
 ADOMString string);

attribute DOMString
 id;

htmlelemobj.id

htmlelemobj.elemname.id
 = string

ADOMString DOMgetId(
 ADOMHTMLElement*
 htmlelemobj);

void ADOMsetId(
 ADOMHTMLElement*
 htmlelemobj,
 ADOMString string);

attribute DOMString
 lang;

htmlelemobj.lang

htmlelemobj.lang =
 string

ADOMString ADOMgetLang(
 ADOMHTMLElement*
 htmlelemobj);

void ADOMsetLang(
 ADOMHTMLElement*
 htmlelemobj,
 ADOMString string);

attribute DOMString
 title;

htmlelemobj.title

htmlelemobj.title =
 string

ADOMString ADOMgetTitle(
 ADOMHTMLElement*
 htmlelemobj);

void ADOMsetTitle(
 ADOMHTMLElement*
 htmlelemobj,
 ADOMString string);

HTMLFontElement interface

attribute DOMString
 color;

fontelemobj.color

fontelemobj.color
 = string

ADOMString ADOMgetColor(
 ADOMHTMLFontElement*
 fontelemobj);

void ADOMsetColor(
 ADOMHTMLFontElement*
 fontelemobj,
 ADOMString string);

attribute DOMString 
 face;

fontelemobj.face

fontelemobj.face
 = string

ADOMString ADOMgetFace(
 ADOMHTMLFontElement*
 fontelemobj);

void ADOMsetFace(
 ADOMHTMLFontElement*
 fontelemobj,
 ADOMString string);

attribute DOMString
 size;

fontelemobj.size

fontelemobj.size
 = string

ADOMString ADOMgetSize(
 ADOMHTMLFontElement*
 fontelemobj);

void ADOMsetSize(
 ADOMHTMLFontElement*
 fontelemobj,
 ADOMString string);

HTMLFormElement interface

attribute DOMString
 acceptCharset;

formobj.acceptCharset

formobj.acceptCharset =
 string

ADOMString 
 ADOMgetAcceptCharset(
 ADOMHTMLFormElement*
 formobj);

void ADOMsetAcceptCharset(
 ADOMHTMLFormElement*
 formobj,
 ADOMString string);

attribute DOMString
 action;

formobj.action

formobj.action =
 string

ADOMString ADOMgetAction(
 ADOMHTMLFontElement*
 fontelemobj);

void ADOMsetAction(
 ADOMHTMLFontElement*
 fontelemobj,
 ADOMString string);

readonly attribute
 HTMLCollection
 elements;

formobj.elements

ADOMHTMLCollection*
 ADOMgetElements(
 ADOMHTMLFontElement*
 fontelemobj);

attribute DOMString
 enctype;

formobj.enctype

formobj.enctype =
 string

ADOMString ADOMgetEnctype(
 ADOMHTMLFontElement* 
 fontelemobj);

void ADOMsetEnctype(
 ADOMHTMLFontElement*
 fontelemobj,
 ADOMString string);

readonly attribute
 long length;

formobj.length

ADOMUInt32 ADOMgetLength(
 ADOMHTMLFontElement*
 fontelemobj);

attribute DOMString
 method;

formobj.method

formobj.method =
 string

ADOMString ADOMgetMethod(
 ADOMHTMLFontElement*
 fontelemobj);

void ADOMsetMethod(
 ADOMHTMLFontElement*
 fontelemobj,
 ADOMString string);

attribute DOMString
 name;

formobj.name

formobj.name =
 string

ADOMString ADOMgetName(
 ADOMHTMLFontElement*
 fontelemobj);

void ADOMsetName(
 ADOMHTMLFontElement*
 fontelemobj,
 ADOMString string);

void reset();

formobj.reset()

void ADOMreset(
 ADOMHTMLFontElement*
 fontelemobj);

void submit();

formobj.submit()

void ADOMsubmit(
 ADOMHTMLFontElement*
 fontelemobj);

attribute DOMString
 target;

formobj.target

formobj.target =
 string

ADOMString ADOMgetTarget(
 ADOMHTMLFontElement*
 fontelemobj);

void ADOMsetTarget(
 ADOMHTMLFontElement*
 fontelemobj,
 ADOMString string);

HTMLHeadElement interface

attribute DOMString
 profile;

headobj.profile

headobj.profile =
 string

ADOMString ADOMgetProfile(
 ADOMHTMLHeadElement* 
 headobj);

void ADOMsetProfile(
 ADOMHTMLHeadElement*
 headobj,
 ADOMString string);

HTMLHeadingElement interface

attribute DOMString
 align;

headingobj.align

headingobj.align =
 string

ADOMString ADOMgetAlign(
 ADOMHTMLHeadElement*
 headingobj);

void ADOMsetAlign(
 ADOMHTMLHeadElement*
 headingobj,
 ADOMString string);

HTMLHRElement interface

attribute DOMString
 align;

hrobj.align

hrobj.align =
 string

ADOMString ADOMgetAlign(
 ADOMHTMLHRElement*
 hrobj);

void ADOMsetAlign(
 ADOMHTMLHRElement*
 hrobj,
 ADOMString string);

attribute boolean
 noShade;

hrobj.noShade

hrobj.noShade = bool

ADOMBoolean ADOMgetNoShade(
 ADOMHTMLHRElement*
 hrobj);

void ADOMsetNoShade(
 ADOMHTMLHRElement*
 hrobj,
 ADOMBoolean bool);

attribute DOMString
 size;

hrobj.size

hrobj.size = string

ADOMString ADOMgetSize(
 ADOMHTMLHRElement*
 hrobj);

void ADOMsetSize(
 ADOMHTMLHRElement*
 hrobj,
 ADOMString string);

attribute DOMString
 width;

hrobj.width

hrobj.width = string

ADOMString ADOMgetWidth(
 ADOMHTMLHRElement* 
 hrobj);

void ADOMsetWidth(
 ADOMHTMLHRElement*
 hrobj,
 ADOMString string);

HTMLHtmlElement interface

attribute DOMString
 version;

htmlelemobj.version

htmlelemobj.version =
 string

ADOMString ADOMgetVersion(
 ADOMHTMLElementobject*
 htmlelemobj);

void ADOMsetVersion(
 ADOMDOMImplementation*
 htmlelemobj,
 ADOMString string);

HTMLImageElement interface

attribute DOMString
 align;

imageelemobj.align

imageelemobj.align =
 string

ADOMString ADOMgetAlign(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetAlign(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 alt;

imageelemobj.alt

imageelemobj.alt =
 string

ADOMString ADOMgetAlt(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetAlt(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 border;

imageelemobj.border

imageelemobj.border =
 string

ADOMString ADOMgetBorder(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetBorder(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 height;

imageelemobj.height

imageelemobj.height =
 string

ADOMString ADOMgetHeight(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetHeight(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 hspace;

imageelemobj.hspace

imageelemobj.hspace =
 string

ADOMString ADOMgetHspace(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetHspace(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute boolean
 isMap;

imageelemobj.isMap

imageelemobj.isMap =
 bool

ADOMBoolean ADOMgetIsMap(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetIsMap(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMBoolean bool);

attribute DOMString
 longDesc;

imageelemobj.longDesc

imageelemobj.longDesc =
 string

ADOMString ADOMgetLongDesc(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetLongDesc(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 lowSrc;

imageelemobj.lowSrc

imageelemobj.lowSrc =
 string

ADOMString ADOMgetLowSrc(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetLowSrc(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 name;

imageelemobj.name

imageelemobj.name =
 string

ADOMString ADOMgetName(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetName(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 src;

imageelemobj.src

imageelemobj.src =
 string

ADOMString ADOMgetSrc(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetSrc(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 useMap;

imageelemobj.useMap

imageelemobj.useMap =
 string

ADOMString ADOMgetUseMap(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetUseMap(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 vspace;

imageelemobj.vspace

imageelemobj.vspace =
 string

ADOMString ADOMgetVspace(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetVspace(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

attribute DOMString
 width;

imageelemobj.width

imageelemobj.width =
 string

ADOMString ADOMgetWidth(
 ADOMHTMLImageElement*
 imageelemobj);

void ADOMsetWidth(
 ADOMHTMLImageElement*
 imageelemobj,
 ADOMString string);

HTMLInputElement interface

attribute DOMString
 accept;

inputelemobj.accept

inputelemobj.accept =
 string

ADOMString ADOMgetAccept(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetAccept(
 ADOMHTMLInputElement* 
 inputelemobj,
 ADOMString string);

attribute DOMString
 accessKey;

inputelemobj.accessKey

inputelemobj.
 accessKey = string

ADOMString ADOMgetAccessKey(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetAccessKey(
 ADOMHTMLInputElement* 
 inputelemobj,
 ADOMString string);

attribute DOMString
 align;

inputelemobj.align

inputelemobj.align =
 string

ADOMString ADOMgetAlign(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetAlign(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMString string);

attribute DOMString
 alt;

inputelemobj.alt

inputelemobj.alt =
 string

ADOMString ADOMgetAlt(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetAlt(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMString string);

void blur();

inputelemobj.blur()

void ADOMblur(
 ADOMHTMLInputElement*
 inputelemobj);

attribute boolean
 checked;

inputelemobj.checked

inputelemobj.checked =
 bool

ADOMBoolean ADOMgetChecked(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetChecked(
 ADOMHTMLInputElement* 
 inputelemobj,
 ADOMBoolean bool);

void click();

inputelemobj.click()

void ADOMclick(
 ADOMHTMLInputElement*
 inputelemobj);

attribute boolean
 defaultChecked;

inputelemobj.
 defaultChecked

inputelemobj.
 defaultChecked = bool

ADOMBoolean ADOMgetDefaultChecked(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetDefaultChecked( 
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMBoolean bool);

attribute DOMString
 defaultValue;

inputelemobj.
defaultValue

inputelemobj.
 defaultValue = string

ADOMString ADOMgetDefaultValue(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetDefaultValue(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMString string);

attribute boolean
 disabled;

inputelemobj.disabled

inputelemobj.disabled =
 bool

ADOMBoolean ADOMgetDisabled(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetDisabled(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMBoolean bool);

void focus();

inputelemobj.focus()

void ADOMfocus(
 ADOMHTMLInputElement*
 inputelemobj);

readonly attribute
 HTMLFormElement
 form;

inputelemobj.form

ADOMHTMLFormElement* ADOMgetForm(
 ADOMHTMLInputElement*
 inputelemobj);

attribute long
 maxLength;

inputelemobj.maxLength

inputelemobj.maxLength
 = maxlength

ADOMInt32 ADOMgetMaxLength(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetMaxLength(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMInt32 maxlength);

attribute DOMString
 name;

inputelemobj.name

inputelemobj.name =
 string

ADOMString ADOMgetName(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetName(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMString string);

attribute boolean
 readOnly;

inputelemobj.readOnly

inputelemobj.readOnly =
 bool

ADOMBoolean ADOMgetReadOnly(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetReadOnly(
 ADOMHTMLInputElement* 
 inputelemobj,
 ADOMBoolean bool);

void select();

inputelemobj.select()

void ADOMselect(
 ADOMHTMLInputElement*
 inputelemobj);

attribute DOMString
 size;

inputelemobj.size 

inputelemobj.size =
 string

ADOMString ADOMgetSize(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetSize(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMString string);

attribute DOMString
 src;

inputelemobj.src

inputelemobj.src =
 string

ADOMString ADOMgetSrc(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetSrc(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMString string);

attribute long
 tabIndex;

inputelemobj.tabIndex

inputelemobj.tabIndex =
 tabindex

ADOMInt32 ADOMgetTabIndex(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetTabIndex(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMInt32 tabindex);

readonly attribute
 DOMString type;

inputelemobj.type

ADOMString ADOMgetType(
 ADOMHTMLInputElement*
 inputelemobj);

attribute DOMString
 useMap;

inputelemobj.useMap

inputelemobj.useMap =
 string

ADOMString ADOMgetUseMap(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetUseMap(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMString string);

attribute DOMString 
 value;

inputelemobj.value

inputelemobj.value =
 value

ADOMString ADOMgetValue(
 ADOMHTMLInputElement*
 inputelemobj);

void ADOMsetValue(
 ADOMHTMLInputElement*
 inputelemobj,
 ADOMString value);

HTMLLIElement interface

attribute DOMString
 type;

lielemobj.type

lielemobj.type =
 type

ADOMString ADOMgetType(
 ADOMHTMLIElement*
 lielemobj);

void ADOMsetType(
 ADOMHTMLIElement*
 lielemobj,
 ADOMString type);

attribute long
 value;

lielemobj.value

lielemobj.value =
 string

ADOMString ADOMgetValue(
 ADOMHTMLIElement*
 lielemobj);

void ADOMsetValue(
 ADOMHTMLIElement*
 lielemobj,
 ADOMString string);

HTMLMapElement interface

readonly attribute
 HTMLCollection 
 areas;

mapelemobj.areas

HTMLCollection* 
 ADOMgetAreas(
 ADOMHTMLMapElement*
 mapelemobj);

attribute DOMString
 name;

mapelemobj.name

mapelemobj.name =
 name

ADOMString ADOMgetName(
 ADOMHTMLMapElement*
 mapelemobj);

void ADOMsetName(
 ADOMHTMLMapElement* 
 mapelemobj,
 ADOMString name);

HTMLMenuElement interface

attribute boolean 
 compact;

menuelemobj.compact

menuelemobj.compact =
 bool

ADOMBoolean ADOMgetCompact(
 ADOMHTMLMenuElement*
 menuelemobj);

void ADOMsetCompact(
 ADOMHTMLMenuElement*
 menuelemobj,
 ADOMBoolean bool);

HTMLMetaElement interface

attribute DOMString
 content;

metaelemobj.content

metaelemobj.content =
 string

ADOMString ADOMgetContent(
 ADOMHTMLMetaElement*
 metaelemobj);

void ADOMsetContent(
 ADOMHTMLMetaElement*
 metaelemobj,
 ADOMString string);

attribute DOMString
 httpEquiv;

metaelemobj.httpEquiv

metaelemobj.httpEquiv =
 string

ADOMString ADOMgetHttpEquiv(
 ADOMHTMLMetaElement*
 metaelemobj);

void ADOMsetHttpEquiv(
 ADOMHTMLMetaElement*
 metaelemobj,
 ADOMString string);

attribute DOMString
 name;

metaelemobj.name

metaelemobj.name =
 string

ADOMString ADOMgetName(
 ADOMHTMLMetaElement*
 metaelemobj);

void ADOMsetName(
 ADOMHTMLMetaElement*
 metaelemobj,
 ADOMString string);

attribute DOMString
 scheme;

metaelemobj.scheme

metaelemobj.scheme =
 string

ADOMString ADOMgetScheme(
 ADOMHTMLMetaElement*
 metaelemobj);

void ADOMsetScheme(
 ADOMHTMLMetaElement*
 metaelemobj,
 ADOMString string);

HTMLModElement interface

attribute DOMString
 cite;

modelemobj.modelemname.cite

modelemobj.modelemname.
 cite = cite

ADOMString ADOMgetCite(
 ADOMHTMLModElement*
 modelemobj);

void ADOMsetCite(
 ADOMHTMLModElement*
 modelemobj,
 ADOMString cite);

attribute DOMString
 dateTime;

modelemobj.modelemname.
 dateTime

modelemobj.modelemname.
 dateTime = dateTime

ADOMString ADOMgetDateTime(
 ADOMHTMLModElement*
 modelemobj);

void ADOMsetDateTime(
 ADOMHTMLModElement*
 modelemobj,
 ADOMString dateTime);

HTMLObjectElement interface

attribute DOMString
 align;

objelemobj.align

objelemobj.align
 = align

ADOMString ADOMgetAlign(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetAlign(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString align);

attribute DOMString
 archive;

objelemobj.archive

objelemobj.archive =
 archive

ADOMString ADOMgetArchive(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetArchive(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString archive);

attribute DOMString
 border;

objelemobj.border

objelemobj.border
 = border

ADOMString ADOMgetBorder(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetBorder(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString border);

attribute DOMString
 code;

objelemobj.code

objelemobj.code = code

ADOMString ADOMgetCode(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetCode(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString code);

attribute DOMString
 codeBase;

objelemobj.codeBase

objelemobj.codeBase =
 codeBase

ADOMString ADOMgetCodeBase(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetCodeBase(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString codeBase);

attribute DOMString
 codeType;

objelemobj.codeType

objelemobj.codeType =
 codeType

ADOMString ADOMgetCodeType(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetCodeType(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString codeType);

attribute DOMString
 data;

objelemobj.data

objelemobj.data = data

ADOMString ADOMgetData(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetData(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString data);

attribute boolean
 declare;

objelemobj.declare

objelemobj.declare =
 bool

ADOMBoolean ADOMgetDeclare(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetDeclare(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMBoolean bool);

readonly attribute
 HTMLFormElement
 form;

objelemobj.form

HTMLFormElement* 
 ADOMgetForm(
 ADOMHTMLObjectElement*
 form);

attribute DOMString
 height;

objelemobj.height

objelemobj.height =
 height

ADOMString ADOMgetHeight(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetHeight(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString height);

attribute DOMString
 hspace;

objelemobj.hspace

objelemobj.hspace =
 hspace

ADOMString ADOMgetHspace(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetHspace(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString hspace);

attribute DOMString
 name;

objelemobj.name

objelemobj.name =
 name

ADOMString ADOMgetName(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetName(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString name);

attribute DOMString
 standby;

objelemobj.standby

objelemobj.standby =
 standby

ADOMString ADOMgetStandby(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetStandby(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString standby);

attribute long
 tabIndex;

objelemobj.tabIndex

objelemobj.tabIndex =
 tabindex

ADOMInt32 ADOMgetTabIndex(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetTabIndex(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMInt32 tabindex);

attribute DOMString
 type;

objelemobj.type

objelemobj.type =
 type

ADOMString ADOMgetType(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetType(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString type);

attribute DOMString
 useMap;

objelemobj.useMap

objelemobj.useMap =
 useMap

ADOMString ADOMgetUseMap(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetUseMap(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString useMap);

attribute DOMString
 vspace;

objelemobj.vspace

objelemobj.vspace =
 vspace

ADOMString ADOMgetVspace(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetVspace(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString vspace);

attribute DOMString
 width;

objelemobj.width

objelemobj.width =
 width

ADOMString ADOMgetWidth(
 ADOMHTMLObjectElement*
 objelemobj);

void ADOMsetWidth(
 ADOMHTMLObjectElement*
 objelemobj,
 ADOMString width);

HTMLOListElement interface

attribute boolean
 compact;

olistelemobj.compact

olistelemobj.compact =
 bool

ADOMBoolean ADOMgetCompact(
 ADOMHTMLOListElement*
 olistelemobj);

void ADOMsetCompact(
 ADOMHTMLOListElement*
 olistelemobj,
 ADOMBoolean bool);

attribute long
 start;

olistelemobj.start

olistelemobj.start =
 start

ADOMInt32 ADOMgetStart(
 ADOMHTMLOListElement*
 olistelemobj);

void ADOMsetStart(
 ADOMHTMLOListElement*
 olistelemobj,
 ADOMInt32 start);

attribute DOMString
 type;

olistelemobj.type

olistelemobj.type =
 string

ADOMString ADOMgetType(
 ADOMHTMLOListElement*
 olistelemobj);

void ADOMsetType(
 ADOMHTMLOListElement*
 olistelemobj,
 ADOMString string);

HTMLOptionElement interface

attribute boolean
 defaultSelected;

optionelemobj.
 defaultSelected

optionelemobj.
 defaultSelected = bool

ADOMBoolean 
 ADOMgetDefaultSelected(
 ADOMHTMLOptionElement*
 optionelemobj);

void ADOMsetDefaultSelected(
 ADOMHTMLOptionElement*
 optionelemobj,
 ADOMBoolean bool);

attribute boolean
 disabled;

optionelemobj.disabled

optionelemobj.disabled
 = bool

ADOMBoolean ADOMgetDisabled(
 ADOMHTMLOptionElement*
 optionelemobj);

void ADOMsetDisabled(
 ADOMHTMLOptionElement*
 optionelemobj,
 ADOMBoolean bool);

readonly attribute
 HTMLFormElement
 form;

optionelemobj.form

HTMLFormElement*
 ADOMgetForm(
 ADOMHTMLOptionElement*
 optionelemobj);

readonly attribute
 long index;

optionelemobj.index

ADOMInt32 ADOMgetIndex(
 ADOMHTMLOptionElement*
 optionelemobj);

attribute DOMString
 label;

optionelemobj.label

optionelemobj.label =
 string

ADOMString ADOMgetLabel(
 ADOMHTMLOptionElement* 
 optionelemobj);

void ADOMsetLabel(
 ADOMHTMLOptionElement*
 optionelemobj,
 ADOMString string);

readonly attribute
 boolean selected;

optionelemobj.selected

ADOMBoolean ADOMgetSelected(
 ADOMHTMLOptionElement*
 optionelemobj);

readonly attribute
 DOMString text;

optionelemobj.text

ADOMString ADOMgetText(
 ADOMHTMLOptionElement*
 optionelemobj);

attribute DOMString 
 value;

optionelemobj.value

optionelemobj.value =
 string

ADOMString ADOMgetValue(
 ADOMHTMLOptionElement*
 optionelemobj);

void ADOMsetValue(
 ADOMHTMLOptionElement*
 optionelemobj,
 ADOMString string);

HTMLParagraphElement interface

attribute DOMString
 align;

pgfelemobj.align

pgfelemobj.align =
 align

ADOMString ADOMgetAlign(
 ADOMHTMLParagraphElement*
 pgfelemobj);

void ADOMsetAlign(
 ADOMHTMLParagraphElement*
 pgfelemobj,
 ADOMString align);

HTMLParamElement interface

attribute DOMString 
 name;

paramelemobj.name

paramelemobj.name =
 name

ADOMString ADOMgetName(
 ADOMHTMLParamElement*
 paramelemobj);

void ADOMsetName(
 ADOMHTMLParamElement*
 paramelemobj,
 ADOMString name);

attribute DOMString
 type;

paramelemobj.type

paramelemobj.type =
 type

ADOMString ADOMgetType(
 ADOMHTMLParamElement*
 paramelemobj);

void ADOMsetType(
 ADOMHTMLParamElement*
 paramelemobj,
 ADOMString type);

attribute DOMString
 value;

paramelemobj.value

paramelemobj.value =
 value

ADOMString ADOMgetValue(
 ADOMHTMLParamElement*
 paramelemobj);

void ADOMsetValue(
 ADOMHTMLParamElement*
 paramelemobj,
 ADOMString value);

attribute DOMString
 valueType;

paramelemobj.valueType

paramelemobj.valueType
 = valueType

ADOMString ADOMgetValueType(
 ADOMHTMLParamElement*
 paramelemobj);

void ADOMsetValueType(
 ADOMHTMLParamElement*
 paramelemobj,
 ADOMString valueType);

HTMLPreElement interface

attribute long
 width;

preelemobj.width

preelemobj.width =
 width

ADOMString ADOMgetWidth(
 ADOMHTMLPreElement*
 preelemobj);

void ADOMsetWidth(
 ADOMHTMLPreElement*
 preelemobj,
 ADOMString width);

HTMLQuoteElement interface

attribute DOMString
 cite;

quoteelemobj.cite

quoteelemobj.cite =
 cite

ADOMString ADOMgetCite(
 ADOMHTMLQuoteElement*
 quoteelemobj);

void ADOMsetCite(
 ADOMHTMLQuoteElement*
 quoteelemobj,
 ADOMString cite);

HTMLScriptElement interface

attribute DOMString
 charset;

scriptelemobj.charset

scriptelemobj.charset =
 charset

ADOMString ADOMgetCharset(
 ADOMHTMLScriptElement*
 scriptelemobj);

void ADOMsetCharset(
 ADOMHTMLScriptElement*
 scriptelemobj,
 ADOMString charset);

attribute boolean
 defer;

scriptelemobj.defer

scriptelemobj.defer =
 bool

ADOMBoolean ADOMgetDefer(
 ADOMHTMLScriptElement*
 scriptelemobj);

void ADOMsetDefer(
 ADOMHTMLScriptElement*
 scriptelemobj,
 ADOMBoolean bool);

attribute DOMString
 event;

scriptelemobj.event

scriptelemobj.event =
 event

ADOMString ADOMgetEvent(
 ADOMHTMLScriptElement*
 scriptelemobj);

void ADOMsetEvent(
 ADOMHTMLScriptElement*
 scriptelemobj,
 ADOMString event);

attribute DOMString
 htmlFor;

scriptelemobj.htmlFor

scriptelemobj.htmlFor =
 htmlFor

ADOMString ADOMgetHtmlFor(
 ADOMHTMLScriptElement*
 scriptelemobj);

void ADOMsetHtmlFor(
 ADOMHTMLScriptElement*
 scriptelemobj,
 ADOMString htmlFor);

attribute DOMString
 src;

scriptelemobj.src

scriptelemobj.src =
 src

ADOMString ADOMgetSrc(
 ADOMHTMLScriptElement*
 scriptelemobj);

void ADOMsetSrc(
 ADOMHTMLScriptElement*
 scriptelemobj,
 ADOMString src);

attribute DOMString 
 text;

scriptelemobj.text

scriptelemobj.text =
 text

ADOMString ADOMgetText(
 ADOMHTMLScriptElement*
 scriptelemobj);

void ADOMsetText(
 ADOMHTMLScriptElement*
 scriptelemobj,
 ADOMString text);

attribute DOMString
 type;

scriptelemobj.type

scriptelemobj.type =
 type

ADOMString ADOMgetType(
 ADOMHTMLScriptElement*
 scriptelemobj);

void ADOMsetType(
 ADOMHTMLScriptElement*
 scriptelemobj,
 ADOMString type);

HTMLSelectElement interface

void add(
 in HTMLElement
 element,in
 HTMLElement
 before);

selectelemobj.add(
 element, before)

void ADOMadd(
 ADOMHTMLSelectElement*
 selectelemobj,
 HTMLElement* element,
 HTMLElement* before);

void blur();

selectelemobj.blur()

void ADOMblur(
 ADOMHTMLSelectElement*
 selectelemobj);

attribute boolean
 disabled;

selectelemobj.disabled

selectelemobj.disabled
 = bool

ADOMBoolean ADOMgetDisabled(
 ADOMHTMLSelectElement* 
 selectelemobj);

void ADOMsetDisabled(
 ADOMHTMLSelectElement*
 selectelemobj,
 ADOMBoolean bool);

void focus();

selectelemobj.focus()

void ADOMfocus(
 ADOMHTMLSelectElement*
 selectelemobj);

readonly attribute
 HTMLFormElement
 form;

selectelemobj.form

HTMLFormElement* 
 ADOMgetForm(
 ADOMHTMLFormElement*
 formmobj);

readonly attribute
 long length;

selectelemobj.length

ADOMUInt32 ADOMgetLength(
 ADOMHTMLSelectElement*
 selectelemobj);

attribute boolean
 multiple;

selectelemobj.multiple

selectelemobj.multiple
 = bool

ADOMBoolean ADOMgetMultiple(
 ADOMHTMLSelectElement*
 selectelemobj);

void ADOMsetMultiple(
 ADOMHTMLSelectElement*
 selectelemobj,
 ADOMBoolean bool);

attribute DOMString
 name;

selectelemobj.name

selectelemobj.name =
 name

ADOMString ADOMgetName(
 ADOMHTMLSelectElement*
 selectelemobj);

void ADOMsetName(
 ADOMHTMLSelectElement*
 selectelemobj,
 ADOMString name);

readonly attribute
 HTMLCollection
 options;

selectelemobj.options

ADOMHTMLCollection*
 ADOMgetOptions(
 ADOMHTMLCollection* 
 collectobj);

void remove(
 in long index);

selectelemobj.
 remove(index)

void ADOMremove(
 ADOMHTMLSelectElement*
 selectelemobj,
 ADOMInt32 index);

attribute long
 selectedIndex;

selectelemobj.
 selectedIndex

selectelemobj.
 selectedIndex =
 selectedIndex

ADOMInt32 ADOMgetSelectedIndex(
 ADOMHTMLSelectElement*
 selectelemobj);

void ADOMsetSelectedIndex(
 ADOMHTMLSelectElement*
 selectelemobj,
 ADOMInt32 selectedIndex);

attribute long
 size;

selectelemobj.size

selectelemobj.size
 = size

ADOMString ADOMgetSize(
 ADOMHTMLSelectElement*
 selectelemobj);

void ADOMsetSize(
 ADOMHTMLSelectElement*
 selectelemobj,
 ADOMString size);

attribute long
 tabIndex;

selectelemobj.tabIndex

selectelemobj.tabIndex
 = tabindex

ADOMInt32 ADOMgetTabIndex(
 ADOMHTMLSelectElement*
 selectelemobj);

void ADOMsetTabIndex(
 ADOMHTMLSelectElement*
 selectelemobj,
 ADOMInt32 tabindex);

readonly attribute
 DOMString type;

selectelemobj.type

ADOMString ADOMgetType(
 ADOMHTMLSelectElement*
 selectelemobj);

attribute DOMString
 value;

selectelemobj.value

selectelemobj.value
 = value

ADOMString ADOMgetValue(
 ADOMHTMLSelectElement* 
 selectelemobj);

void ADOMsetValue(
 ADOMHTMLSelectElement*
 selectelemobj,
 ADOMString value);

HTMLStyleElement interface

attribute boolean
 disabled;

styleelemobj.disabled

styleelemobj.disabled =
 bool

ADOMBoolean ADOMgetDisabled(
 ADOMHTMLStyleElement*
 styleelemobj);

void ADOMsetDisabled(
 ADOMHTMLStyleElement*
 styleelemobj,
 ADOMBoolean bool);

attribute DOMString
 media;

styleelemobj.media

styleelemobj.media
 = media

ADOMString ADOMgetMedia(
 ADOMHTMLStyleElement*
 styleelemobj);

void ADOMsetMedia(
 ADOMHTMLStyleElement*
 styleelemobj,
 ADOMString media);

attribute DOMString
 type;

styleelemobj.type

styleelemobj.type
 = type

ADOMString ADOMgetType(
 ADOMHTMLStyleElement*
 styleelemobj);

void ADOMsetType(
 ADOMHTMLStyleElement*
 styleelemobj,
 ADOMString type);

HTMLTableCaptionElement interface

attribute DOMString
 align;

tblcapelemobj.align

tblcapelemobj.align
 = align

ADOMString 
 ADOMgetAlign(
 ADOMHTMLTableCaption
 Element*
 tblcapelemobj);

void 
 ADOMsetAlign(
 ADOMHTMLTableCaption
 Element*
 tblcapelemobj,
 ADOMString align);

HTMLTableCellElement interface

attribute DOMString
 abbr;

tblcellelemobj.abbr

tblcellelemobj.abbr
 = abbr

ADOMString ADOMgetAbbr(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetAbbr(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString abbr);

attribute DOMString
 align;

tblcellelemobj.align

tblcellelemobj.align =
 align

ADOMString ADOMgetAlign(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetAlign(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString align);

attribute DOMString
 axis;

tblcellelemobj.axis

tblcellelemobj.axis
 = axis

ADOMString ADOMgetAxis(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetAxis(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString axis);

attribute DOMString
 bgColor;

tblcellelemobj.bgColor

tblcellelemobj.bgColor
 = bgColor

ADOMString ADOMgetBgColor(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetBgColor(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString bgColor);

readonly attribute
 long cellIndex;

tblcellelemobj.
 cellIndex

ADOMInt32 ADOMgetCellIndex(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

attribute DOMString
 ch;

tblcellelemobj.ch

tblcellelemobj.ch = ch

ADOMString ADOMgetCh(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetCh(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString ch);

attribute DOMString
 chOff;

tblcellelemobj.chOff

tblcellelemobj.chOff =
 chOff

ADOMString ADOMgetChOff(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetChOff(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString chOff);

attribute long
 colSpan;

tblcellelemobj.colSpan

tblcellelemobj.colSpan
 = colSpan

ADOMInt32 ADOMgetColSpan(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetColSpan(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMInt32 colSpan);

attribute DOMString
 headers;

tblcellelemobj.headers

tblcellelemobj.headers
 = headers

ADOMString ADOMgetHeaders(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetHeaders(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString headers);

attribute DOMString
 height;

tblcellelemobj.height

tblcellelemobj.height =
 height

ADOMString ADOMgetHeight(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetHeight(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString height);

attribute boolean
 noWrap;

tblcellelemobj.noWrap

tblcellelemobj.noWrap =
 bool

ADOMBoolean ADOMgetNoWrap(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetNoWrap(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMBoolean bool);

attribute long
 rowSpan;

tblcellelemobj.rowSpan

tblcellelemobj.rowSpan
 = rowSpan

ADOMInt32 ADOMgetRowSpan(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetRowSpan(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMInt32 rowSpan);

attribute DOMString
 scope;

tblcellelemobj.scope

tblcellelemobj.scope =
 scope

ADOMString ADOMgetScope(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetScope(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString scope);

attribute DOMString
 vAlign;

tblcellelemobj.vAlign

tblcellelemobj.vAlign =
 vAlign

ADOMString ADOMgetVAlign(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetVAlign(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString vAlign);

attribute DOMString 
 width;

tblcellelemobj.width

tblcellelemobj.width =
 width

ADOMString ADOMgetWidth(
 ADOMHTMLTableCellElement*
 tblcellelemobj);

void ADOMsetWidth(
 ADOMHTMLTableCellElement*
 tblcellelemobj,
 ADOMString width);

HTMLTableColElement interface

attribute DOMString
 align;

tblcolelemobj.align

tblcolelemobj.align =
 string

ADOMString ADOMgetAlign(
 ADOMHTMLTableColElement*
 tblcolelemobj);

void ADOMsetAlign(
 ADOMHTMLTableColElement*
 tblcolelemobj,
 ADOMString string);

attribute DOMString
 ch;

tblcolelemobj.ch

tblcolelemobj.ch
 = string

ADOMString ADOMgetCh(
 ADOMHTMLTableColElement*
 tblcolelemobj);

void ADOMsetCh(
 ADOMHTMLTableColElement*
 tblcolelemobj,
 ADOMString string);

attribute DOMString
 chOff;

tblcolelemobj.chOff

tblcolelemobj.chOff =
 string

ADOMString ADOMgetChOff(
 ADOMHTMLTableColElement*
 tblcolelemobj);

void ADOMsetChOff(
 ADOMHTMLTableColElement*
 tblcolelemobj,
 ADOMString string);

attribute long
 span;

tblcolelemobj.span

tblcolelemobj.span
 = span

ADOMInt32 ADOMgetSpan(
 ADOMHTMLTableColElement*
 tblcolelemobj);

void ADOMsetSpan(
 ADOMHTMLTableColElement*
 tblcolelemobj,
 ADOMInt32 span);

attribute DOMString 
 vAlign;

tblcolelemobj.vAlign

tblcolelemobj.vAlign =
 string

ADOMString ADOMgetVAlign(
 ADOMHTMLTableColElement*
 tblcolelemobj);

void ADOMsetVAlign(
 ADOMHTMLTableColElement*
 tblcolelemobj,
 ADOMString string);

attribute DOMString
 width;

tblcolelemname.width

tblcolelemname.width =
 string

ADOMString ADOMgetWidth(
 ADOMHTMLTableColElement*
 tblcolelemobj);

void ADOMsetWidth(
 ADOMHTMLTableColElement*
 tblcolelemobj,
 ADOMString string);

HTMLTableElement interface

attribute DOMString
 align;

tblemobj.align

tblelemobj.align
 = string

ADOMString ADOMgetAlign(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetAlign(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMString string);

attribute DOMString
 bgColor;

tblelemobj.bgColor

tblelemobj.bgColor =
 string

ADOMString ADOMgetBgColor(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetBgColor(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMString string);

attribute DOMString
 border;

tblelemobj.border

tblelemobj.border =
 string

ADOMString ADOMgetBorder(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetBorder(
 ADOMHTMLTableElement* 
 tblelemobj,
 ADOMString string);

attribute
 HTMLTableCaptionElement
 caption;

tblelemobj.caption

tblelemobj.caption =
 caption

ADOMHTMLTableCaptionElement*
 ADOMgetCaption(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetCaption(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMHTMLTableCaptionElement*
 caption);

attribute DOMString
 cellPadding;

tblelemobj.cellPadding

tblelemobj.cellPadding
 = string

ADOMString
 ADOMgetCellPadding(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetCellPadding(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMString string);

attribute DOMString
 cellSpacing;

tblelemobj.cellSpacing

tblelemobj.cellSpacing
 = string

ADOMString
 ADOMgetCellSpacing(
 ADOMHTMLTableElement* 
 tblelemobj);

void ADOMsetCellSpacing(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMString string);

HTMLCaptionElement
 createCaption();

tblelemobj.
 createCaption()

ADOMHTMLCaptionElement*
 ADOMcreateCaption(
 ADOMHTMLTableElement*
 tblelemobj);

HTMLCaptionElement
 createTFoot();

tblelemobj.
 createTFoot()

ADOMHTMLCaptionElement*
 ADOMcreateTFoot(
 ADOMHTMLTableElement*
 tblelemobj);

HTMLCaptionElement
 createTHead();

tblelemobj.
 createTHead()

ADOMHTMLCaptionElement*
 ADOMcreateTHead(
 ADOMHTMLTableElement*
 tblelemobj);

void deleteCaption();

tblelemobj.
 deleteCaption()

void ADOMdeleteCaption(
 ADOMHTMLTableElement*
 tblelemobj);

void deleteRow(
 in long index);

tblelemobj.
 deleteRow(index)

void ADOMdeleteRow(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMInt32 index);

void deleteTFoot();

tblelemobj.
 deleteTFoot()

void ADOMdeleteTFoot(
 ADOMHTMLTableElement*
 tblelemobj);

void deleteTHead();

tblelemobj.
 deleteTHead()

void ADOMdeleteTHead(
 ADOMHTMLTableElement*
 tblelemobj);

attribute DOMString
 frame;

tblelemobj.frame

tblelemobj.frame
 = string

ADOMString ADOMgetFrame(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetFrame(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMString string);

HTMLElement
 insertRow(
 in long index);

tblelemobj.
 insertRow(index)

ADOMHTMLElement*
 ADOMinsertRow(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMInt32 index);

readonly attribute
 HTMLCollection
 rows;

tblelemobj.rows

ADOMHTMLCollection*
 ADOMgetRows(
 ADOMHTMLTableElement*
 tblelemobj);

attribute DOMString
 rules;

tblelemobj.rules

tblelemobj.rules
 = string

ADOMString ADOMgetRules(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetRules(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMString string);

attribute DOMString
 summary;

tblelemobj.summary

tblelemobj.summary
 = string

ADOMString ADOMgetSummary(
 ADOMHTMLTableElement* 
 tblelemobj);

void ADOMsetSummary(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMString string);

readonly attribute
 HTMLCollection 
 tBodies;

tblelemobj.tBodies

ADOMHTMLCollection*
 ADOMgetTBodies(
 ADOMHTMLTableElement*
 tblelemobj);

attribute
 HTMLTableSection
 Element tFoot;

tblelemobj.tFoot

tblelemobj.tFoot
 = tfoot

ADOMHTMLTableSectionElement*
 ADOMgetTFoot(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetTFoot(
 ADOMHTMLTableElement*
 tblelemobj,
 HTMLTableSectionElement*
 tfoot);

attribute
 HTMLTableSection
 Element tHead;

tblelemobj.tHead

tblelemobj.tHead
 = thead

ADOMHTMLTableSectionElement*
 ADOMgetTHead(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetTHead(
 ADOMHTMLTableElement*
 tblelemobj,
 HTMLTableSectionElement*
 thead);

attribute DOMString 
 width;

tblelemobj.width

tblelemobj.width
 = string

ADOMString ADOMgetWidth(
 ADOMHTMLTableElement*
 tblelemobj);

void ADOMsetWidth(
 ADOMHTMLTableElement*
 tblelemobj,
 ADOMString string);

HTMLTableRowElement interface

attribute DOMString
 align;

tblrowelemobj.align

tblrowelemobj.align =
 string

ADOMString ADOMgetAlign(
 ADOMHTMLTableRowElement*
 tblrowelemobj);

void ADOMsetAlign(
 ADOMHTMLTableRowElement* 
 tblrowelemobj,
 ADOMString string);

attribute DOMString
 bgColor;

tblrowelemobj.bgColor

tblrowelemobj.bgColor
 = string

ADOMString ADOMgetBgColor(
 ADOMHTMLTableRowElement*
 tblrowelemobj);

void ADOMsetBgColor(
 ADOMHTMLTableRowElement*
 tblrowelemobj,
 ADOMString string);

readonly attribute
 HTMLCollection
 cells;

tblrowelemobj.cells

ADOMHTMLCollection*
 ADOMgetCells(
 ADOMHTMLTableRowElement* 
 tblrowelemobj);

attribute DOMString
 ch;

tblrowelemobj.ch

tblrowelemobj.ch
 = string

ADOMString ADOMgetCh(
 ADOMHTMLTableRowElement*
 tblrowelemobj);

void ADOMsetCh(
 ADOMHTMLTableRowElement*
 tblrowelemobj,
 ADOMString string);

attribute DOMString
 chOff;

tblrowelemobj.chOff

tblrowelemobj.chOff
 = string

ADOMString ADOMgetChOff(
 ADOMHTMLTableRowElement*
 tblrowelemobj);

void ADOMsetChOff(
 ADOMHTMLTableRowElement*
 tblrowelemobj,
 ADOMString string);

void deleteCell(in
 long index);

tblrowelemobj.
 deleteCell(index)

void ADOMdeleteCell(
 ADOMHTMLTableRowElement*
 tblrowelemobj,
 ADOMInt32 index);

HTMLElement
 insertCell(in 
 long index);

tblrowelemobj.
 insertCell(index)

ADOMHTMLElement*
 ADOMinsertCell(
 ADOMHTMLTableRowElement*
 tblrowelemobj,
 ADOMInt32 index);

readonly attribute
 long rowIndex;

tblrowelemobj.rowIndex

ADOMInt32 ADOMgetRowIndex(
 ADOMHTMLTableRowElement*
 tblrowelemobj);

readonly attribute
 long 
 sectionRowIndex;

tblrowelemobj.
 sectionRowIndex

ADOMInt32
 ADOMgetSectionRowIndex(
 ADOMHTMLTableRowElement*
 tblrowelemobj);

attribute DOMString
 vAlign;

tblrowelemobj.vAlign

tblrowelemobj.vAlign =
 string

ADOMString ADOMgetVAlign(
 ADOMHTMLTableRowElement*
 tblrowelemobj);

void ADOMsetVAlign(
 ADOMHTMLTableRowElement*
 tblrowelemobj,
 ADOMString string);

HTMLTableSectionElement interface

attribute DOMString
 align;

tblsectelemobj.align

tblsectelemobj.align =
 string

ADOMString 
 ADOMgetAlign(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj);

void 
 ADOMsetAlign(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj,
 ADOMString string);

attribute DOMString
 ch;

tblsectelemobj.ch

tblsectelemobj.ch =
 string

ADOMString 
 ADOMgetCh(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj);

void 
 ADOMsetCh(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj,
 ADOMString string);

attribute DOMString
 chOff;

tblsectelemobj.chOff

tblsectelemobj.chOff =
 string

ADOMString 
 ADOMgetChOff(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj);

void 
 ADOMsetChOff(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj,
 ADOMString string);

void deleteRow(
 in long index);

tblsectelemobj.
 deleteRow(index)

void 
 ADOMdeleteRow(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj,
 ADOMInt32 index);

HTMLElement 
 insertRow(in 
 long index);

tblsectelemobj.
 insertRow(index)

ADOMHTMLElement*
 ADOMinsertRow(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj,
 ADOMInt32 index);

readonly attribute
 HTMLCollection rows;

tblsectelemobj.rows

ADOMHTMLCollection*
 ADOMgetRows(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj);

attribute DOMString
 vAlign;

tblsectelemobj.vAlign

tblsectelemobj.vAlign =
 string

ADOMString 
 ADOMgetVAlign(
 ADOMHTMLTableSection 
 Element*
 tblsectelemobj);

void 
 ADOMsetVAlign(
 ADOMHTMLTableSection
 Element*
 tblsectelemobj,
 ADOMString string);

HTMLTextAreaElement interface

attribute DOMString
 accessKey;

txtareaelemobj.
 accessKey

txtareaelemobj.
 accessKey = string

ADOMString ADOMgetAccessKey(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetAccessKey(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMString string);

void blur();

txtareaelemobj.blur()

void ADOMblur(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

attribute long
 cols;

txtareaelemobj.cols

txtareaelemobj.cols
 = cols

ADOMInt32 ADOMgetColsAsInt(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetColsAsInt(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMInt32 cols);

attribute DOMString
 defaultValue;

txtareaelemobj.
 defaultValue

txtareaelemobj.
 defaultValue = string

ADOMString
 ADOMgetDefaultValue(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetDefaultValue(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMString string);

attribute boolean
 disabled;

txtareaelemobj.disabled

txtareaelemobj.disabled
 = bool

ADOMBoolean ADOMgetDisabled(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetDisabled(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMBoolean bool);

void focus();

txtareaelemobj.focus()

void ADOMfocus(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

readonly attribute
 HTMLFormElement
 form;

txtareaelemobj.form

ADOMHTMLFormElement*
 ADOMgetForm(
 ADOMHTMLFormElement*
 formmobj);

attribute DOMString
 name;

txtareaelemobj.name

txtareaelemobj.name =
 string

ADOMString ADOMgetName(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetName(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMString string);

attribute boolean
 readOnly;

txtareaelemobj.readOnly

txtareaelemobj.readOnly
 = bool

ADOMBoolean ADOMgetReadOnly(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetReadOnly(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMBoolean bool);

attribute long
 rows;

txtareaelemobj.rows

txtareaelemobj.rows
 = rows

ADOMInt32 ADOMgetRowsAsInt(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetRowsAsInt(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMInt32 rows);

void select();

txtareaelemobj.select()

void ADOMselect(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

attribute long
 tabIndex;

txtareaelemobj.tabIndex

txtareaelemobj.tabIndex
 = tabindex

ADOMInt32 ADOMgetTabIndex(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetTabIndex(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMInt32 tabindex);

readonly attribute
 DOMString type;

txtareaelemobj.type

ADOMString ADOMgetType(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

attribute DOMString
 value;

txtareaelemobj.value

txtareaelemobj.value =
 string

ADOMString ADOMgetValue(
 ADOMHTMLTextAreaElement*
 txtareaelemobj);

void ADOMsetValue(
 ADOMHTMLTextAreaElement*
 txtareaelemobj,
 ADOMString string);

HTMLTitleElement interface

attribute DOMString
 text;

titleelemobj.text

titleelemobj.text
 = string

ADOMString ADOMgetText(
 ADOMHTMLTitleElement*
 titleelemobj);

void ADOMsetText(
 ADOMHTMLTitleElement*
 titleelemobj,
 ADOMString string);

HTMLUListElement interface

attribute boolean
 compact;

ulistelemobj.compact

ulistelemobj.compact
 = bool

ADOMBoolean ADOMgetCompact(
 ADOMHTMLUListElement*
 ulistelemobj);

void ADOMsetCompact(
 ADOMHTMLUListElement*
 ulistelemobj,
 ADOMBoolean bool);

attribute DOMString
 type;

ulistelemobj.type

ulistelemobj.type
 = string

ADOMString ADOMgetType(
 ADOMHTMLUListElement*
 ulistelemobj);

void ADOMsetType(
 ADOMHTMLUListElement* 
 ulistelemobj,
 ADOMString string);

Node interface

Node appendChild(
 in Node newChild)
 raises
 (DOMException);

nodeobj.appendChild(
 newChild)

ADOMNode* ADOMappendChild(
 ADOMNode* nodeobj,
 Node* newChild);

readonly attribute
 NamedNodeMap
 attributes;

nodeobj.attributes

ADOMNamedNodeMap*
 ADOMgetAttributes(
 ADOMNode* nodeobj);

readonly attribute
 NodeList
 childNodes;

nodeobj.childNodes

ADOMNodeList*
 ADOMgetChildNodes(
 ADOMNode* nodeobj);

Node cloneNode(
 in boolean deep);

nodeobj.cloneNode(deep)

ADOMNode* ADOMcloneNode(
 ADOMNode* nodeobj,
 ADOMBoolean deep);

readonly attribute
 Node firstChild;

nodeobj.firstChild

ADOMNode* ADOMgetFirstChild(
 ADOMNode* nodeobj);

boolean hasChildNodes();

nodeobj.hasChildNodes()

ADOMBoolean
 ADOMhasChildNodes(
 ADOMNode* nodeobj);

Node insertBefore(
 in Node newChild,
 in Node refChild)
 raises
 (DOMException);

nodeobj.insertBefore(
 newChild, refChild)

ADOMNode* ADOMinsertBefore(
 ADOMNode* nodeobj,
 ADOMNode* newChild,
 ADOMNode* refChild);

readonly attribute
 Node lastChild;

nodeobj.lastChild

ADOMNode* ADOMgetLastChild(
 ADOMNode* nodeobj);

readonly attribute
 Node nextSibling;

nodeobj.nextSibling

ADOMNode* 
 ADOMgetNextSibling(
 ADOMNode* nodeobj);

readonly attribute
 DOMString nodeName;

nodeobj.nodeName

ADOMString ADOMgetNodeName(
 ADOMNode* nodeobj);

readonly attribute
 unsigned short
 nodeType;

nodeobj.nodeType

ADOMUInt16
 ADOMgetNodeType(
 ADOMNode* nodeobj);

attribute DOMString 
 nodeValue;
 // raises
 (DOMException)
 on setting
 // raises
 (DOMException)
 on retrieval

nodeobj.nodeValue

nodeobj.nodeValue =
 string

ADOMString ADOMgetNodeValue(
 ADOMNode* nodeobj);

void ADOMsetNodeValue(
 ADOMNode* nodeobj,
 ADOMString string);

readonly attribute
 Document 
 ownerDocument;

nodeobj.ownerDocument

ADOMDocument*
 ADOMgetOwnerDocument(
 ADOMNode* nodeobj);

readonly attribute
 Node parentNode;

nodeobj.parentNode

ADOMNode* ADOMgetParentNode(
 ADOMNode* nodeobj);

readonly attribute
 Node 
 previousSibling;

nodeobj.previousSibling

ADOMNode*
 ADOMgetPreviousSibling(
 ADOMNode* nodeobj);

Node removeChild(in
 Node oldChild)
 raises
 (DOMException);

nodeobj.removeChild(
 oldChild)

ADOMNode* ADOMremoveChild(
 ADOMNode* nodeobj,
 ADOMNode* oldChild);

Node replaceChild(
 in Node newChild,
 in Node oldChild)
 raises
 (DOMException);

nodeobj.replaceChild(
 newChild, oldChild)

ADOMNode* ADOMreplaceChild(
 ADOMNode* nodeobj,
 ADOMNode* newChild,
 ADOMNode* oldChild);

NodeList interface

Node item(
 in unsigned 
 long index);

nodelistobj.item(index)

ADOMNode* ADOMitem(
 ADOMNodeList* nodelistobj,
 ADOMUInt32 index);

readonly attribute
 unsigned long
 length;

nodelistobj.length

ADOMUInt32 ADOMgetLength(
 ADOMNodeList* nodelistobj);

Text interface

Text splitText(
 in unsigned long
 offset)
 raises
 (DOMException);

textobj.splitText(
 offset)

Text* ADOMsplitText(
 ADOMText* textobj,
 ADOMUInt32 offset);

Send feedback about this page using email.