# (hey, emacs !  Please use -*- tab-width: 4; -*- thanks)
# This file is used to generate the enumeration DOM_Runtime::Prototype on domruntime.h,
# most of domprototypes.cpp, and parts of domglobaldata.{h,cpp}.
#
# Empty lines and lines starting with '#' are ignored (and stripped
# the next time this file is modified by the script that reads it.)
#
# The syntax is
#
#  group "name" [{CONDITION}]
#  {
#    PROTOTYPE: ClassName(display_name, [functions], [functions_with_data], [InitFunction]) [base=BASEPROTOTYPE] [{CONDITION}]
#  };
#
# "Name" is an informal name describing the group of prototypes (such
# as the name of the specification they come from).  PROTOTYPE is the
# name of the enumerator in DOM_Runtime::Prototype minus the
# "_PROTOTYPE" part.  ClassName is the name of the C++ class that has
# the enumerators FUNCTIONS_ARRAY_SIZE and
# FUNCTIONS_WITH_DATA_ARRAY_SIZE defining the number of functions the
# prototype has, and whose name, with '_functions' or
# '_functions_with_data' appended, forms the name of the arrays of
# function descriptions for the prototype.  BASEPROTOTYPE is the
# prototype object's own prototype (if it isn't Object.prototype).
#
# "Display_name" is the 'visible' name for the prototype, e.g. the
# name used in the prototype's 'toString'.
#
# If the name of the prototype is on the form "(NAME)", the prototype
# is not included in DOM_Runtime::Prototype or in domprototypes.cpp,
# but is really just a collection of functions referenced directly by
# some code somewhere (probably by the class itself, which then is
# likely a sub-class of DOM_Prototype itself.)
#
# Groups or individual prototypes can be conditional by appending
# {CONDITION} to the line that defines the group/prototype.  The text
# between the braces will be put prepended by a "#", so it can be any
# valid preprocessor directive, minus the "#".
#
# The order of prototypes and groups, or the actual groups themselves
# and their names, is all insignificant, code-wise.
#
# To regenerate other files after this is modified, simply run
# python modules/dom/scripts/prototypes.py

group "JavaScript"
{
  (WINDOW):    JS_WindowPrototype(Window, functions, functions_with_data)
  NAVIGATOR:   JS_Navigator(Navigator, functions, functions_with_data)
  HISTORY:     JS_History(History, functions_with_data)
  CONSOLE:     JS_Console(Console, functions, functions_with_data)
  LOCATION:    JS_Location(Location, PreparePrototype, functions, functions_with_data)
  PLUGINARRAY: JS_PluginArray(PluginArray, functions)
}

group "DOM 2 Core"
{
  NODE:                  DOM_Node(Node, functions, functions_with_data, ConstructNodeObjectL)
  DOCUMENT:              DOM_Document(Document, functions, functions_with_data, ConstructDocumentObjectL)     base=NODE
  DOCUMENTFRAGMENT:      DOM_DocumentFragment(DocumentFragment, functions_with_data)      base=NODE
  CHARACTERDATA:         DOM_CharacterData(CharacterData, functions)                      base=NODE
  ATTR:                  DOM_Attr(Attr)                                                   base=NODE
  ELEMENT:               DOM_Element(Element, functions, functions_with_data)             base=NODE
  TEXT:                  DOM_Text(Text, functions)                                        base=CHARACTERDATA
  COMMENT:               DOM_Comment(Comment)                                             base=CHARACTERDATA
  CDATASECTION:          DOM_CDATASection(CDATASection)                                   base=TEXT
  DOCUMENTTYPE:          DOM_DocumentType(DocumentType)                                   base=NODE
  NOTATION:              DOM_Notation(Notation)                                           base=NODE
  ENTITY:                DOM_Entity(Entity)                                               base=NODE
  ENTITYREFERENCE:       DOM_EntityReference(EntityReference)                             base=NODE
  PROCESSINGINSTRUCTION: DOM_ProcessingInstruction(ProcessingInstruction)                 base=NODE
  NODELIST:              DOM_Collection(NodeList, functions)
  NAMEDNODEMAP:          DOM_NamedNodeMap(NamedNodeMap, functions_with_data)
  XMLDOCUMENT:           DOM_XMLDocument(XMLDocument, functions)                          base=DOCUMENT
  DOMEXCEPTION:          DOM_DOMException(DOMException, ConstructDOMExceptionObjectL)     base=(ERROR)
  CLIENTRECT:            DOM_Object(ClientRect)
  CLIENTRECTLIST:        DOM_ClientRectList(ClientRectList, functions)
}

group "HTML5 Microdata"
{
	HTMLPROPERTIESCOLLECTION: DOM_HTMLPropertiesCollection(HTMLPropertiesCollection, functions) base=HTMLCOLLECTION
	HTMLPROPERTYNODELISTCOLLECTION: DOM_PropertyNodeList_Collection(PropertyNodeList, functions) base=NODELIST
}

group "DOM 3 Core"
{
  DOMCONFIGURATION: DOM_DOMConfiguration(DOMConfiguration, functions_with_data)
  DOMSTRINGLIST:    DOM_DOMStringList(DOMStringList, functions)
  DOMSTRINGMAP:     DOM_DOMStringMap(DOMStringMap)
  DOMTOKENLIST:     DOM_DOMTokenList(DOMTokenList, functions, functions_with_data)
  DOMSETTABLETOKENLIST: DOM_DOMSettableTokenList(DOMSettableTokenList) base=DOMTOKENLIST
}

group "DOM 2 Events"
{
  EVENT:                     DOM_Event(Event, functions, functions_with_data, ConstructEventObjectL)
  UIEVENT:                   DOM_UIEvent(UIEvent, functions)                                               base=EVENT
  MOUSEEVENT:                DOM_MouseEvent(MouseEvent, functions)                                         base=UIEVENT
  KEYBOARDEVENT:             DOM_KeyboardEvent(KeyboardEvent,  functions, ConstructKeyboardEventObjectL)   base=UIEVENT
  MUTATIONEVENT:             DOM_MutationEvent(MutationEvent, functions)                                   base=EVENT   {ifdef DOM2_MUTATION_EVENTS}
  PROGRESSEVENT:             DOM_ProgressEvent(ProgressEvent, functions)                                   base=EVENT   {ifdef PROGRESS_EVENTS_SUPPORT}
  TRANSITIONEVENT:           DOM_TransitionEvent(TransitionEvent, functions)                               base=EVENT   {ifdef CSS_TRANSITIONS}
  OTRANSITIONEVENT:          DOM_TransitionEvent(OTransitionEvent, functions)                              base=EVENT   {ifdef CSS_TRANSITIONS}
  WEBKITTRANSITIONEVENT:     DOM_TransitionEvent(WebKitTransitionEvent, functions)                         base=EVENT   {ifdef CSS_TRANSITIONS}
  ANIMATIONEVENT:            DOM_AnimationEvent(AnimationEvent, functions)                                 base=EVENT   {ifdef CSS_ANIMATIONS}
  HASHCHANGEEVENT:           DOM_HashChangeEvent(HashChangeEvent, functions)                               base=EVENT
  ERROREVENT:                DOM_ErrorEvent(ErrorEvent, functions)                                         base=EVENT
  CUSTOMEVENT:               DOM_CustomEvent(CustomEvent, functions)                                       base=EVENT
}

group "DOM 3 Events"
{
  TEXTEVENT:                 DOM_TextEvent(TextEvent, functions, ConstructTextEventObjectL) base=UIEVENT
}

group "DOM 2 HTML"
{
  HTMLCOLLECTION:                   DOM_HTMLCollection(HTMLCollection, functions) base=NODELIST
  HTMLOPTIONSCOLLECTION:            DOM_HTMLOptionsCollection(HTMLOptionsCollection, functions_with_data)       base=HTMLCOLLECTION
  HTMLDOCUMENT:                     DOM_HTMLDocument(HTMLDocument, functions, functions_with_data)              base=DOCUMENT
  HTMLELEMENT:                      DOM_HTMLElement(HTMLElement, functions, ConstructHTMLElementPrototypeL)                                     base=ELEMENT
}

group "DOM 2 CSS"
{
  CSSSTYLEDECLARATION: DOM_CSSStyleDeclaration(CSSStyleDeclaration, functions)
  CSSSTYLESHEET:       DOM_CSSStyleSheet(CSSStyleSheet, functions)
  CSSRULELIST:         DOM_CSSRuleList(CSSRuleList, functions)
  CSSRULE:             DOM_CSSRule(CSSRule, ConstructCSSRuleObjectL)
  CSSCONDITIONALRULE:  DOM_CSSConditionalRule(CSSConditionalRule, functions)                               base=CSSRULE
  CSSMEDIARULE:        DOM_CSSMediaRule(CSSMediaRule)                                                      base=CSSCONDITIONALRULE
  CSSSUPPORTSRULE:     DOM_CSSSupportsRule(CSSSupportsRule)                                                base=CSSCONDITIONALRULE
  CSSKEYFRAMESRULE:    DOM_CSSKeyframesRule(CSSKeyframesRule, functions)                                   base=CSSRULE {ifdef CSS_ANIMATIONS}
  CSSMATRIX:           DOM_CSSMatrix(CSSMatrix, functions)                                                              {ifdef CSS_TRANSFORMS}
}

group "DOM 2 Traversal & Range"
{
  NODEFILTER:     DOM_NodeFilter(NodeFilter, ConstructNodeFilterObjectL)                  {ifdef DOM2_TRAVERSAL}
  NODEITERATOR:   DOM_NodeIterator(NodeIterator, functions, functions_with_data)          {ifdef DOM2_TRAVERSAL}
  TREEWALKER:     DOM_TreeWalker(TreeWalker, functions_with_data)                         {ifdef DOM2_TRAVERSAL}
  RANGE:          DOM_Range(Range, functions, functions_with_data, ConstructRangeObjectL) {ifdef DOM2_RANGE}
}

group "DOM 2 Style Sheets"
{
  STYLESHEETLIST: DOM_StyleSheetList(StyleSheetList, functions)
  MEDIALIST:      DOM_MediaList(MediaList, functions)
}

group "CSSOM View"
{
  MEDIAQUERYLIST: DOM_MediaQueryList(MediaQueryList, functions)
}

group "DOM 3 Load & Save and extras"
{
  LSEXCEPTION:    LSException(LSException) base=(ERROR) {ifdef DOM3_LOAD}
  LSPARSER:       DOM_LSParser(LSParser, functions, functions_with_data) {ifdef DOM3_LOAD}
  DOMPARSER:      DOM_DOMParser(DOMParser, functions) {ifdef DOM3_LOAD}
  LSSERIALIZER:   DOM_LSSerializer(LSSerializer, functions_with_data) {ifdef DOM3_SAVE}
  XMLSERIALIZER:  DOM_XMLSerializer(XMLSerializer, functions) {ifdef DOM3_SAVE}
  XMLHTTPREQUEST: DOM_XMLHttpRequest(XMLHttpRequest, functions, functions_with_data, ConstructXMLHttpRequestObjectL) {ifdef DOM_HTTP_SUPPORT}
  XMLHTTPREQUESTUPLOAD: DOM_XMLHttpRequestUpload(XMLHttpRequestUpload, functions, functions_with_data) {if defined DOM_HTTP_SUPPORT && defined PROGRESS_EVENTS_SUPPORT}
  ANONXMLHTTPREQUEST: DOM_XMLHttpRequest(AnonXMLHttpRequest) base=XMLHTTPREQUEST {ifdef DOM_HTTP_SUPPORT}
  FORMDATA:       DOM_FormData(FormData, functions) {ifdef DOM_HTTP_SUPPORT}
}

group "DOM 3 XPath" {ifdef DOM3_XPATH}
{
  XPATHEVALUATOR:       DOM_XPathEvaluator(XPathEvaluator, functions, functions_with_data)
  XPATHEXCEPTION:       DOM_XPathException(XPathException)     base=(ERROR)
  XPATHEXPRESSION:      DOM_XPathExpression(XPathExpression, functions)
  XPATHNSRESOLVER:      DOM_XPathNSResolver(XPathNSResolver, functions)
  XPATHRESULT:          DOM_XPathResult(XPathResult, functions_with_data)
  XPATHNAMESPACE:       DOM_XPathNamespace(XPathNamespace)           base=NODE
  XPATHRESULT_NODELIST: DOM_XPathResult_NodeList(XPathResultNodeList, functions)
}

group "Canvas" {ifdef CANVAS_SUPPORT}
{
  CANVASCONTEXT2D:     DOMCanvasContext2D(CanvasRenderingContext2D, functions)
  CANVASGRADIENT:      DOMCanvasGradient(CanvasGradient, functions)
  CANVASPATTERN:       DOMCanvasPattern(CanvasPattern)
  CANVASIMAGEDATA:     DOMCanvasImageData(ImageData)
  TEXTMETRICS:         DOM_Object(TextMetrics)
}

group "Canvas3D" {ifdef CANVAS3D_SUPPORT}
{
  CANVASCONTEXTWEBGL:      DOMCanvasContextWebGL(WebGLRenderingContext, functions, ConstructCanvasContextWebGLObjectL)
  WEBGLCONTEXTATTRIBUTES:  DOMWebGLContextAttributes(WebGLContextAttributes)
  WEBGLOBJECT:             DOMWebGLObject(WebGLObject)
  WEBGLBUFFER:             DOMWebGLBuffer(WebGLBuffer)
  WEBGLEXTENSION:          DOMWebGLExtension(WebGLExtension)
  WEBGLFRAMEBUFFER:        DOMWebGLFramebuffer(WebGLFramebuffer)
  WEBGLPROGRAM:            DOMWebGLProgram(WebGLProgram)
  WEBGLRENDERBUFFER:       DOMWebGLRenderbuffer(WebGLRenderbuffer)
  WEBGLSHADER:             DOMWebGLShader(WebGLShader)
  WEBGLTEXTURE:            DOMWebGLTexture(WebGLTexture)
  WEBGLUNIFORMLOCATION:    DOMWebGLUniformLocation(WebGLUniformLocation)
  WEBGLACTIVEINFO:         DOMWebGLActiveInfo(WebGLActiveInfo)
}

group "SVG" {ifdef SVG_DOM}
{
  SVGDOCUMENT:            DOM_SVGDocument(SVGDocument)       base=DOCUMENT
  SVGEXCEPTION:           DOM_SVGException(SVGException)     base=(ERROR)
  SVGELEMENT:             DOM_SVGElement(SVGElement)       base=ELEMENT
  SVGOBJECT:              DOM_SVGObject(SVGObject)
  SVGLIST:                DOM_SVGList(SVGList, functions)                                   {ifdef SVG_FULL_11}
  SVGSTRINGLIST:          DOM_SVGStringList(SVGStringList, functions)                             {ifdef SVG_FULL_11}
  SVGELEMENTINSTANCE:     DOM_SVGElementInstance(SVGElementInstance, functions, functions_with_data)
  SVGELEMENTINSTANCELIST: DOM_SVGElementInstanceList(SVGElementInstanceList, functions)                    {ifdef SVG_FULL_11}
  TIMEEVENT:              DOM_TimeEvent(TimeEvent, functions)     base=EVENT
}

group "Debugger" {ifdef DOM_DEBUGGER_SUPPORT}
{
  DEBUGGER: DOM_Debugger(Debugger, functions)
}

group "TextRange" {ifdef DOM_SELECTION_SUPPORT}
{
  WINDOWSELECTION:   DOM_WindowSelection(Selection, functions, functions_with_data)
}

group "Proprietary XSLT support" {ifdef DOM_XSLT_SUPPORT}
{
  XSLTPROCESSOR: DOM_XSLTProcessor(XSLTProcessor, functions, functions_with_data)
}

group "UPnP Services Discovery" {if defined UPNP_SUPPORT && defined UPNP_SERVICE_DISCOVERY}
{
  DEVICEDESCRIPTOR: DOM_DeviceDescriptor(DeviceDescriptor, ConstructDeviceDescriptorL)
  SERVICEDESCRIPTOR: DOM_ServiceDescriptor(ServiceDescriptor, ConstructServiceDescriptorL)
  UPNPCOLLECTION: DOM_UPnPCollection(UPnPCollection)
}

group "WebFeeds support" {ifdef WEBFEEDS_BACKEND_SUPPORT}
{
  WEBFEEDS: DOM_WebFeeds(WebFeeds, functions)
  FEEDLIST: DOM_FeedList(FeedList, functions)
  FEED: DOM_Feed(Feed, functions)
  FEEDENTRYLIST: DOM_FeedEntryList(FeedEntryList, functions)
  FEEDENTRY: DOM_FeedEntry(FeedEntry, functions)
  FEEDCONTENT: DOM_FeedContent(FeedContent)
  FEEDREADERLIST: DOM_FeedReaderList(FeedReaderList, functions) {ifdef WEBFEEDS_EXTERNAL_READERS}
  FEEDREADER: DOM_FeedReader(FeedReader, functions) {ifdef WEBFEEDS_EXTERNAL_READERS}
}

group "WebServer support" {ifdef WEBSERVER_SUPPORT}
{
  WEBSERVERREQUEST: DOM_WebServerRequest(WebServerRequest, functions)
  WEBSERVERRESPONSE: DOM_WebServerResponse(WebServerResponse, functions)
  WEBSERVERUPLOADEDFILE: DOM_WebServerUploadedFile(WebServerUploadedFile, functions)
  WEBSERVERSESSION: DOM_WebServerSession(WebServerSession, functions)
  WEBSERVERCONNECTION: DOM_WebServerConnection(WebServerConnection)
  WEBSERVERARRAY: DOM_WebServerArray(WebServerArray)
  WEBSERVERCOLLECTION: DOM_WebServerCollection(WebServerCollection)
  WEBSERVERSERVICEDESCRIPTOR: DOM_WebServerServiceDescriptor(WebServerServiceDescriptor)
}

group "Gadget support" {ifdef GADGET_SUPPORT}
{
  WIDGET:          DOM_Widget(Widget)
  WIDGETICON:      DOM_WidgetIcon(WidgetIcon, functions_with_data)
  WIDGETWINDOW:    DOM_WidgetWindow(WidgetWindow, functions, functions_with_data)
  WIDGETCOLLECTION: DOM_WidgetCollection(WidgetCollection)
}

group "Gadget Manager support" {if defined DOM_WIDGETMANAGER_SUPPORT || defined DOM_UNITEAPPMANAGER_SUPPORT || defined EXTENSION_MANAGER_SUPPORT}
{
  WIDGETMANAGER:   DOM_WidgetManager(WidgetManager, functions)
}

group "Opera Account support" {if defined DOM_ACCOUNTMANAGER_SUPPORT}
{
  OPERAACCOUNTMANAGER: DOM_OperaAccountManager(OperaAccountManager, functions)
}

group "Unite support" {if defined DOM_UNITEDEVMANAGER_SUPPORT}
{
  UNITEDEVICEMANAGER: DOM_UniteDeviceManager(UniteDeviceManager, functions)
}

group "IO support" {if defined DOM_GADGET_FILE_API_SUPPORT || defined WEBSERVER_SUPPORT}
{
  IO:                  DOM_IO(IO)
  BYTEARRAY:           DOM_ByteArray(ByteArray)
}

group "Gadget File API support" {if defined DOM_GADGET_FILE_API_SUPPORT}
{
  GADGETFILE:          DOM_GadgetFile(GadgetFile, functions, functions_with_data)
  FILESTREAM:          DOM_FileStream(FileStream, functions, functions_with_data)
  FILESYSTEM:          DOM_FileSystem(FileSystem, functions, functions_with_data)
}

group "File API support"
{
  BLOB:                DOM_Blob(Blob, functions)
  FILE:                DOM_File(File) base=BLOB
  FILELIST:            DOM_FileList(FileList, functions)
  FILEREADER:          DOM_FileReader(FileReader, functions, functions_with_data, ConstructFileReaderObjectL)
  FILEREADERSYNC:      DOM_FileReaderSync(FileReaderSync, functions_with_data)
  FILEERROR:           DOM_FileError(FileError, ConstructFileErrorObjectL)
  FILEEXCEPTION:       DOM_FileException(FileException, ConstructFileExceptionObjectL) base=(ERROR)
}

group "Media" {ifdef MEDIA_HTML_SUPPORT}
{
  MEDIAERROR:	    DOM_MediaError(MediaError, ConstructMediaErrorObjectL)
  TIMERANGES:       DOM_TimeRanges(TimeRanges, functions_with_data)
  TEXTTRACK:	    DOM_TextTrack(TextTrack, functions, functions_with_data)
  TEXTTRACKLIST:    DOM_TextTrackList(TextTrackList, functions, functions_with_data)
  TEXTTRACKCUE:	    DOM_TextTrackCue(TextTrackCue, functions, functions_with_data)
  TEXTTRACKCUELIST:	DOM_TextTrackCueList(TextTrackCueList, functions)
  TRACKEVENT:       DOM_TrackEvent(TrackEvent) base=EVENT
}

group "Geolocation support" {if defined(DOM_GEOLOCATION_SUPPORT) && defined(PI_GEOLOCATION)}
{
  GEOLOCATION:		DOM_Geolocation(Geolocation, functions)
  POSITION:			DOM_Position(Position)
  COORDINATES:      DOM_Coordinates(Coordinates)
  POSITIONERROR:	DOM_PositionError(PositionError)
}

group "HTML5 Client-side Storage" {ifdef CLIENTSIDE_STORAGE_SUPPORT}
{
  STORAGE:        DOM_Storage(Storage, functions)
  STORAGE_USERJS: DOM_Storage(StorageUserJS, functions) {ifdef WEBSTORAGE_USER_SCRIPT_STORAGE_SUPPORT}
  STORAGEEVENT:   DOM_StorageEvent(StorageEvent, functions) base=EVENT
}

group "HTML5 Database Storage"  {ifdef DATABASE_STORAGE_SUPPORT}
{
  DATABASE:		DOM_Database(Database, functions, functions_with_data)
  SQLTRANSACTION:	DOM_SQLTransaction(SQLTransaction, functions)
  SQLRESULTSET:	DOM_SQLResultSet(SQLResultSet)
  SQLRESULTSETROWLIST: DOM_SQLResultSetRowList(SQLResultSetRowList, functions)
  SQLERROR:		DOM_SQLError(SQLError, ConstructSQLErrorObjectL)
}

group "JIL API support" {ifdef DOM_JIL_API_SUPPORT}
{
    JIL_ACCELEROMETERINFO:  DOM_JILAccelerometerInfo(JILAccelerometerInfo)
    JIL_ACCOUNTINFO:        DOM_JILAccountInfo(JILAccountInfo)
    JIL_ADDRESSBOOKITEM:    DOM_JILAddressBookItem(JILAddressBookItem, functions)
    JIL_ATTACHMENT:         DOM_JILAttachment(JILAttachment)
    JIL_AUDIOPLAYER:        DOM_JILAudioPlayer(JILAudioPlayer, functions) {ifdef MEDIA_JIL_PLAYER_SUPPORT}
    JIL_CALENDARITEM:       DOM_JILCalendarItem(JILCalendarItem, functions)
    JIL_CALLRECORD:         DOM_JILCallRecord(JILCallRecord)
    JIL_CALLRECORDTYPES:    DOM_JILCallRecordTypes(JILCallRecordTypes)
    JIL_CAMERA:             DOM_JILCamera(JILCamera, functions) {ifdef JIL_CAMERA_SUPPORT}
    JIL_CONFIG:             DOM_JILConfig(JILConfig, functions)
    JIL_DATANETWORKINFO:    DOM_JILDataNetworkInfo(JILDataNetworkInfo, functions)
    JIL_DEVICE:             DOM_JILDevice(JILDevice, functions)
    JIL_DEVICEINFO:         DOM_JILDeviceInfo(JILDeviceInfo)
    JIL_DEVICESTATEINFO:    DOM_JILDeviceStateInfo(JILDeviceStateInfo, functions)
    JIL_EMAILACCOUNT:       DOM_JILEmailAccount(JILEmailAccount)
    JIL_EXCEPTION:          DOM_JILException(JILException)          base=(ERROR)
    JIL_FILE:               DOM_JILFile(JILFile)
    JIL_MESSAGE:            DOM_JILMessage(JILMessage, functions)
    JIL_MESSAGEFOLDERTYPES: DOM_JILMessageFolderTypes(JILMessageFolderTypes)
    JIL_MESSAGEQUANTITIES:  DOM_JILMessageQuantities(JILMessageQuantities)
    JIL_MESSAGETYPES:       DOM_JILMessageTypes(JILMessageTypes)
    JIL_MESSAGING:          DOM_JILMessaging(JILMessaging, functions)
    JIL_MULTIMEDIA:         DOM_JILMultimedia(JILMultimedia) {ifndef MEDIA_JIL_PLAYER_SUPPORT}
    JIL_MULTIMEDIA:         DOM_JILMultimedia(JILMultimedia, functions) {ifdef MEDIA_JIL_PLAYER_SUPPORT}
    JIL_PIM:                DOM_JILPIM(JILPIM, functions)
    JIL_POSITIONINFO:       DOM_JILPositionInfo(JILPositionInfo)
    JIL_POWERINFO:          DOM_JILPowerInfo(JILPowerInfo)
    JIL_RADIOINFO:          DOM_JILRadioInfo(JILRadioInfo)
    JIL_TELEPHONY:          DOM_JILTelephony(JILTelephony, functions)
    JIL_VIDEOPLAYER:        DOM_JILVideoPlayer(JILVideoPlayer, functions) {ifdef MEDIA_JIL_PLAYER_SUPPORT}
    JIL_WIDGET:             DOM_JILWidget(JILWidget, functions)
}

group "HTML 5 Offline Web Application" {ifdef APPLICATION_CACHE_SUPPORT}
{
  APPLICATIONCACHE:      DOM_ApplicationCache(ApplicationCache, functions, functions_with_data, ConstructApplicationCacheObjectL)
}

group "WebSocket" {ifdef WEBSOCKETS_SUPPORT}
{
	WEBSOCKET:		DOM_WebSocket(WebSocket, functions, functions_with_data, ConstructWebSocketObjectL)
	CLOSEEVENT:		DOM_CloseEvent(CloseEvent, functions) base=EVENT
}

group "HTML5 Web Workers"  {ifdef DOM_WEBWORKERS_SUPPORT}
{
	(WEBWORKERS_DEDICATED):      DOM_DedicatedWorkerGlobalScope(WorkerGlobalScope, functions, functions_with_data)
	(WEBWORKERS_SHARED):         DOM_SharedWorkerGlobalScope(WorkerGlobalScope, functions, functions_with_data)
	WEBWORKERS_DEDICATED_OBJECT: DOM_DedicatedWorkerObject(Worker, functions, functions_with_data)
	WEBWORKERS_SHARED_OBJECT:    DOM_SharedWorkerObject(SharedWorker, functions, functions_with_data)
	WEBWORKERS_LOCATION:         JS_Location_Worker(WorkerLocation, functions)
	WEBWORKERS_NAVIGATOR:        JS_Navigator_Worker(WorkerNavigator)
}

group "HTML5 Cross Document Messaging"  {ifdef DOM_CROSSDOCUMENT_MESSAGING_SUPPORT}
{
	CROSSDOCUMENT_MESSAGECHANNEL: DOM_MessageChannel(MessageChannel)
	CROSSDOCUMENT_MESSAGEEVENT:   DOM_MessageEvent(MessageEvent, functions) base=EVENT
	CROSSDOCUMENT_MESSAGEPORT:    DOM_MessagePort(MessagePort, functions, functions_with_data)
}

group "HTML5 Server-Sent Events" {ifdef EVENT_SOURCE_SUPPORT}
{
	EVENTSOURCE: DOM_EventSource(EventSource, functions, functions_with_data, ConstructEventSourceObjectL)
}

group "Touch Events support" {ifdef TOUCH_EVENTS_SUPPORT}
{
        TOUCH:          DOM_Touch(Touch)
        TOUCHLIST:      DOM_TouchList(TouchList, functions)
        TOUCHEVENT:     DOM_TouchEvent(TouchEvent, functions) base=UIEVENT
}

group "Extension support" {ifdef EXTENSION_SUPPORT}
{
  EXTENSION:                     DOM_Extension(Extension, functions, functions_with_data)
  EXTENSION_BACKGROUND:          DOM_ExtensionBackground(Extension, functions, functions_with_data)
  EXTENSION_CONTEXT:             DOM_ExtensionContext(Context, functions)
  EXTENSION_SPEEDDIAL_CONTEXT:   DOM_ExtensionSpeedDialContext(SpeedDialContext)
  EXTENSION_CONTEXTS:            DOM_ExtensionContexts(Contexts)
  EXTENSION_PAGE_CONTEXT:        DOM_ExtensionPageContext(Extension, functions, functions_with_data)
  (EXTENSION_SCOPE):             DOM_ExtensionScopePrototype(ExtensionScope, functions_with_data)
  EXTENSION_UIBADGE:             DOM_ExtensionUIBadge(Badge, functions)
  EXTENSION_UIITEM:              DOM_ExtensionUIItem(UIItem, functions, functions_with_data)
  EXTENSION_UIITEM_EVENT:        DOM_ExtensionUIItemEvent(UIItemEvent, functions) base=EVENT
  EXTENSION_UIPOPUP:             DOM_ExtensionUIPopup(Popup, functions)
  EXTENSION_URLFILTER:           DOM_ExtensionURLFilter(URLFilter, ConstructExtensionURLFilterL, functions_with_data) {ifdef URL_FILTER}
  EXTENSION_URLFILTER_EVENT:     DOM_ExtensionURLFilterEvent(URLFilterEvent) {ifdef URL_FILTER}
  EXTENSION_RULELIST:            DOM_ExtensionRuleList(RuleList, functions) {ifdef URL_FILTER}
  EXTENSION_RULEOPTIONS:         DOM_ExtensionRuleOptions(RuleOptions) {ifdef URL_FILTER}
}

group "Tabs & windows API" {ifdef DOM_EXTENSIONS_TAB_API_SUPPORT}
{
  BROWSER_TAB:                   DOM_BrowserTab(BrowserTab, functions)
  BROWSER_TAB_MANAGER:           DOM_BrowserTabManager(BrowserTabManager, functions, functions_with_data)
  BROWSER_TAB_EVENT:             DOM_BrowserTabEvent(BrowserTabEvent) base=EVENT
  BROWSER_TAB_GROUP:             DOM_BrowserTabGroup(BrowserTabGroup, functions)
  BROWSER_TAB_GROUP_MANAGER:     DOM_BrowserTabGroupManager(BrowserTabGroupManager, functions, functions_with_data)
  BROWSER_TAB_GROUP_EVENT:       DOM_BrowserTabGroupEvent(BrowserTabGroupEvent)  base=EVENT
  BROWSER_WINDOW:                DOM_BrowserWindow(BrowserWindow, functions)
  BROWSER_WINDOW_MANAGER:        DOM_BrowserWindowManager(BrowserWindowManager, functions, functions_with_data)
  BROWSER_WINDOW_EVENT:          DOM_BrowserWindowEvent(BrowserWindowEvent)  base=EVENT
}

group "Extension Context Menu API" {ifdef DOM_EXTENSIONS_CONTEXT_MENU_API_SUPPORT}
{
  EXTENSION_MENUCONTEXT:          DOM_ExtensionMenuContext(MenuContext, functions, functions_with_data)
  EXTENSION_ROOTMENUCONTEXT:      DOM_ExtensionRootMenuContext(RootMenuContext, functions) base=EXTENSION_MENUCONTEXT
  EXTENSION_MENUITEM:             DOM_ExtensionMenuItem(MenuItem) base=EXTENSION_MENUCONTEXT
  EXTENSION_MENUCONTEXT_PROXY:    DOM_ExtensionMenuContextProxy(MenuContextProxy, functions_with_data)
  EXTENSION_MENUITEM_PROXY:       DOM_ExtensionMenuItem(MenuItemProxy) base=EXTENSION_MENUCONTEXT_PROXY
}

group "HTML5 History"
{
  POPSTATEEVENT:          DOM_PopStateEvent(PopStateEvent, functions) base=EVENT
}

group "DOMPerformance" {ifdef DOM_WINDOW_PERFORMANCE_OBJECT_SUPPORT}
{
	PERFORMANCE:		DOM_Performance(Performance, functions)
}

group "Stream API support" {ifdef DOM_STREAM_API_SUPPORT}
{
	LOCALMEDIASTREAM:    DOM_LocalMediaStream(LocalMediaStream, functions, functions_with_data)
}

group "DeviceOrientation Event" {ifdef DOM_DEVICE_ORIENTATION_EVENT_SUPPORT}
{
  DEVICEORIENTATION_EVENT:   DOM_DeviceOrientationEvent(DeviceOrientationEvent, functions) base=EVENT
  DEVICEMOTION_EVENT:        DOM_DeviceMotionEvent(DeviceMotionEvent, functions) base=EVENT
}

group "Search Suggestions Support" {ifdef DOC_SEARCH_SUGGESTIONS_SUPPORT}
{
  SEARCHSUGGESTS:		  DOM_SearchSuggestionsEvent(SearchSuggestionsEvent) base=EVENT
}

group "Paged display" {ifdef PAGED_MEDIA_SUPPORT}
{
  PAGEEVENT: DOM_PageEvent(PageChangeEvent, functions) base=EVENT
}

group "HTML5 Data Transfer" {if defined(DRAG_SUPPORT) || defined(USE_OP_CLIPBOARD)}
{
  DATATRANSFER:      DOM_DataTransfer(DataTransfer, functions, functions_with_data)
  DATATRANSFERITEM:  DOM_DataTransferItem(DataTransferItem, functions_with_data)
  DATATRANSFERITEMS: DOM_DataTransferItems(DataTransferItemList, functions)
}

group "HTML5 DND" {ifdef DRAG_SUPPORT}
{
  DRAGEVENT:         DOM_DragEvent(DragEvent, functions) base=MOUSEEVENT
}

group "Clipboard Event" {ifdef USE_OP_CLIPBOARD}
{
  CLIPBOARDEVENT:         DOM_ClipboardEvent(ClipboardEvent, functions) base=EVENT
}
