[W3C] Document Object Model (DOM) Level 3 Events Specification Version 1.0 W3C Working Draft 31 March 2003 This version: http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331 Latest version: http://www.w3.org/TR/DOM-Level-3-Events Previous version: http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030221/ Editors: Philippe Le Hégaret, W3C Tom Pixley, Netscape Communications Corporation (until July 2002) This document is also available in these non-normative formats: XML file, plain text, PostScript file, PDF file, single HTML file, and ZIP file. Copyright ©2003 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply. ---------------------------------------------------------------------------- Abstract This specification defines the Document Object Model Events Level 3, a generic platform- and language-neutral event system which allows registration of event handlers, describes event flow through a tree structure, and provides basic contextual information for each event. The Document Object Model Events Level 3 builds on the Document Object Model Events Level 2 [DOM Level 2 Events]. Status of this document This section describes the status of this document at the time of its publication. Other documents may supersede this document. The latest status of this document series is maintained at the W3C. This document contains the Document Object Model Level 3 Events specification. This is a Last Call Working Draft for review by W3C members and other interested parties. The Last Call review period ends on 1 May 2003. The list of issues is also available. Please, send your comments on this document to the public mailing list www-dom@w3.org. An archive is available at http://lists.w3.org/Archives/Public/www-dom/. It is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to use W3C Working Drafts as reference material or to cite them as other than "work in progress". This is work in progress and does not imply endorsement by, or the consensus of, either W3C or members of the DOM Working Group. Patent disclosures relevant to this specification may be found on the Working Group's patent disclosure page. This document has been produced as part of the W3C DOM Activity. The authors of this document are the DOM Working Group members. A list of current W3C Recommendations and other technical documents can be found at http://www.w3.org/TR. Table of contents * Expanded Table of Contents * W3C Copyright Notices and Licenses * 1. Document Object Model Events * Appendix A: Key identifiers for keyboard events. * Appendix B: Changes * Appendix C: IDL Definitions * Appendix D: Java Language Binding * Appendix E: ECMAScript Language Binding * Glossary * References * Index 31 March 2003 Expanded Table of Contents * Expanded Table of Contents * W3C Copyright Notices and Licenses o W3C® Document Copyright Notice and License o W3C® Software Copyright Notice and License o W3C® Short Software Notice * 1. Document Object Model Events o 1.1. Introduction + 1.1.1. Event flows + 1.1.2. Conformance o 1.2. DOM event flow + 1.2.1. Phases + 1.2.2. Event listeners o 1.3. Default actions and cancelable events o 1.4. Event types + 1.4.1. Event types and event categories + 1.4.2. Complete list of event types + 1.4.3. Compatibility with DOM Level 2 Events o 1.5. Event listener registration + 1.5.1. Using the EventTarget methods + 1.5.2. Using XML Events + 1.5.3. Using VoiceXML Events + 1.5.4. Using XML or HTML attributes o 1.6. Basic interfaces + 1.6.1. Event creation o 1.7. Event module definitions + 1.7.1. User Interface event types + 1.7.2. Text events + 1.7.3. Mouse event types + 1.7.4. Keyboard event types + 1.7.5. Mutation and mutation name event types + 1.7.6. Basic event types + 1.7.7. HTML Events * Appendix A: Key identifiers for keyboard events. o A.1. Introduction + A.1.1. Modifier keys + A.1.2. Dead keys + A.1.3. Input Method Editors + A.1.4. Guidelines for defining key identifiers o A.2. Key identifiers set * Appendix B: Changes o B.1. Changes between DOM Level 2 Events and DOM Level 3 Events + B.1.1. Changes to DOM Level 2 event flow + B.1.2. Changes to DOM Level 2 event types + B.1.3. Changes to DOM Level 2 Events interfaces + B.1.4. New Interfaces * Appendix C: IDL Definitions * Appendix D: Java Language Binding * Appendix E: ECMAScript Language Binding * Glossary * References o 1. Normative references o 2. Informative references * Index 31 March 2003 W3C Copyright Notices and Licenses Copyright © 2003 World Wide Web Consortium, (Massachusetts Institute of Technology, European Research Consortium for Informatics and Mathematics, Keio University). All Rights Reserved. This document is published under the W3C® Document Copyright Notice and License. The bindings within this document are published under the W3C® Software Copyright Notice and License. The software license requires "Notice of any changes or modifications to the W3C files, including the date changes were made." Consequently, modified versions of the DOM bindings must document that they do not conform to the W3C standard; in the case of the IDL definitions, the pragma prefix can no longer be 'w3c.org'; in the case of the Java language binding, the package names can no longer be in the 'org.w3c' package. ------- W3C® Document Copyright Notice and License Note: This section is a copy of the W3C® Document Notice and License and could be found at http://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231. Copyright © 2003 World Wide Web Consortium, (Massachusetts Institute of Technology, European Research Consortium for Informatics and Mathematics, Keio University). All Rights Reserved. http://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231 Public documents on the W3C site are provided by the copyright holders under the following license. By using and/or copying this document, or the W3C document from which this statement is linked, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions: Permission to copy, and distribute the contents of this document, or the W3C document from which this statement is linked, in any medium for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the document, or portions thereof, that you use: 1. A link or URL to the original W3C document. 2. The pre-existing copyright notice of the original author, or if it doesn't exist, a notice (hypertext is preferred, but a textual representation is permitted) of the form: "Copyright © [$date-of-document] World Wide Web Consortium, (Massachusetts Institute of Technology, European Research Consortium for Informatics and Mathematics, Keio University). All Rights Reserved. http://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231" 3. If it exists, the STATUS of the W3C document. When space permits, inclusion of the full text of this NOTICE should be provided. We request that authorship attribution be provided in any software, documents, or other items or products that you create pursuant to the implementation of the contents of this document, or any portion thereof. No right to create modifications or derivatives of W3C documents is granted pursuant to this license. However, if additional requirements (documented in the Copyright FAQ) are satisfied, the right to create modifications or derivatives is sometimes granted by the W3C to individuals complying with those requirements. THIS DOCUMENT IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF THE DOCUMENT ARE SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE DOCUMENT OR THE PERFORMANCE OR IMPLEMENTATION OF THE CONTENTS THEREOF. The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to this document or its contents without specific, written prior permission. Title to copyright in this document will at all times remain with copyright holders. ------- W3C® Software Copyright Notice and License Note: This section is a copy of the W3C® Software Copyright Notice and License and could be found at http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 Copyright © 2003 World Wide Web Consortium, (Massachusetts Institute of Technology, European Research Consortium for Informatics and Mathematics, Keio University). All Rights Reserved. http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 This work (and included software, documentation such as READMEs, or other related items) is being provided by the copyright holders under the following license. By obtaining, using and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions. Permission to copy, modify, and distribute this software and its documentation, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the software and documentation or portions thereof, including modifications: 1. The full text of this NOTICE in a location viewable to users of the redistributed or derivative work. 2. Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, the W3C® Short Software Notice should be included (hypertext is preferred, text is permitted) within the body of any redistributed or derivative code. 3. Notice of any changes or modifications to the files, including the date changes were made. (We recommend you provide URIs to the location from which the code is derived.) THIS SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENTATION. The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the software without specific, written prior permission. Title to copyright in this software and any associated documentation will at all times remain with copyright holders. W3C® Short Software Notice Note: This section is a copy of the W3C® Short Software Notice and could be found at http://www.w3.org/Consortium/Legal/2002/copyright-software-short-notice-20021231 Copyright © 2003 World Wide Web Consortium, (Massachusetts Institute of Technology, European Research Consortium for Informatics and Mathematics, Keio University). All Rights Reserved. Copyright © [$date-of-software] World Wide Web Consortium, (Massachusetts Institute of Technology, European Research Consortium for Informatics and Mathematics, Keio University). All Rights Reserved. This work is distributed under the W3C® Software License [1] 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. [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 31 March 2003 1. Document Object Model Events Editors: Philippe Le Hégaret, W3C Tom Pixley, Netscape Communications Corporation (until July 2002) Table of contents * 1.1. Introduction o 1.1.1. Event flows o 1.1.2. Conformance * 1.2. DOM event flow o 1.2.1. Phases o 1.2.2. Event listeners * 1.3. Default actions and cancelable events * 1.4. Event types o 1.4.1. Event types and event categories o 1.4.2. Complete list of event types o 1.4.3. Compatibility with DOM Level 2 Events * 1.5. Event listener registration o 1.5.1. Using the EventTarget methods o 1.5.2. Using XML Events o 1.5.3. Using VoiceXML Events o 1.5.4. Using XML or HTML attributes * 1.6. Basic interfaces o Event, EventTarget, EventListener, EventException, EventExceptionCode o 1.6.1. Event creation + DocumentEvent, CustomEvent * 1.7. Event module definitions o 1.7.1. User Interface event types + UIEvent o 1.7.2. Text events + TextEvent o 1.7.3. Mouse event types + MouseEvent o 1.7.4. Keyboard event types + KeyboardEvent o 1.7.5. Mutation and mutation name event types + MutationEvent, MutationNameEvent o 1.7.6. Basic event types o 1.7.7. HTML Events 1.1. Introduction DOM Events is designed with two main goals. The first goal is the design of an event system which allows registration of event listeners, describes event flow through a tree structure. Additionally, the specification will provide standard modules of events for user interface control and document mutation notifications, including defined contextual information for each of these event modules. The second goal of the DOM Events is to provide a common subset of the current event systems used in DOM Level 0 browsers. This is intended to foster interoperability of existing scripts and content. It is not expected that this goal will be met with full backwards compatibility. However, the specification attempts to achieve this when possible. The following sections of the specification define both the specification for the DOM Event Model and a number of conformant event modules designed for use within the model. The DOM Event Model consists of: * The DOM event flow, which describe the flow of events in a tree-based structure. * A set of interfaces to access contextual information on events, to register event listeners. 1.1.1. Event flows This document specifies an event flow for tree-based structures: DOM event flow. While it is expected that HTML and XML applications will follow this event flow, applications might reuse the interfaces defined in this document for non tree-based structure. In that case, it is the responsibility of such application to define their event flow and how it relates to the DOM event flow. As example of such use could be found in [DOM Level 3 Load and Save]. 1.1.2. Conformance An implementation is DOM Level 3 Events conformant if it supports the Core module defined in [DOM Level 2 Core], the DOM event flow and the interfaces with their associated semantics defined in Basic interfaces. An implementation conforms to a DOM Level 3 Events module if it conforms to DOM Level 3 Events and the event types defined in the module. An implementation conforms to an event type if it conforms to its associated semantics and DOM interfaces. For example, an implementation conforms to the DOM Level 3 User Interface Events module (see User Interface event types) if it conforms to DOM Level 3 Events (i.e. implements all the basic interfaces), can generate the event types {"http://www.w3.org/2001/xml-events", "DOMActivate"} {"http://www.w3.org/2001/xml-events", "DOMFocusIn"} {"http://www.w3.org/2001/xml-events", "DOMFocusOut"} accordingly to their semantics, supports the UIEvent interface, and conforms to DOM Level 2 Core module. Note: An implementation which does not conform to an event module can still implement the DOM interfaces associated with it. The DOM application can then create an event object using the DocumentEvent.createEvent method and dispatch an event type associated with this interface using the EventTarget.dispatchEvent method. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "Events" and "3.0" (respectively) to determine whether or not DOM Level 3 Events is supported by the implementation. In order to fully support DOM Level 3 Events, an implementation must also support the "Core" feature defined in the DOM Level 2 Core specification [DOM Level 2 Core] and use the DOM event flow. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. DOM Level 3 Events is built on top of DOM Level 2 Events [DOM Level 2 Events], i.e. a DOM Level 3 Events implementation where hasFeature("Events", "3.0") returns true must also return true when the version number is "2.0", "" or, null. Each event module describes its own feature string in the event module listing. 1.2. DOM event flow The DOM event flow is the process through which the event originates from the DOM Events implementation and is dispatched into a tree. Each event has an event target, a targeted node in the case of the DOM Event flow, toward which the event is dispatched by the DOM Events implementation. 1.2.1. Phases The event is dispatched following a path from the root of the tree to this target node. It can then be handled locally at the target node level or from any target ancestor higher in the tree. The event dispatching (also called event propagation) occurs in three phases: 1. The capture phase: the event is dispatched on the target ancestors from the root of the tree to the direct parent of the target node. 2. The target phase: the event is dispatched on the target node. 3. The bubbling phase: the event is dispatched on the target ancestors from the direct parent of the target node to the root of the tree. --------------------------------------------------------------------- [graphical representation of an event dispatched in a DOM tree using the DOM event flow] --------------------------------------------------------------------- graphical representation of an event dispatched in a DOM tree using the DOM event flow --------------------------------------------------------------------- Note: An SVG 1.0 version of the representation above is also available. The target ancestors are determined before the initial dispatch of the event. If the target node is removed during the dispatching, or a target ancestor is added or removed, the event propagation will always be based on the target node and the target ancestors determined before the dispatch. Some events may not necessarily accomplish the three phases of the DOM event flow, e.g. the event could only be defined for one or two phases. As an example, events defined in this specification will always accomplish the capture and target phases but some will not accomplish the bubbling phase ("bubbling events" versus "non-bubbling events", see also the Event.bubbles attribute). 1.2.2. Event listeners Each node encountered during the dispatch of the event may contain event listeners. 1.2.2.1. Registration of event listeners Event listeners can be registered on all nodes in the tree for a specific type of event or event category, phase, and group. If the event listener is registered on a node while an event gets processed on this node, the event listener will not be triggered during the current phase but may be triggered during a later phase in the event flow, i.e. the bubbling phase. 1.2.2.2. Event groups An event listener is always part of a group. It is either explicitly in a group if a group has been specified at the registration or implicitly in the default group if no group has been specified. Within a group, event listeners are ordered in their order of registration. If two event listeners {A1, A2}, that are part of the same group, are registered one after the other (A1, then A2) for the same phase, the DOM event flow guarantees their triggering order (A1, then A2). If the two listeners are not part of the same group, no specification is made as to the order in which they will be triggered. Note: While this specification does not specify a full ordering (i.e. groups are still unordered), it does specify ordering within a group. This implies that if the event listeners {A1, A2, B1, B2}, with A and B being two different groups, are registered for the same phase in the following order: A1, A2, B1, and B2. The following triggering orders are possible and conform to the DOM event flow: {A1, A2, B1, B2}, {A1, B1, A2, B2}, {B1, A1, A2, B2}, {A1, B1, B2, A2}, {B1, A1, B2, A2}, {B1, B2, A1, A2}. DOM Events implementations may impose priorities on groups but DOM applications must not rely on it. Unlike this specification, [DOM Level 2 Events] did not specify any triggering order for event listeners. 1.2.2.3. Triggering an event listener When the event is dispatched through the tree, from node to node, event listeners registered on the node are triggered if: 1. they were registered for the same type of event, or the same category. 2. they were registered for the same phase; 3. the event propagation has not been stopped for the group. 1.2.2.4. Removing an event listener If an event listener is removed from a node while an event is being processed on the node, it will not be triggered by the current actions. Once removed, the event listener is never invoked again (unless registered again for future processing). 1.2.2.5. Reentrance It is expected that actions taken by EventListeners may cause additional events to be dispatched. Additional events should be handled in a synchronous manner and may cause reentrance into the event model. If an event listener fires a new event using EventTarget.dispatchEvent, the event propagation that causes the event listener to be triggered will resume only after the event propagation of the new event is completed. Since implementations may have restrictions such as stack-usage or other memory requirements, applications should not depend on how many synchronous events may be triggered. 1.2.2.6. Event propagation and event groups All event listeners are part of a group (see Registration of event listeners). An event listener may prevent event listeners that are part of a same group from being triggered. The effect could be: * immediate and no more event listeners from the same group will be triggered by the event object; * differed until all event listeners from the same group have been triggered on the current node, i.e. the event listeners of the same group attached on other nodes will not be triggered. If two event listeners are registered for two different groups, one cannot prevent the other from being triggered. 1.3. Default actions and cancelable events Implementations may have a default action associated with an event type. An example is the [HTML 4.01] form element. When the user submits the form (e.g. by pressing on a submit button), the event {"http://www.w3.org/2001/xml-events", "submit"} is dispatched to the element and the default action for this event type is generally to send a request to a Web server with the parameters from the form. The default actions are not part of the DOM Event flow. Before invoking a default action, the implementation must first dispatch the event as described in the DOM event flow. A cancelable event is an event associated with a default action which is allowed to be canceled during the DOM event flow. At any phase during the event flow, the triggered event listeners have the option of canceling the default action or allowing the default action to proceed. In the case of the hyperlink in the browser, canceling the action would have the result of not activating the hyperlink. Not all events defined in this specification are cancelable events. Different implementations will specify their own default actions, if any, associated with each event. The DOM Events specification does not attempt to specify these actions. This specification does not provide mechanisms for accessing default actions or adding new ones. Note: Some implementations also provide default actions before the dispatch of the event. It is not possible to cancel those default actions and this specification does not address them. An example of such default actions can be found in [DOM Level 2 HTML] on the HTMLInputElement.checked attribute. 1.4. Event types Each event is associated with a type, called event type. The event type is composed of a local name and a namespace URI as defined in [XML Namespaces]. All events defined in this specification use the namespace URI "http://www.w3.org/2001/xml-events". Note: As in [DOM Level 3 Core], DOM Level 3 Events does not perform any URI normalization or canonicalization. The URIs given to the DOM are assumed to be valid (e.g., characters such as white spaces are properly escaped), and no lexical checking is performed. Absolute URI references are treated as strings and compared literally. How relative namespace URI references are treated is undefined. To ensure interoperability only absolute namespace URI references (i.e., URI references beginning with a scheme name and a colon) should be used. Applications that wish to have no namespace should use the value null as the namespaceURI parameter of methods. If they pass an empty string the DOM implementation turns it into a null. 1.4.1. Event types and event categories An event type could be part of one or more categories. A category is represented using a local name and a namespace URI as defined in [XML Namespaces]. The event types defined in this specification are not associated with one or more event categories and this specification does not provide methods to associate them. Other specifications may create and associate event categories with event listeners but in such case would need to inform the dispatch mechanism of those event categories. 1.4.2. Complete list of event types Depending on the level of DOM support, or the devices used to display (e.g. screen) or interact with (e.g. mouse, keyboard, touch screen, voice, ...), these event types could be generated by the implementation. When used with an [XML 1.0] or [HTML 4.01] application, the specifications of those languages may restrict the semantics and scope (in particular the possible target nodes) associated with an event type. For example, {"http://www.w3.org/2001/xml-events", "click"} can be targeted to all [XHTML 1.0] elements but applet, base, basefont, bdo, br, font, frame, frameset, head, html, iframe, isindex, meta, param, script, style, and title. Refer to the specification defining the language used in order to find those restrictions or to find event types that are not defined in this document. The following table defines all event types provided in this specification (with the exception of two event types preserved for backward compatibility with [HTML 4.01]). All events will accomplish the capture phase and target phases, but not all of them will accomplish the bubbling phase (see also DOM event flow). Some events are not cancelable (see Default actions and cancelable events). Contextual information related to the event type are accessible using DOM interfaces. Event type Description BubblingCancelable Target node DOM interface phase "http://www.w3.org/2001/xml-events", An element is activated, for instance,Yes Yes Element UIEvent "DOMActivate" using a mouse device, a keyboard device, or a voice command. Note: The activation of an element is device dependent but is also application dependent, e.g. a link in a document can be activated using a mouse click or a mouse double click. "http://www.w3.org/2001/xml-events", An event target receives focus, for Yes No Element UIEvent "DOMFocusIn" instance via a pointing device being moved onto an element or using keyboard navigation. The focus is given to the element before the dispatch of this event type. "http://www.w3.org/2001/xml-events", A event target loses focus, for Yes No Element UIEvent "DOMFocusOut" instance via a pointing device being moved out of an element or by tabbing navigation out of the element. The focus is taken from the element before the dispatch of this event type. "http://www.w3.org/2001/xml-events", One or more characters have been Yes Yes Element TextEvent "textInput" entered. The characters can originate from a variety of sources. For example, it could be a character resulting from a key being pressed or released on a keyboard device, a character resulting from the processing of an input method editor, or resulting from a voice command. "http://www.w3.org/2001/xml-events", A pointing device button is clicked Yes Yes Element MouseEvent "click" over an element. The definition of a click depends on the environment configuration; i.e. may depend on the screen location or the delay between the press and release of the pointing device button. In any case, the target node must be the same between the mousedown, mouseup, and click. The sequence of these events is: {"http://www.w3.org/2001/xml-events", "mousedown"}, {"http://www.w3.org/2001/xml-events", "mouseup"}, and {"http://www.w3.org/2001/xml-events", "click"}. Note that, given the definition of a click, If one or more of the event types {"http://www.w3.org/2001/xml-events", "mouseover"}, {"http://www.w3.org/2001/xml-events", "mousemove"}, and {"http://www.w3.org/2001/xml-events", "mouseout"} occur between the press and release of the pointing device button, the event type {"http://www.w3.org/2001/xml-events", "click"} cannot occur. In the case of nested elements, this event type is always targeted at the most deeply nested element. "http://www.w3.org/2001/xml-events", A pointing device button is pressed Yes Yes Element MouseEvent "mousedown" over an element. In the case of nested elements, this event type is always targeted at the most deeply nested element. "http://www.w3.org/2001/xml-events", A pointing device button is released Yes Yes Element MouseEvent "mouseup" over an element. In the case of nested elements, this event type is always targeted at the most deeply nested element. "http://www.w3.org/2001/xml-events", A pointing device is moved onto an Yes Yes Element MouseEvent "mouseover" element. In the case of nested elements, this event type is always targeted at the most deeply nested element. "http://www.w3.org/2001/xml-events", A pointing device is moved while it isYes Yes Element MouseEvent "mousemove" over an element. In the case of nested elements, this event type is always targeted at the most deeply nested element. "http://www.w3.org/2001/xml-events", A pointing device is moved away from Yes Yes Element MouseEvent "mouseout" an element. In the case of nested elements, this event type is always targeted at the most deeply nested element. "http://www.w3.org/2001/xml-events", A key is pressed down. This event typeYes Yes Element KeyboardEvent "keydown" is device dependent and relies on the capabilities of the input devices and how they are mapped in the operating system. This event type is generated after the keyboard mapping but before the processing of the input method editor. This event should logically happen before the event {"http://www.w3.org/2001/xml-events", "keyup"} is produced. "http://www.w3.org/2001/xml-events", A key is released. This event type is Yes Yes Element KeyboardEvent "keyup" device dependent and relies on the capabilities of the input devices and how they are mapped in the operating system. This event type is generated after the keyboard mapping but before the processing of the input method editor. This event should logically happen after the event {"http://www.w3.org/2001/xml-events", "keydown"} is produced. "http://www.w3.org/2001/xml-events", This is a general event for Yes No Document, MutationEvent "DOMSubtreeModified" notification of all changes to the DocumentFragment, document. It can be used instead of Element, Attr the more specific events listed below. It may be dispatched after a single modification to the document or, at the implementation's discretion, after multiple changes have occurred. The latter use should generally be used to accommodate multiple changes which occur either simultaneously or in rapid succession. The target of this event is the lowest common parent of the changes which have taken place. This event is dispatched after any other events caused by the mutation(s) have occurred. "http://www.w3.org/2001/xml-events", A node has been added as a child of Yes No Element, Attr, Text, MutationEvent "DOMNodeInserted" another node. This event is dispatched Comment, CDATASection, after the insertion has taken place. DocumentType, The target node of this event is the EntityReference, node being inserted. ProcessingInstruction "http://www.w3.org/2001/xml-events", A node is being removed from its Yes No Element, Attr, Text, MutationEvent "DOMNodeRemoved" parent node. This event is dispatched Comment, CDATASection, before the node is removed from the DocumentType, tree. The target node of this event is EntityReference, the node being removed. ProcessingInstruction "http://www.w3.org/2001/xml-events", A node is being removed from a No No Element, Attr, Text, MutationEvent "DOMNodeRemovedFromDocument" document, either through direct Comment, CDATASection, removal of the node or removal of a DocumentType, subtree in which it is contained. This EntityReference, event is dispatched before the removal ProcessingInstruction takes place. The target node of this event type is the node being removed. If the node is being directly removed, the event type {"http://www.w3.org/2001/xml-events", "DOMNodeRemoved"} will fire before this event type. "http://www.w3.org/2001/xml-events", A node is being inserted into a No No Element, Attr, Text, MutationEvent "DOMNodeInsertedIntoDocument" document, either through direct Comment, CDATASection, insertion of the node or insertion of DocumentType, a subtree in which it is contained. EntityReference, This event is dispatched after the ProcessingInstruction insertion has taken place. The target node of this event is the node being inserted. If the node is being directly inserted, the event type {"http://www.w3.org/2001/xml-events", "DOMNodeInserted"} will fire before this event type. "http://www.w3.org/2001/xml-events", Occurs after an Attr has been modifiedYes No Element MutationEvent "DOMAttrModified" on a node. The target node of this event is the parent Element node whose Attr changed. It is expected that string based replacement of an Attr value will be viewed as a modification of the Attr since its identity does not change. Subsequently replacement of the Attr node with a different Attr node is viewed as the removal of the first Attr node and the addition of the second. "http://www.w3.org/2001/xml-events", Occurs after CharacterData.data or Yes No Text, Comment, MutationEvent "DOMCharacterDataModified" ProcessingInstruction.data have been CDATASection, modified but the node itself has not ProcessingInstruction been inserted or deleted. The target node of this event is the CharacterData node or the ProcessingInstruction node. "http://www.w3.org/2001/xml-events", Occurs after the namespaceURI and/or Yes No Element MutationNameEvent "DOMElementNameChanged" the nodeName of an Element node have been modified (e.g., the element was renamed using Document.renameNode). The target of this event is the renamed Element node. "http://www.w3.org/2001/xml-events", Occurs after the namespaceURI and/or Yes No Element MutationNameEvent "DOMAttributeNameChanged" the nodeName of a Attr node have been modified (e.g., the attribute was renamed using Document.renameNode). The target of this event is the parent Element node whose Attr has been renamed. "http://www.w3.org/2001/xml-events", The DOM Implementation finishes No No Element Event "load" loading the resource (such as the document) and any dependent resources (such as images, style sheets, or scripts). Dependent resources that fail to load will not prevent this event from firing if the resource that loaded them is still accessible via the DOM. "http://www.w3.org/2001/xml-events", The DOM implementation removes from No No Element Event "unload" the environment the resource (such as the document) or any dependent resources (such as images, style sheets, scripts). The document is unloaded after the dispatch of this event type. "http://www.w3.org/2001/xml-events", The loading of the document, or a Yes No Element Event "abort" resource linked from it, is stopped before being entirely loaded. "http://www.w3.org/2001/xml-events", The document, or a resource linked Yes No Element Event "error" from it, has been loaded but cannot be interpreted according to its semantic, such as an invalid image or a script execution error. "http://www.w3.org/2001/xml-events", A user selects some text. DOM Level 3 Yes No Element Event "select" Events does not provide contextual information to access the selected text. The selection occured before the dispatch of this event type. "http://www.w3.org/2001/xml-events", A control loses the input focus and Yes No Element Event "change" its values has been modified since gaining focus. "http://www.w3.org/2001/xml-events", A form, such as [HTML 4.01], [XHTML Yes Yes Element Event "submit" 1.0], or [XForms 1.0] forms, is submitted. "http://www.w3.org/2001/xml-events", A form, such as [HTML 4.01], [XHTML Yes Yes Element Event "reset" 1.0], or [XForms 1.0] forms, is reset. "http://www.w3.org/2001/xml-events", A document view has been resized. The Yes No Document UIEvent "resize" resize occured before the dispatch of this event type. "http://www.w3.org/2001/xml-events", A document view has been scrolled. TheYes No Document UIEvent "scroll" scroll occured before the dispatch of this event type. The event objects associated with the event types described above may contain context information. Refer to the description of the DOM interfaces for further information. 1.4.3. Compatibility with DOM Level 2 Events Namespace URIs Were only introduced in DOM Level 3 Events and were not part of DOM Level 2 Events. DOM Level 2 Events methods are namespace ignorant and the event type is only represented by an XML name, specified in the Event.type attribute. Therefore, while it is safe to use these methods when not dealing with namespaces, using them and the new ones at the same time should be avoided. DOM Level 2 Events methods solely identify events by their Event.type. On the contrary, the DOM Level 3 Events methods related to namespaces, identify attribute nodes by their Event.namespaceURI and Event.type. Because of this fundamental difference, mixing both sets of methods can lead to unpredictable results. For example, using EventTarget.addEventListenerNS, two event listeners (or more) could be registered using the same type and same useCapture values, but different namespaceURIs. Calling EventTarget.removeEventListener with that type and useCapture could then remove any or none of those event listeners. The result depends on the implementation. The only guarantee in such cases is that all methods which access an event listener by its namespaceURI and type will access the same event listener. For instance, EventTarget.removeEventListenerNS removes the event that EventTarget.addEventListenerNS added. For compatibility reasons, the dispatching of an event will ignore namespace URIs if either the event or the event listener has a null namespace URI. If a DOM Level 2 event (i.e. with a null namespace URI) is dispatched in the DOM tree, all event listeners that match the type will be triggered as described in the DOM event flow. If a DOM Level 3 event (i.e. with a namespace URI) is dispatched in the DOM tree, all event listener with the same type and the same or null namespace URI, will be triggered as described in the DOM event flow. 1.5. Event listener registration Note: This section is informative. There are mainly two ways to associate an event listener to a node in the tree: 1. at the programming level using the EventTarget methods. 2. at the document level using [XML Events] or an ad-hoc syntax, as the ones provided in [XHTML 1.0] or [SVG 1.0]. 1.5.1. Using the EventTarget methods The user can attach an event listener using the methods on the EventTarget interface: myCircle.addEventListenerNS("http://www.w3.org/2001/xml-events", "DOMActivate", myListener, true, myEvtGroup); The methods do not provide the ability to register the same event listener more than once for the same event type and the same phase. It is not possible to register an event listener: * for only one of the target and bubbling phases since those phases are coupled during the registration (but the listener itself could ignore events during one of these phases if desired). * for a specific event target and have it only triggered for this event target during the bubbling or capture phases (but again, the listener itself could ignore events with other event targets if desired). * for a specific event category. To register an event listener, DOM applications must use the methods EventTarget.addEventListener and EventTarget.addEventListenerNS. An EventListener being registered on an EventTarget may choose to have that EventListener triggered during the capture phase by specifying the useCapture parameter of the EventTarget.addEventListener or EventTarget.addEventListenerNS methods to be true. If false, the EventListener will be triggered during the target and bubbling phases. 1.5.2. Using XML Events In [XML Events], event listeners are attached using elements and attributes: Event listeners can only be registered on Element nodes, i.e. other Node types are not addressable, and cannot be registered for a specific group either, i.e. they are always attached to the default group. The target phase and the bubbling phase are coupled during the registration. [XML Events] does not address namespaces in event types. If the value of the event attribute of the listener element contains a colon (':'), it should be interpreted as a QName as defined in [XML Schema Part 2]. 1.5.3. Using VoiceXML Events In [VoiceXML 2.0], event listeners are attached using elements:
Please say something You don't have the authorization! Connection error Connection error Unknown error
Event listeners can only be registered on Element nodes, i.e. other Node types are not addressable, and cannot be registered for a specific group either, i.e. they are always attached to the default group. The target phase and the bubbling phase are coupled during the registration. [VoiceXML 2.0] does not address namespaces in event types but uses the notion of event categories. The event type "connection.disconnect.hangup" could be associated to the event categories {"http://www.example.org/2003/voicexml", "connection"} and {"http://www.example.org/2003/voicexml", "connection.disconnect"}. 1.5.4. Using XML or HTML attributes In languages such as [HTML 4.01], [XHTML 1.0], or [SVG 1.0], event listeners are specified as attributes: Since only one attribute with the same name can appear on an element, it is therefore not possible to register more than one event listener on a single EventTarget for the event type. Also, event listeners can only be registered on Element nodes for the target phase and bubbling phase, i.e. other Node types and the capture phase are not addressable with these languages. Event listeners cannot be registered for a specific group either, i.e. they are always attached to the default group. In order to achieve compatibility with those languages, implementors may view the setting of attributes which represent event handlers as the creation and registration of an EventListener on the EventTarget. The value of useCapture defaults to false. This EventListener behaves in the same manner as any other EventListeners which may be registered on the EventTarget. If the attribute representing the event listener is changed, this may be viewed as the removal of the previously registered EventListener and the registration of a new one. Furthermore, no specification is made as to the order in which event attributes will receive the event with regards to the other EventListeners on the EventTarget. 1.6. Basic interfaces The interfaces described in this section are fundamental to DOM Level 3 Events and must always be supported by the implementation. Interface Event (introduced in DOM Level 2) The Event interface is used to provide contextual information about an event to the listener processing the event. An object which implements the Event interface is passed as the parameter to an EventListener. More specific context information is passed to event listeners by deriving additional interfaces from Event which contain information directly relating to the type of event they represent. These derived interfaces are also implemented by the object passed to the event listener. IDL Definition // Introduced in DOM Level 2: interface Event { // PhaseType const unsigned short CAPTURING_PHASE = 1; const unsigned short AT_TARGET = 2; const unsigned short BUBBLING_PHASE = 3; readonly attribute DOMString type; readonly attribute EventTarget target; readonly attribute EventTarget currentTarget; readonly attribute unsigned short eventPhase; readonly attribute boolean bubbles; readonly attribute boolean cancelable; readonly attribute DOMTimeStamp timeStamp; void stopPropagation(); void preventDefault(); void initEvent(in DOMString eventTypeArg, in boolean canBubbleArg, in boolean cancelableArg); // Introduced in DOM Level 3: readonly attribute DOMString namespaceURI; // Introduced in DOM Level 3: boolean isCustom(); // Introduced in DOM Level 3: void stopImmediatePropagation(); // Introduced in DOM Level 3: boolean isDefaultPrevented(); // Introduced in DOM Level 3: void initEventNS(in DOMString namespaceURIArg, in DOMString eventTypeArg, in boolean canBubbleArg, in boolean cancelableArg); }; Definition group PhaseType An integer indicating which phase of the event flow is being processed as defined in DOM event flow. Defined Constants AT_TARGET The current event is in the target phase, i.e. it is being evaluated at the event target. BUBBLING_PHASE The current event phase is the bubbling phase. CAPTURING_PHASE The current event phase is the capture phase. Attributes bubbles of type boolean, readonly Used to indicate whether or not an event is a bubbling event. If the event can bubble the value is true, otherwise the value is false. cancelable of type boolean, readonly Used to indicate whether or not an event can have its default action prevented (see also Default actions and cancelable events). If the default action can be prevented the value is true, otherwise the value is false. currentTarget of type EventTarget, readonly Used to indicate the EventTarget whose EventListeners are currently being processed. This is particularly useful during the capture and bubbling phases. This attribute could contain the target node or a target ancestor when used with the DOM event flow. eventPhase of type unsigned short, readonly Used to indicate which phase of event flow is currently being accomplished. namespaceURI of type DOMString, readonly, introduced in DOM Level 3 The namespace URI associated with this event at creation time, or null if it is unspecified. For events initialized with a DOM Level 2 Events method, such as initEvent, this is always null. target of type EventTarget, readonly Used to indicate the event target. This attribute contain the target node when used with the DOM event flow. timeStamp of type DOMTimeStamp, readonly Used to specify the time (in milliseconds relative to the epoch) at which the event was created. Due to the fact that some systems may not provide this information the value of timeStamp may be not available for all events. When not available, a value of 0 will be returned. Examples of epoch time are the time of the system start or 0:0:0 UTC 1st January 1970. type of type DOMString, readonly The name must be an NCName as defined in [XML Namespaces] and is case-sensitive. The character ":" (colon) should not be used in this attribute. If the attribute Event.namespaceURI is different from null, this attribute represents a local name. Methods initEvent The initEvent method is used to initialize the value of an Event created through the DocumentEvent.createEvent method. This method may only be called before the Event has been dispatched via the EventTarget.dispatchEvent method. If the method is called several times before invoking EventTarget.dispatchEvent, only the final invocation takes precedence. If called from a subclass of Event interface only the values specified in this method are modified, all other attributes are left unchanged. This method sets the Event.type attribute to eventTypeArg, and Event.localName and Event.namespaceURI to null. To initialize an event with a local name and namespace URI, use the initEventNS method. Parameters eventTypeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. This parameter overrides the intrinsic bubbling behavior of the event. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. This parameter overrides the intrinsic cancelable behavior of the event. No Return Value No Exceptions initEventNS introduced in DOM Level 3 The initEventNS method is used to initialize the value of an Event created through the DocumentEvent interface. This method may only be called before the Event has been dispatched via the dispatchEvent method, though it may be called multiple times the event has been dispatched. If called multiple times the final invocation takes precedence. If a call to initEventNS is made after one of the Event derived interfaces' init methods has been called, only the values specified in the initEventNS method are modified, all other attributes are left unchanged. This method sets the Event.type attribute to eventTypeArg, and Event.namespaceURI to namespaceURIArg. Parameters namespaceURIArg of type DOMString Specifies the namespace URI associated with this event, or null if no namespace. eventTypeArg of type DOMString Specifies the local name of the event type (see also the description of Event.type). canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. No Return Value No Exceptions isCustom introduced in DOM Level 3 This method will always return false, unless the event implements the CustomEvent interface. Return Value boolean true if preventDefault() has been called for this event. No Parameters No Exceptions isDefaultPrevented introduced in DOM Level 3 This method will return true if the method preventDefault() has been called for this event, false otherwise. Return Value boolean true if preventDefault() has been called for this event. No Parameters No Exceptions preventDefault If an event is cancelable, the preventDefault method is used to signify that the event is to be canceled, meaning any default action normally taken by the implementation as a result of the event will not occur (see also Default actions and cancelable events), and thus independently of event groups. Calling this method for a non-cancelable event has no effect. Note: This method does not stop the event propagation; use stopPropagation or stopImmediatePropagation for that effect. No Parameters No Return Value No Exceptions stopImmediatePropagation introduced in DOM Level 3 This method is used to prevent event listeners of the same group to be triggered and, unlike stopPropagation its effect is immediate (see Event propagation and event groups). Once it has been called, further calls to that method have no additional effect. Note: This method does not prevent the default action from being invoked; use preventDefault for that effect. No Parameters No Return Value No Exceptions stopPropagation This method is used to prevent event listeners of the same group to be triggered but its effect is differed until all event listeners attached on the currentTarget have been triggered (see Event propagation and event groups). Once it has been called, further calls to that method have no additional effect. Note: This method does not prevent the default action from being invoked; use preventDefault for that effect. No Parameters No Return Value No Exceptions Interface EventTarget (introduced in DOM Level 2) The EventTarget interface is implemented by all the objects which could be event targets in an implementation which supports the Event flows. The interface allows registration, removal or query of event listeners, and dispatch of events to an event target. When used with DOM event flow, this interface is implemented by all target nodes and target ancestors, i.e. all DOM Nodes of the tree support this interface when the implementation conforms to DOM Level 3 Events and, therefore, this interface can be obtained by using binding-specific casting methods on an instance of the Node interface. Invoking multiple times addEventListener or addEventListenerNS on the same EventTarget with the same parameters (namespaceURI, type, listener, and useCapture) is considered to be a no-op and thus independently of the event group. They do not cause the EventListener to be called more than once and do not cause a change in the triggering order. In order to guarantee that an event listener will be added to the event target for the specified event group, one needs to invoke removeEventListener or removeEventListenerNS first. IDL Definition // Introduced in DOM Level 2: interface EventTarget { void addEventListener(in DOMString type, in EventListener listener, in boolean useCapture); void removeEventListener(in DOMString type, in EventListener listener, in boolean useCapture); // Modified in DOM Level 3: boolean dispatchEvent(in Event evt) raises(EventException); // Introduced in DOM Level 3: void addEventListenerNS(in DOMString namespaceURI, in DOMString type, in EventListener listener, in boolean useCapture, in DOMObject evtGroup); // Introduced in DOM Level 3: void removeEventListenerNS(in DOMString namespaceURI, in DOMString type, in EventListener listener, in boolean useCapture); // Introduced in DOM Level 3: boolean willTriggerNS(in DOMString namespaceURI, in DOMString type); // Introduced in DOM Level 3: boolean hasEventListenerNS(in DOMString namespaceURI, in DOMString type); }; Methods addEventListener This method allows the registration of an event listener in the default group and, depending on the useCapture parameter, on the capture phase of the DOM event flow or its target and bubbling phases. Parameters type of type DOMString Specifies the Event.type associated with the event for which the user is registering. listener of type EventListener The listener parameter takes an object implemented by the user which implements the EventListener interface and contains the method to be called when the event occurs. useCapture of type boolean If true, useCapture indicates that the user wishes to add the event listener for the capture phase only, i.e. this event listener will not be triggered during the target and bubbling phases. If false, the event listener will only be triggered during the target and bubbling phases. No Return Value No Exceptions addEventListenerNS introduced in DOM Level 3 This method allows the registration of an event listener in a specified group or the default group and, depending on the useCapture parameter, on the capture phase of the DOM event flow or its target and bubbling phases. Parameters namespaceURI of type DOMString Specifies the Event.namespaceURI associated with the event for which the user is registering. type of type DOMString Specifies the Event.type associated with the event for which the user is registering. listener of type EventListener The listener parameter takes an object implemented by the user which implements the EventListener interface and contains the method to be called when the event occurs. useCapture of type boolean If true, useCapture indicates that the user wishes to add the event listener for the capture phase only, i.e. this event listener will not be triggered during the target and bubbling phases. If false, the event listener will only be triggered during the target and bubbling phases. evtGroup of type DOMObject The object that represents the event group to associate with the EventListener (see also Event propagation and event groups). Use null to attach the event listener to the default group. No Return Value No Exceptions dispatchEvent modified in DOM Level 3 This method allows the dispatch of events into the implementation's event model. The event target of the event is the EventTarget object on which dispatchEvent is called. Parameters evt of type Event The event to be dispatched. Return Value boolean Indicates whether any of the listeners which handled the event called preventDefault. If preventDefault was called the returned value is false, else it is true. Exceptions EventException UNSPECIFIED_EVENT_TYPE_ERR: Raised if the Event.type was not specified by initializing the event before dispatchEvent was called. Specification of the Event.type as null or an empty string will also trigger this exception. DISPATCH_REQUEST_ERR: Raised if the Event object is already being dispatched in the tree. NOT_SUPPORTED_ERR: Raised if the Event object has not been created using DocumentEvent.createEvent or does not support the interface CustomEvent. hasEventListenerNS introduced in DOM Level 3 This method allows the DOM application to know if this EventTarget contains an event listener registered for the specified event type. This is useful for determining at which nodes within a hierarchy altered handling of specific event types has been introduced, but should not be used to determine whether the specified event type triggers an event listener (see willTriggerNS). Issue canTriggerOnTarget-useCapture: do we need a useCapture parameter? Resolution: No use case for that. Parameters namespaceURI of type DOMString Specifies the Event.namespaceURI associated with the event. type of type DOMString Specifies the Event.type associated with the event. Return Value boolean true if an event listener is registered on this EventTarget for the specified event type, false otherwise. No Exceptions removeEventListener This method allows the removal of event listeners from the default group. Calling removeEventListener with arguments which do not identify any currently registered EventListener on the EventTarget has no effect. Parameters type of type DOMString Specifies the Event.type for which the user registered the event listener. listener of type EventListener The EventListener to be removed. useCapture of type boolean Specifies whether the EventListener being removed was registered for the capture phase or not. If a listener was registered twice, once for the capture phase and once for the target and bubbling phases, each must be removed separately. Removal of an event listener registered for the capture phase does not affect the same event listener registered for the target and bubbling phases, and vice versa. No Return Value No Exceptions removeEventListenerNS introduced in DOM Level 3 This method allows the removal of event listeners from a specified group or the default group. Calling removeEventListenerNS with arguments which do not identify any currently registered EventListener on the EventTarget has no effect. Parameters namespaceURI of type DOMString Specifies the Event.namespaceURI associated with the event for which the user registered the event listener. type of type DOMString Specifies the Event.type associated with the event for which the user registered the event listener. listener of type EventListener The EventListener parameter indicates the EventListener to be removed. useCapture of type boolean Specifies whether the EventListener being removed was registered for the capture phase or not. If a listener was registered twice, once for the capture phase and once for the target and bubbling phases, each must be removed separately. Removal of an event listener registered for the capture phase does not affect the same event listener registered for the target and bubbling phases, and vice versa. No Return Value No Exceptions willTriggerNS introduced in DOM Level 3 This method allows the DOM application to know if an event listener, attached to this EventTarget or one of its ancestors, will be triggered by the specified event type during the dispatch of the event to this event target or one of its descendants. Parameters namespaceURI of type DOMString Specifies the Event.namespaceURI associated with the event. type of type DOMString Specifies the Event.type associated with the event. Return Value boolean true if an event listener will be triggered on the EventTarget with the specified event type, false otherwise. No Exceptions Interface EventListener (introduced in DOM Level 2) The EventListener interface is the primary way for handling events. Users implement the EventListener interface and register their event listener on an EventTarget. The users should also remove their EventListener from its EventTarget after they have completed using the listener. Copying a Node does not copy the event listeners attached to it. Event listeners must be attached to the newly created Node afterwards if so desired. Therefore, Nodes are copied using Node.cloneNode or Range.cloneContents, the EventListeners attached to the source Nodes are not attached to their copies. Moving a Node does not affect the event listeners attached to it. Therefore, when Nodes are moved using Document.adoptNode, Node.appendChild, or Range.extractContents, the EventListeners attached to the moved Nodes stay attached to them. IDL Definition // Introduced in DOM Level 2: interface EventListener { void handleEvent(in Event evt); }; Methods handleEvent This method is called whenever an event occurs of the event type for which the EventListener interface was registered. Parameters evt of type Event The Event contains contextual information about the event. No Return Value No Exceptions Exception EventException introduced in DOM Level 2 Event operations may throw an EventException as specified in their method descriptions. IDL Definition // Introduced in DOM Level 2: exception EventException { unsigned short code; }; // EventExceptionCode const unsigned short UNSPECIFIED_EVENT_TYPE_ERR = 0; // Introduced in DOM Level 3: const unsigned short DISPATCH_REQUEST_ERR = 1; Definition group EventExceptionCode An integer indicating the type of error generated. Defined Constants DISPATCH_REQUEST_ERR, introduced in DOM Level 3. If the Event object is already dispatched in the tree. UNSPECIFIED_EVENT_TYPE_ERR If the Event.type was not specified by initializing the event before the method was called. Specification of the Event.type as null or an empty string will also trigger this exception. 1.6.1. Event creation In most cases, the events dispatched by the DOM Events implementation are also created by the implementation. It is however possible to simulate events such as mouse events by creating the Event objects and dispatch them using the DOM Events implementation. DOM Events provides two ways for creating Event objects. An application can either create Event objects that are known to the implementation, or create its own objects and have them dispatched by the DOM Events implementation. Creating Event objects that are known to the DOM Events implementation is done using DocumentEvent.createEvent. The application must then initialize the object by calling the appropriate initialization method before invoking EventTarget.dispatchEvent. The Event objects created must be known by the DOM Events implementation otherwise an event exception is thrown. The DOM application might want to create its own Event objects, in order to change the default Event implementation provided by the DOM Events implementation or to generate new event types with specific contextual information. In any case, the application is responsible for creating and initializing the Event object. The application can then dispatch the event using the DOM Events implementation by using EventTarget.dispatchEvent. However, the DOM Events implementation requires to have access to two attributes in the Event object in order to accomplish the dispatch appropriately: Event.currentTarget and Event.eventPhase. Those attributes are defined as readonly in the Event interface since event listeners must not change them and it is the responsibility of the DOM Events implementation to update them during the event flow. Therefore, implementing the Event interface when creating its own events is not enough for an application since the DOM Events implementation will not be able to update the current phase and the current node during the dispatch, unless the event object also implements the CustomEvent interface to give access to the relevant attributes. Interface DocumentEvent (introduced in DOM Level 2) The DocumentEvent interface provides a mechanism by which the user can create an Event object of a type supported by the implementation. It is expected that the DocumentEvent interface will be implemented on the same object which implements the Document interface in an implementation which supports the Event model. IDL Definition // Introduced in DOM Level 2: interface DocumentEvent { Event createEvent(in DOMString eventType) raises(DOMException); // Introduced in DOM Level 3: boolean canDispatch(in DOMString namespaceURI, in DOMString type); }; Methods canDispatch introduced in DOM Level 3 Test if the implementation can generate events of a specified type. Parameters namespaceURI of type DOMString Specifies the Event.namespaceURI of the event. type of type DOMString Specifies the Event.type of the event. Return Value boolean true if the implementation can generate and dispatch this event type, false otherwise. No Exceptions createEvent Parameters eventType of type DOMString The eventType parameter specifies the name of the DOM Events interface to be supported by the created event object, e.g. "Event", "MouseEvent", "MutationEvent" ... If the Event is to be dispatched via the EventTarget.dispatchEvent method the appropriate event init method must be called after creation in order to initialize the Event's values. As an example, a user wishing to synthesize some kind of UIEvent would call DocumentEvent.createEvent with the parameter "UIEvent". The UIEvent.initUIEventNS method could then be called on the newly created UIEvent object to set the specific type of user interface event to be dispatched, {"http://www.w3.org/2001/xml-events", "DOMActivate"} for example, and set its context information, e.g. UIEvent.detail in this example. The createEvent method is used in creating Events when it is either inconvenient or unnecessary for the user to create an Event themselves. In cases where the implementation provided Event is insufficient, users may supply their own Event implementations for use with the EventTarget.dispatchEvent method. However, the DOM implementation needs access to the attributes Event.currentTarget and Event.eventPhase to propagate appropriately the event in the DOM tree. Therefore users' Event implementations might need to support the CustomEvent interface for that effect. Note: For backward compatibility reason, "UIEvents", "MouseEvents", "MutationEvents", and "HTMLEvents" feature names are valid values for the parameter eventType and represent respectively the interfaces "UIEvent", "MouseEvent", "MutationEvent", and "Event". Return Value Event The newly created event object. Exceptions DOMException NOT_SUPPORTED_ERR: Raised if the implementation does not support the Event interface requested. Interface CustomEvent (introduced in DOM Level 3) The CustomEvent interface gives access to the attributes Event.currentTarget and Event.eventPhase. It is intended to be used by the DOM Events implementation to access the underlying current target and event phase while dispatching a custom Event in the tree; it is also intended to be implemented, and not used, by DOM applications. The methods contained in this interface are not intended to be used by a DOM application, especially during the dispatch on the Event object. Changing the current target or the current phase may conduct into unpredictable results of the event flow. The DOM Events implementation should ensure that both methods return the appropriate current target and phase before invoking each event listener on the current target to protect DOM applications from malicious event listeners. Note: If this interface is supported by the event object, Event.isCustom() must return true. IDL Definition // Introduced in DOM Level 3: interface CustomEvent : Event { void setDispatchState(in EventTarget target, in unsigned short phase); boolean isPropagationStopped(); boolean isImmediatePropagationStopped(); }; Methods isImmediatePropagationStopped The isImmediatePropagationStopped method is used by the DOM Events implementation to know if the method stopImmediatePropagation() has been called for this event. It returns true if the method has been called, false otherwise. Return Value boolean true if the event propagation has been stopped immediately in the current group. No Parameters No Exceptions isPropagationStopped This method will return true if the method stopPropagation() has been called for this event, false in any other cases. Return Value boolean true if the event propagation has been stopped in the current group. No Parameters No Exceptions setDispatchState The setDispatchState method is used by the DOM Events implementation to set the values of Event.currentTarget and Event.eventPhase. It also reset the states of isPropagationStopped and isImmediatePropagationStopped. Parameters target of type EventTarget Specifies the new value for the Event.currentTarget attribute. phase of type unsigned short Specifies the new value for the Event.eventPhase attribute. No Return Value No Exceptions 1.7. Event module definitions The DOM Event Model allows a DOM implementation to support multiple modules of events. The model has been designed to allow addition of new event modules as is required. The DOM will not attempt to define all possible events. For purposes of interoperability, the DOM will define a module of user interface events including lower level device dependent events, a module of UI logical events, and a module of document mutation events. 1.7.1. User Interface event types The User Interface event module contains basic event types associated with user interfaces. Interface UIEvent (introduced in DOM Level 2) The UIEvent interface provides specific contextual information associated with User Interface events. Note: To create an instance of the UIEvent interface, use the feature string "UIEvent" as the value of the input parameter used with the DocumentEvent.createEvent method. IDL Definition // Introduced in DOM Level 2: interface UIEvent : Event { readonly attribute views::AbstractView view; readonly attribute long detail; void initUIEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg); // Introduced in DOM Level 3: void initUIEventNS(in DOMString namespaceURI, in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg); }; Attributes detail of type long, readonly Specifies some detail information about the Event, depending on the type of event. view of type views::AbstractView, readonly The view attribute identifies the AbstractView from which the event was generated. Methods initUIEvent The initUIEvent method is used to initialize the value of a UIEvent created using the DocumentEvent.createEvent method. This method may only be called before the UIEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. Parameters typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. This parameter overrides the intrinsic bubbling behavior of the event. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. This parameter overrides the intrinsic cancelable behavior of the event. viewArg of type views::AbstractView Specifies the Event's AbstractView. detailArg of type long Specifies the Event's detail. No Return Value No Exceptions initUIEventNS introduced in DOM Level 3 The initUIEventNS method is used to initialize the value of a UIEvent created using the DocumentEvent.createEvent method. This method may only be called before the UIEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. Parameters namespaceURI of type DOMString Specifies the namespace URI associated with this event, or null if the application wish not to use namespaces. typeArg of type DOMString Specifies the event type (see also the description of the type attribute in the Event interface). canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. viewArg of type views::AbstractView Specifies the Event's AbstractView. detailArg of type long Specifies the Event's detail. No Return Value No Exceptions The User Interface event types are listed below. For a full description of the semantics associated with these event types, refer to the Complete list of event types. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "UIEvents" and "3.0" (respectively) to determine whether or not the DOM Level 3 User Interface event types are supported by the implementation. In order to fully support this module, an implementation must also support the "Events" feature defined in this specification and the "Views" feature defined in the DOM Level 2 Views specification [DOM Level 2 Views]. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. The DOM Level 3 User Interface Events module is built on top of the DOM Level 2 User Interface Events [DOM Level 2 Events] module, i.e. a DOM Level 3 User Interface Events implementation where hasFeature("UIEvents", "3.0") returns true must also return true when the version number is "2.0", "" or, null. Event type Context information "http://www.w3.org/2001/xml-events", "DOMActivate" UIEvent.view is in use. "http://www.w3.org/2001/xml-events", "DOMFocusIn" (same as above) "http://www.w3.org/2001/xml-events", "DOMFocusOut" (same as above) 1.7.2. Text events The text event module originates from the [HTML 4.01] onkeypress attribute. Unlike this attribute, the event type {"http://www.w3.org/2001/xml-events", "textInput"} applies only to characters and is specifically designed for use with text input devices. Interface TextEvent (introduced in DOM Level 3) The TextEvent interface provides specific contextual information associated with Text Events. Note: To create an instance of the TextEvent interface, use the feature string "TextEvent" as the value of the input parameter used with the DocumentEvent.createEvent method. Issue auto-repeat: In the past, detail was used to contain the repeat count for the key. Do we want to keep this notion? How? using an auto-repeat event instead? Use cases? Resolution: closed. Issue visibleOutputGenerated-1: same question for visibleOutputGenerated: This attribute is device dependent (display related). What happen on voice system for example? What are the real use cases for it? Resolution: closed. Issue paste-1: What happens on paste through Ctrl-V? Do you get a textInput event or not if the selection contains characters? Resolution: This will be undefined by this specification. IDL Definition // Introduced in DOM Level 3: interface TextEvent : UIEvent { readonly attribute DOMString data; void initTextEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in DOMString dataArg); void initTextEventNS(in DOMString namespaceURI, in DOMString type, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in DOMString dataArg); }; Attributes data of type DOMString, readonly data holds the value of the characters generated by the character device. This may be a single Unicode character or it may be a string. Methods initTextEvent The initTextEvent method is used to initialize the value of a TextEvent created using the DocumentEvent.createEvent method. This method may only be called before the TextEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. This method has no effect if called after the event has been dispatched. Parameters typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. This parameter overrides the intrinsic bubbling behavior of the event. cancelableArg of type boolean Specifies whether or not the event's default action can be prevent. This parameter overrides the intrinsic cancelable behavior of the event. viewArg of type views::AbstractView Specifies the TextEvent's view. dataArg of type DOMString Specifies the TextEvent's data attribute No Return Value No Exceptions initTextEventNS The initTextEventNS method is used to initialize the value of a TextEvent created using the DocumentEvent.createEvent method. This method may only be called before the TextEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. This method has no effect if called after the event has been dispatched. Parameters namespaceURI of type DOMString Specifies the namespace URI associated with this event, or null if the applications wish to have no namespace. type of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevent. viewArg of type views::AbstractView Specifies the TextEvent's view. dataArg of type DOMString Specifies the TextEvent's data attribute No Return Value No Exceptions The text event type is listed below. For a full description of the semantics associated with this event type, refer to the Complete list of event types. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "TextEvents" and "3.0" (respectively) to determine whether or not the Text event module is supported by the implementation. In order to fully support this module, an implementation must also support the "UIEvents" feature defined in this specification. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. Event type Context information "http://www.w3.org/2001/xml-events", "textInput" UIEvent.view and TextEvent.data are in use. 1.7.3. Mouse event types The Mouse event module originates from the [HTML 4.01] onclick, ondblclick, onmousedown, onmouseup, onmouseover, onmousemove, and onmouseout attributes. This event module is specifically designed for use with pointing input devices, such a mouse. Interface MouseEvent (introduced in DOM Level 2) The MouseEvent interface provides specific contextual information associated with Mouse events. In the case of nested elements mouse events are always targeted at the most deeply nested element. Ancestors of the targeted element may use bubbling to obtain notification of mouse events which occur within its descendent elements. Note: To create an instance of the MouseEvent interface, use the feature string "MouseEvent" as the value of the input parameter used with the DocumentEvent.createEvent method. IDL Definition // Introduced in DOM Level 2: interface MouseEvent : UIEvent { readonly attribute long screenX; readonly attribute long screenY; readonly attribute long clientX; readonly attribute long clientY; readonly attribute boolean ctrlKey; readonly attribute boolean shiftKey; readonly attribute boolean altKey; readonly attribute boolean metaKey; readonly attribute unsigned short button; readonly attribute EventTarget relatedTarget; void initMouseEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg, in long screenXArg, in long screenYArg, in long clientXArg, in long clientYArg, in boolean ctrlKeyArg, in boolean altKeyArg, in boolean shiftKeyArg, in boolean metaKeyArg, in unsigned short buttonArg, in EventTarget relatedTargetArg); // Introduced in DOM Level 3: void initMouseEventNS(in DOMString namespaceURI, in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg, in long screenXArg, in long screenYArg, in long clientXArg, in long clientYArg, in boolean ctrlKeyArg, in boolean altKeyArg, in boolean shiftKeyArg, in boolean metaKeyArg, in unsigned short buttonArg, in EventTarget relatedTargetArg, in boolean altGraphKeyArg); // Introduced in DOM Level 3: readonly attribute boolean altGraphKey; }; Attributes altGraphKey of type boolean, readonly, introduced in DOM Level 3 true if the alt-graph (Alt Gr) key modifier is activated. Note: Some operating systems simulate the alt-graph key modifier with the combinaison of alt and ctrl key modifiers. Implementations are encouraged to use this modifier instead. altKey of type boolean, readonly true if the alt (alternative) key modifier is activated. button of type unsigned short, readonly During mouse events caused by the depression or release of a mouse button, button is used to indicate which mouse button changed state. 0 indicates the normal (in general on the left or the one button on Macintosh mice, used to activate a button or select text) button of the mouse. 2 indicates the contextual property (in general on the right, used to display a context menu) button of the mouse if present. 1 indicates the extra (in general in the middle and often combined with the mouse wheel) button. Some mice may provide or simulate more buttons and values higher than 2 could be used to represent such buttons. clientX of type long, readonly The horizontal coordinate at which the event occurred relative to the DOM implementation's client area. clientY of type long, readonly The vertical coordinate at which the event occurred relative to the DOM implementation's client area. ctrlKey of type boolean, readonly true if the control (Ctrl) key modifier is activated. metaKey of type boolean, readonly true if the meta (Meta) key modifier is activated. Note: The Command key modifier on Macintosh system must be represented using this key modifier. relatedTarget of type EventTarget, readonly Used to identify a secondary EventTarget related to a UI event. Currently this attribute is used with the mouseover event to indicate the EventTarget which the pointing device exited and with the mouseout event to indicate the EventTarget which the pointing device entered. screenX of type long, readonly The horizontal coordinate at which the event occurred relative to the origin of the screen coordinate system. screenY of type long, readonly The vertical coordinate at which the event occurred relative to the origin of the screen coordinate system. shiftKey of type boolean, readonly true if the shift (Shift) key modifier is activated. Methods initMouseEvent The initMouseEvent method is used to initialize the value of a MouseEvent created using the DocumentEvent.createEvent method. This method may only be called before the MouseEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times before being dispatched. If called multiple times, the final invocation takes precedence. Parameters typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. viewArg of type views::AbstractView Specifies the Event's view. detailArg of type long Specifies the Event's mouse click count. screenXArg of type long Specifies the Event's screen x coordinate screenYArg of type long Specifies the Event's screen y coordinate clientXArg of type long Specifies the Event's client x coordinate clientYArg of type long Specifies the Event's client y coordinate ctrlKeyArg of type boolean Specifies whether or not control key was depressed during the Event. altKeyArg of type boolean Specifies whether or not alt key was depressed during the Event. shiftKeyArg of type boolean Specifies whether or not shift key was depressed during the Event. metaKeyArg of type boolean Specifies whether or not meta key was depressed during the Event. buttonArg of type unsigned short Specifies the Event's mouse button. relatedTargetArg of type EventTarget Specifies the Event's related EventTarget. No Return Value No Exceptions initMouseEventNS introduced in DOM Level 3 The initMouseEventNS method is used to initialize the value of a MouseEvent created using the DocumentEvent.createEvent interface. This method may only be called before the MouseEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. Parameters namespaceURI of type DOMString Specifies the namespace URI associated with this event, or null if the application wish to have no namespace. typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. viewArg of type views::AbstractView Specifies the Event's AbstractView. detailArg of type long Specifies the Event's mouse click count. screenXArg of type long Specifies the Event's screen x coordinate screenYArg of type long Specifies the Event's screen y coordinate clientXArg of type long Specifies the Event's client x coordinate clientYArg of type long Specifies the Event's client y coordinate ctrlKeyArg of type boolean Specifies whether or not control key was depressed during the Event. altKeyArg of type boolean Specifies whether or not alt key was depressed during the Event. shiftKeyArg of type boolean Specifies whether or not shift key was depressed during the Event. metaKeyArg of type boolean Specifies whether or not meta key was depressed during the Event. buttonArg of type unsigned short Specifies the Event's mouse button. relatedTargetArg of type EventTarget Specifies the Event's related EventTarget. altGraphKeyArg of type boolean Specifies whether or not alt graph key was depressed during the Event. No Return Value No Exceptions The Mouse event types are listed below. For a full description of the semantics associated with these event types, refer to the Complete list of event types. In the case of nested elements, mouse event types are always targeted at the most deeply nested element. Ancestors of the targeted element may use bubbling to obtain notification of mouse events which occur within its descendent elements. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "MouseEvents" and "3.0" (respectively) to determine whether or not the Mouse event module is supported by the implementation. In order to fully support this module, an implementation must also support the "UIEvents" feature defined in this specification. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. The DOM Level 3 Mouse Events module is built on top of the DOM Level 2 Mouse Events [DOM Level 2 Events] module, i.e. a DOM Level 3 Mouse Events implementation where hasFeature("MouseEvents", "3.0") returns true must also return true when the version number is "2.0", "" or, null. Event type Context information "http://www.w3.org/2001/xml-events", MouseEvent.screenX, "click" MouseEvent.screenY, MouseEvent.clientX, MouseEvent.clientY, MouseEvent.altKey, MouseEvent.ctrlKey, MouseEvent.shiftKey, MouseEvent.metaKey, MouseEvent.altGraphKey, MouseEvent.button, and UIEvent.view are in use. The UIEvent.detail attribute indicates the number of consecutive clicks of a pointing device button during a user action. The attribute value is 1 when the user begins this action and increments by 1 for each click. The notion of consecutive clicks depends on the environment configuration. For example, a "double click" will not happen if there is a long delay between the two clicks, even if the pointing device did not move. "http://www.w3.org/2001/xml-events", MouseEvent.screenX, "mousedown" MouseEvent.screenY, MouseEvent.clientX, MouseEvent.clientY, MouseEvent.altKey, MouseEvent.ctrlKey, MouseEvent.shiftKey, MouseEvent.metaKey, MouseEvent.altGraphKey, MouseEvent.button, and UIEvent.view are in use. The UIEvent.detail attribute indicates the number of consecutive clicks, incremented by one, of a pointing device button during a user action. For example, if no click happened before the mousedown, UIEvent.detail will contain the value 1. "http://www.w3.org/2001/xml-events", MouseEvent.screenX, "mouseup" MouseEvent.screenY, MouseEvent.clientX, MouseEvent.clientY, MouseEvent.altKey, MouseEvent.ctrlKey, MouseEvent.shiftKey, MouseEvent.metaKey, MouseEvent.altGraphKey, MouseEvent.button, and UIEvent.view are in use. The UIEvent.detail attribute indicates the number of consecutive clicks, incremented by one, of a pointing device button during a user action. For example, if no click happened before the mouseup, UIEvent.detail will contain the value 1. However, if no click is generated after the mouseup, UIEvent.detail contains the value 0, indicating that no click is occurring. "http://www.w3.org/2001/xml-events", MouseEvent.screenX, "mouseover" MouseEvent.screenY, MouseEvent.clientX, MouseEvent.clientY, MouseEvent.altKey, MouseEvent.ctrlKey, MouseEvent.shiftKey, MouseEvent.metaKey, MouseEvent.altGraphKey, and UIEvent.view are in use. MouseEvent.relatedTarget indicates the event target a pointing device is exiting. "http://www.w3.org/2001/xml-events", MouseEvent.screenX, "mousemove" MouseEvent.screenY, MouseEvent.clientX, MouseEvent.clientY, MouseEvent.altKey, MouseEvent.ctrlKey, MouseEvent.shiftKey, MouseEvent.metaKey, MouseEvent.altGraphKey, and UIEvent.view are in use. "http://www.w3.org/2001/xml-events", MouseEvent.screenX, "mouseout" MouseEvent.screenY, MouseEvent.clientX, MouseEvent.clientY, MouseEvent.altKey, MouseEvent.ctrlKey, MouseEvent.shiftKey, MouseEvent.metaKey, MouseEvent.altGraphKey, and UIEvent.view are in use. MouseEvent.relatedTarget indicates the event target a pointing device is entering. As an example, a "double-click" on a mouse device will produce the following events (the value of UIEvent.detail is indicated in parenthesis): 1. {"http://www.w3.org/2001/xml-events", "mousedown"} (1) 2. {"http://www.w3.org/2001/xml-events", "mouseup"} (1) 3. {"http://www.w3.org/2001/xml-events", "click"} (1) 4. {"http://www.w3.org/2001/xml-events", "mousedown"} (2) 5. {"http://www.w3.org/2001/xml-events", "mouseup"} (2) 6. {"http://www.w3.org/2001/xml-events", "click"} (2) (ED: plh -- I added this example above but didn't check if it is correct or not yet (do we have the click(1)?). If it is not, let me know in any case. I'll probably complicate the example a bit (with moves) to show how detail really works. ) 1.7.4. Keyboard event types Keyboard events are device dependent, i.e. they rely on the capabilities of the input devices and how they are mapped in the operating systems. It is therefore highly recommended to rely on Text events when dealing with characters. Interface KeyboardEvent (introduced in DOM Level 3) The KeyboardEvent interface provides specific contextual information associated with keyboard devices. Each keyboard event reference a key using an identifier. Each modifier attribute (ctrlKey, shiftKey, altKey, metaKey, and altGraphKey) is activated when the key modifier is being pressed down or maintained pressed, i.e. the modifier attribute is not in use when the key modifier is being released. Note: To create an instance of the KeyboardEvent interface, use the feature string "KeyboardEvent" as the value of the input parameter used with the DocumentEvent.createEvent method. IDL Definition // Introduced in DOM Level 3: interface KeyboardEvent : UIEvent { // KeyLocationCode const unsigned long DOM_KEY_LOCATION_STANDARD = 0x00; const unsigned long DOM_KEY_LOCATION_LEFT = 0x01; const unsigned long DOM_KEY_LOCATION_RIGHT = 0x02; const unsigned long DOM_KEY_LOCATION_NUMPAD = 0x03; const unsigned long DOM_KEY_LOCATION_UNKNOWN = 0x04; readonly attribute DOMString keyIdentifier; readonly attribute unsigned long keyLocation; readonly attribute boolean ctrlKey; readonly attribute boolean shiftKey; readonly attribute boolean altKey; readonly attribute boolean metaKey; readonly attribute boolean altGraphKey; void initKeyboardEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in DOMString keyIdentifierArg, in unsigned long keyLocationArg, in boolean ctrlKeyArg, in boolean shiftKeyArg, in boolean altKeyArg, in boolean metaKeyArg, in boolean altGraphKeyArg); void initKeyboardEventNS(in DOMString namespaceURI, in DOMString type, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in DOMString keyIdentifierArg, in unsigned long keyLocationArg, in boolean ctrlKeyArg, in boolean shiftKeyArg, in boolean altKeyArg, in boolean metaKeyArg, in boolean altGraphKeyArg); }; Definition group KeyLocationCode Defined Constants DOM_KEY_LOCATION_LEFT The key activated is in the left key location (there is more than one possible location for this key). Example: the left Shift key on a PC 101 Key US. DOM_KEY_LOCATION_NUMPAD The key activation originated on the numeric keypad or with a virtual key corresponding to the numeric keypad. Example: the '1' key on a PC 101 Key US. DOM_KEY_LOCATION_RIGHT The key activation is in the right key location (there is more than one possible location for this key). Example: the right Shift key on a PC 101 Key US. DOM_KEY_LOCATION_STANDARD The key activation is not distinguished as the left or right version of the key, and did not originate from the numeric keypad (or did not originate with a virtual key corresponding to the numeric keypad). Example: the 'Q' key on a PC 101 Key US. DOM_KEY_LOCATION_UNKNOWN Implementations can use this constant to indicate that the location of the key cannot be determined. Note: In case a DOM implementation wishes to provide new location information, all values above the value of this constant can be used for that effect and generic DOM applications should consider values above the value of this constant as being equivalent to DOM_KEY_LOCATION_UNKNOWN. Attributes altGraphKey of type boolean, readonly true if the alt-graph (Alt Gr) key modifier is activated. Note: Some operating systems simulate the alt-graph key modifier with the combinaison of alt and ctrl key modifiers. Implementations are encouraged to use this modifier instead. altKey of type boolean, readonly true if the alt (alternative) key modifier is activated. ctrlKey of type boolean, readonly true if the control (Ctrl) key modifier is activated. keyIdentifier of type DOMString, readonly keyIdentifier holds the identifier of the key. For a list of possible values, refer to Key identifiers for keyboard events.. Note: Implementations that are unable to identify a key must use the key identifier "Unidentified". keyLocation of type unsigned long, readonly The keyLocation attribute contains an indication of the location of they key on the device. metaKey of type boolean, readonly true if the meta (Meta) key modifier is activated. Note: The Command key modifier on Macintosh system must be represented using this key modifier. shiftKey of type boolean, readonly true if the shift (Shift) key modifier is activated. Methods initKeyboardEvent The initKeyboardEvent method is used to initialize the value of a KeyboardEvent created using the DocumentEvent.createEvent method. This method may only be called before the KeyboardEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times before being dispatched if necessary. If called multiple times, the final invocation takes precedence. This method has no effect if called after the event has been dispatched. Parameters typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. This parameter overrides the intrinsic bubbling behavior of the event. cancelableArg of type boolean Specifies whether or not the event's default action can be prevent. This parameter overrides the intrinsic cancelable behavior of the event. viewArg of type views::AbstractView Specifies the KeyboardEvent's AbstractView. keyIdentifierArg of type DOMString Specifies the KeyboardEvent's keyIdentifier attribute. keyLocationArg of type unsigned long Specifies the KeyboardEvent's keyLocation attribute. ctrlKeyArg of type boolean Specifies the KeyboardEvent's ctrlKey attribute. shiftKeyArg of type boolean Specifies the KeyboardEvent's shiftKey attribute. altKeyArg of type boolean Specifies the KeyboardEvent's altKey attribute. metaKeyArg of type boolean Specifies the KeyboardEvent's metaKey attribute. altGraphKeyArg of type boolean Specifies the KeyboardEvent's altGraphKey attribute. No Return Value No Exceptions initKeyboardEventNS The initKeyboardEventNS method is used to initialize the value of a KeyboardEvent created using the DocumentEvent.createEvent method. This method may only be called before the KeyboardEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. This method has no effect if called after the event has been dispatched. Parameters namespaceURI of type DOMString Specifies the namespace URI associated with this event, or null if the applications wish to have no namespace. type of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevent. viewArg of type views::AbstractView Specifies the KeyboardEvent's AbstractView. keyIdentifierArg of type DOMString Specifies the KeyboardEvent's keyIdentifier attribute keyLocationArg of type unsigned long Specifies the KeyboardEvent's keyLocation attribute. ctrlKeyArg of type boolean Specifies the KeyboardEvent's ctrlKey attribute. shiftKeyArg of type boolean Specifies the KeyboardEvent's shiftKey attribute. altKeyArg of type boolean Specifies the KeyboardEvent's altKey attribute. metaKeyArg of type boolean Specifies the KeyboardEvent's metaKey attribute. altGraphKeyArg of type boolean Specifies the KeyboardEvent's altGraphKey attribute. No Return Value No Exceptions Depending on the character device generation system, keyboard events may or may not be generated. The keyboard event types are listed below. For a full description of the semantics associated with these event types, refer to the Complete list of event types. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "KeyboardEvents" and "3.0" (respectively) to determine whether or not the Keyboard event module is supported by the implementation. In order to fully support this module, an implementation must also support the "UIEvents" feature defined in this specification. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. Event type Context information "http://www.w3.org/2001/xml-events", UIEvent.view, "keydown" KeyboardEvent.keyIdentifier, KeyboardEvent.location, KeyboardEvent.altKey, KeyboardEvent.altGraphKey, KeyboardEvent.shiftKey, KeyboardEvent.ctrlKey, and KeyboardEvent.metaKey are in use. "http://www.w3.org/2001/xml-events", UIEvent.view, "keyup" KeyboardEvent.keyIdentifier, and KeyboardEvent.location are in use. KeyboardEvent.altKey, KeyboardEvent.altGraphKey, KeyboardEvent.shiftKey, KeyboardEvent.ctrlKey, and KeyboardEvent.metaKey are in use unless the Keyboard.keyIdentifier corresponds to the key modifier itself. Issue keyboard-1: Should the cancellation of a keydown prevent the textInput/keyup event types from being dispatched? 1.7.5. Mutation and mutation name event types The mutation and mutation name event modules are designed to allow notification of any changes to the structure of a document, including attribute, text, or name modifications. It may be noted that none of the event types associated with the modules are designated as cancelable. This stems from the fact that it is very difficult to make use of existing DOM interfaces which cause document modifications if any change to the document might or might not take place due to cancelation of the resulted event. Although this is still a desired capability, it was decided that it would be better left until the addition of transactions into the DOM. Many single modifications of the tree can cause multiple mutation events to be dispatched. Rather than attempt to specify the ordering of mutation events due to every possible modification of the tree, the ordering of these events is left to the implementation. Interface MutationEvent (introduced in DOM Level 2) The MutationEvent interface provides specific contextual information associated with Mutation events. Note: To create an instance of the MutationEvent interface, use the feature string "MutationEvent" as the value of the input parameter used with the DocumentEvent.createEvent method. IDL Definition // Introduced in DOM Level 2: interface MutationEvent : Event { // attrChangeType const unsigned short MODIFICATION = 1; const unsigned short ADDITION = 2; const unsigned short REMOVAL = 3; readonly attribute Node relatedNode; readonly attribute DOMString prevValue; readonly attribute DOMString newValue; readonly attribute DOMString attrName; readonly attribute unsigned short attrChange; void initMutationEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevValueArg, in DOMString newValueArg, in DOMString attrNameArg, in unsigned short attrChangeArg); // Introduced in DOM Level 3: void initMutationEventNS(in DOMString namespaceURI, in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevValueArg, in DOMString newValueArg, in DOMString attrNameArg, in unsigned short attrChangeArg); }; Definition group attrChangeType An integer indicating in which way the Attr was changed. Defined Constants ADDITION The Attr was just added. MODIFICATION The Attr was modified in place. REMOVAL The Attr was just removed. Attributes attrChange of type unsigned short, readonly attrChange indicates the type of change which triggered the DOMAttrModified event. The values can be MODIFICATION, ADDITION, or REMOVAL. attrName of type DOMString, readonly attrName indicates the name of the changed Attr node in a DOMAttrModified event. newValue of type DOMString, readonly newValue indicates the new value of the Attr node in DOMAttrModified events, and of the CharacterData node in DOMCharacterDataModified events. prevValue of type DOMString, readonly prevValue indicates the previous value of the Attr node in DOMAttrModified events, and of the CharacterData node in DOMCharacterDataModified events. relatedNode of type Node, readonly relatedNode is used to identify a secondary node related to a mutation event. For example, if a mutation event is dispatched to a node indicating that its parent has changed, the relatedNode is the changed parent. If an event is instead dispatched to a subtree indicating a node was changed within it, the relatedNode is the changed node. In the case of the DOMAttrModified event it indicates the Attr node which was modified, added, or removed. Methods initMutationEvent The initMutationEvent method is used to initialize the value of a MutationEvent created using the DocumentEvent.createEvent method. This method may only be called before the MutationEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times before being dispatched if necessary. If called multiple times, the final invocation takes precedence. Parameters typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. This parameter overrides the intrinsic bubbling behavior of the event. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. This parameter overrides the intrinsic cancelable behavior of the event. relatedNodeArg of type Node Specifies the Event's related Node. prevValueArg of type DOMString Specifies the Event's prevValue attribute. This value may be null. newValueArg of type DOMString Specifies the Event's newValue attribute. This value may be null. attrNameArg of type DOMString Specifies the Event's attrName attribute. This value may be null. attrChangeArg of type unsigned short Specifies the Event's attrChange attribute. No Return Value No Exceptions initMutationEventNS introduced in DOM Level 3 The initMutationEventNS method is used to initialize the value of a MutationEvent created using the DocumentEvent.createEvent method. This method may only be called before the MutationEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. Parameters namespaceURI of type DOMString Specifies the namespace URI associated with this event, or null if the application wish to have no namespace. typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. relatedNodeArg of type Node Specifies the Event's related Node. prevValueArg of type DOMString Specifies the Event's prevValue attribute. This value may be null. newValueArg of type DOMString Specifies the Event's newValue attribute. This value may be null. attrNameArg of type DOMString Specifies the Event's attrName attribute. This value may be null. attrChangeArg of type unsigned short Specifies the Event's attrChange attribute. No Return Value No Exceptions The mutation event types are listed below. For a full description of the semantics associated with these event types, refer to the Complete list of event types. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "MutationEvents" and "3.0" (respectively) to determine whether or not the MutationEvent is supported by the implementation. In order to fully support this module, an implementation must also support the "Events" feature defined in this specification. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. This MutationEvent interface is built on top of the DOM Level 2 Mutation Events [DOM Level 2 Events] module, i.e. a DOM Level 3 MutationEvent interface implementation where hasFeature("MutationEvents","3.0") returns true must also return true when the version number is "2.0", "" or, null. Event type Context information "http://www.w3.org/2001/xml-events", None "DOMSubtreeModified" "http://www.w3.org/2001/xml-events", MutationEvent.relatedNode holds "DOMNodeInserted" the parent node of the node being inserted. "http://www.w3.org/2001/xml-events", MutationEvent.relatedNode holds "DOMNodeRemoved" the parent node of the node being removed. "http://www.w3.org/2001/xml-events", None "DOMNodeRemovedFromDocument" "http://www.w3.org/2001/xml-events", None "DOMNodeInsertedIntoDocument" "http://www.w3.org/2001/xml-events", MutationEvent.attrName is in use. "DOMAttrModified" The value of MutationEvent.relatedNode indicates the Attr node whose value has been affected. The value of MutationEvent.attrChange indicates whether the Attr was modified, added, or removed. If the Attr node is being added, MutationEvent.newValue is in use. If the Attr node is being removed, MutationEvent.prevValue is in value. If the Attr node is being modified, MutationEvent.newValue and MutationEvent.prevValue are in use. "http://www.w3.org/2001/xml-events", MutationEvent.prevValue, and "DOMCharacterDataModified" MutationEvent.newValue are in use. Interface MutationNameEvent (introduced in DOM Level 3) The MutationNameEvent interface provides specific contextual information associated with Mutation name event types. Note: To create an instance of the MutationNameEvent interface, use the feature string "MutationNameEvent" as the value of the input parameter used with the createEvent method of the DocumentEvent interface. IDL Definition // Introduced in DOM Level 3: interface MutationNameEvent : MutationEvent { readonly attribute DOMString prevNamespaceURI; readonly attribute DOMString prevNodeName; // Introduced in DOM Level 3: void initMutationNameEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevNamespaceURI, in DOMString prevNodeName); // Introduced in DOM Level 3: void initMutationNameEventNS(in DOMString namespaceURI, in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevNamespaceURI, in DOMString prevNodeName); }; Attributes prevNamespaceURI of type DOMString, readonly The previous value of the relatedNode's namespaceURI. prevNodeName of type DOMString, readonly The previous value of the relatedNode's nodeName. Methods initMutationNameEvent introduced in DOM Level 3 The initMutationNameEvent method is used to initialize the value of a MutationNameEvent created using the DocumentEvent.createEvent method. This method may only be called before the MutationNameEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. Parameters typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. relatedNodeArg of type Node Specifies the Event's related Node. prevNamespaceURI of type DOMString Specifies the previous namespaceURI of the related Node. This value may be null. prevNodeName of type DOMString Specifies the previous nodeName of the related Node. No Return Value No Exceptions initMutationNameEventNS introduced in DOM Level 3 The initMutationNameEventNS method is used to initialize the value of a MutationNameEvent created using the DocumentEvent.createEvent method. This method may only be called before the MutationNameEvent has been dispatched via the EventTarget.dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence. Parameters namespaceURI of type DOMString Specifies the namespace URI associated with this event, or null if the application wish to have no namespace. typeArg of type DOMString Specifies the event type. canBubbleArg of type boolean Specifies whether or not the event can bubble. cancelableArg of type boolean Specifies whether or not the event's default action can be prevented. relatedNodeArg of type Node Specifies the Event's related Node. prevNamespaceURI of type DOMString Specifies the previous namespaceURI of the related Node. This value may be null. prevNodeName of type DOMString Specifies the previous nodeName of the related Node. No Return Value No Exceptions The mutation name event types are listed below. For a full description of the semantics associated with these event types, refer to the Complete list of event types. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "MutationNameEvents" and "3.0" (respectively) to determine whether or not the MutationNameEvent is supported by the implementation. In order to fully support this module, an implementation must also support the "MutationEvents" feature defined in this specification and the "Core" feature defined in the DOM Level 3 Core specification [DOM Level 3 Core]. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. Event type Context information "http://www.w3.org/2001/xml-events", MutationNameEvent.prevNamespaceURI, "DOMElementNameChanged" and MutationNameEvent.prevNodeName are in use. "http://www.w3.org/2001/xml-events", MutationNameEvent.prevNamespaceURI, "DOMAttributeNameChanged" and MutationNameEvent.prevNodeName are in use. The value of MutationEvent.relatedNode contains the renamed Attr node. 1.7.6. Basic event types This event module contains basic event types associated with document manipulation. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "BasicEvents" and "3.0" (respectively) to determine whether or not the basic event module is supported by the implementation. In order to fully support this module, an implementation must also support the "Events" feature defined in this specification. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. The basic event types are listed below. For a full description of the semantics associated with these event types, refer to the Complete list of event types. The event types {"http://www.w3.org/2001/xml-events", "resize"} and {"http://www.w3.org/2001/xml-events", "scroll"} implement the UIEvent interface. All other HTML event types implement at least the basic Event interface. However, they may be generated from a user interface; in that case, the event objects also implements the UIEvent interface and UIEvent.view is in use. Event type Context information "http://www.w3.org/2001/xml-events", "load" UIEvent.view may be in use. "http://www.w3.org/2001/xml-events", "unload" (same as above) "http://www.w3.org/2001/xml-events", "abort" (same as above) "http://www.w3.org/2001/xml-events", "error" (same as above) "http://www.w3.org/2001/xml-events", "select" (same as above) "http://www.w3.org/2001/xml-events", "change" (same as above) "http://www.w3.org/2001/xml-events", "submit" (same as above) "http://www.w3.org/2001/xml-events", "reset" (same as above) "http://www.w3.org/2001/xml-events", "resize" UIEvent.view is in use. "http://www.w3.org/2001/xml-events", "scroll" UIEvent.view is in use. 1.7.7. HTML Events The HTML event module is composed of events listed in [HTML 4.01] and additional events which are supported in DOM Level 0 browsers. It refines the semantics and scope of the basic event types and provides two new event types. This event module is only applicable if the Document supports the [DOM Level 2 HTML] specification. Use Node.isSupported(feature, version) with the parameter values "HTML" and "2.0" (respectively) to determine whether or not the Document node supported the HTML module. A DOM application may use the hasFeature(feature, version) method of the DOMImplementation interface with parameter values "HTMLEvents" and "3.0" (respectively) to determine whether or not the HTML event module is supported by the implementation. In order to fully support this module, an implementation must also support the "BasicEvents" feature defined in this specification and the "HTML" feature defined in [DOM Level 2 HTML]. For additional information about conformance, please see the DOM Level 3 Core specification [DOM Level 3 Core]. The DOM Level 3 HTML Events module is built on top of the DOM Level 2 HTML Events [DOM Level 2 Events] module, i.e. a DOM Level 3 HTML Events implementation where hasFeature("HTMLEvents", "3.0") returns true must also return true when the version number is "2.0", "" or, null. Event type Description Target node "http://www.w3.org/2001/xml-events", The DOM implementation HTMLBodyElement, "load" finishes loading all HTMLFrameSetElement, content within the BODY HTMLObjectElement, element, all frames HTMLLinkElement, within a FRAMESET, or anyHTMLMetaElement, resource linked from the HTMLScriptElement, document. HTMLFrameElement, HTMLIFrameElement, HTMLImageElement "http://www.w3.org/2001/xml-events", The DOM implementation HTMLBodyElement, "unload" removes a document from aHTMLFrameSetElement window or frame. This event is valid for BODY and FRAMESET elements. "http://www.w3.org/2001/xml-events", The page loading is HTMLObjectElement "abort" stopped before an image has been allowed to completely load. This event applies to OBJECT elements. "http://www.w3.org/2001/xml-events", An image does not load HTMLObjectElement, "error" properly or when an errorHTMLBodyElement, occurs during script HTMLFrameSetElement execution. This event is valid for OBJECT elements, BODY elements, and FRAMESET element. "http://www.w3.org/2001/xml-events", A user selects some text HTMLInputElement, "select" in a text field either HTMLTextAreaElement via the user interface or via attributes defined in [DOM Level 2 HTML]. This event is valid for INPUT and TEXTAREA elements. "http://www.w3.org/2001/xml-events", A control loses the inputHTMLInputElement, "change" focus and its value has HTMLSelectElement, been modified since HTMLTextAreaElement gaining focus. This event can occur either via a user interface manipulation or the focus() methods and the attributes defined in [DOM Level 2 HTML]. This event is valid for INPUT, SELECT, and TEXTAREA element. "http://www.w3.org/2001/xml-events", A form is submitted HTMLFormElement "submit" either via a button. This event only applies to the FORM element. Note that the HTMLFormElement.submit() method defined in [DOM Level 2 HTML] does not fire this event type. "http://www.w3.org/2001/xml-events", A form is reset either HTMLFormElement "reset" via a button, or the HTMLFormElement.reset() method defined in [DOM Level 2 HTML]. This event only applies to the FORM element. "http://www.w3.org/2001/xml-events", A document view is HTMLDocument "resize" resized. "http://www.w3.org/2001/xml-events", A document view is HTMLDocument "scroll" scrolled. The following new event types are defined: Event type Description BubblingCancelable Target node DOM phase interface "http://www.w3.org/2001/xml-events", An element receives focus either via No No HTMLAnchorElement, Event "focus" a pointing device, the focus() HTMLAreaElement, methods defined in [DOM Level 2 HTMLLabelElement, HTML], or by tabbing navigation. This HTMLInputElement, event is only valid for the following HTMLSelectElement, elements: A, AREA, LABEL, INPUT, HTMLtextAreaElement, SELECT, TEXTAREA, and BUTTON. This HTMLButtonElement. event type is dispatched after the event type {"http://www.w3.org/2001/xml-events", "DOMFocusIn"}. "http://www.w3.org/2001/xml-events", An element loses focus either via a No No HTMLAnchorElement, Event "blur" pointing device, the blur() methods HTMLAreaElement, defined in [DOM Level 2 HTML], or by HTMLLabelElement, tabbing navigation. This event is HTMLInputElement, only valid for the following HTMLSelectElement, elements: A, AREA, LABEL, INPUT, HTMLtextAreaElement, SELECT, TEXTAREA, and BUTTON. This HTMLButtonElement. event type is dispatched after the event type {"http://www.w3.org/2001/xml-events", "DOMFocusOut"}. The event types {"http://www.w3.org/2001/xml-events", "focus"} and {"http://www.w3.org/2001/xml-events", "blur"} may be generated from a user interface; in that case, the event objects also implements the UIEvent interface and UIEvent.view is in use. 1.7.7.1. Activation and default actions The concept of activation ({"http://www.w3.org/2001/xml-events", "DOMActivate"}) was introduced in [DOM Level 2 Events] to separate generic actions from the devices used to activate them. For example, an hyperlink can be activated using a mouse or a keyboard, and the activation will force the user agent to follow the link. It is expected that the action of following the link is done using a default action attached to the hyperlink element. In such case, the default action of the device event type is to trigger the event type {"http://www.w3.org/2001/xml-events", "DOMActivate"}. Preventing the default action of a mouse click when the target node is an hyperlink will prevent the activation. The same approach is made for control elements. If a change is made before the activation, cancelling the device event type will also reverse the change. A good example is the attribute HTMLInputElement.checked. As described in [DOM Level 2 HTML], the value of this property may be changed before the dispatch of the event: the user clicks on the radio button, the radio button is being checked (or unchecked) on the display, the attribute HTMLInputElement.checked is changed as well, and then the device event type {"http://www.w3.org/2001/xml-events", "click"} is being dispatched. If the default action of the device event type is prevented, or if the default action attached to the {"http://www.w3.org/2001/xml-events", "DOMActivate"} event type is prevented, the value of the property will need to be changed back to its original value. 31 March 2003 Appendix A: Key identifiers for keyboard events. Editor: Philippe Le Hégaret, W3C A.1: Introduction Each keyboard event references a key using a DOMString key identifier. The set contained in this appendix is based on the sets of keycodes from: * the interface java.awt.event.KeyEvent of the Java 2 Platform v1.4 [KeyEvent for Java]; * the enumeration System.Windows.Forms.Keys of the Microsoft .NET Framework 1.0 [Keys enumeration for .Net]. While implementations are recommended to use the most relevant identifier for a key independently of the platform or keyboard layout mappings, DOM applications should not make assumption on the ability of keyboard devices to generate them. When using keyboard events, "consider using numbers and function keys (F4, F5, and so on) instead of letters in shortcut-key combinaisons" ([DWW95]) given that most keyboard layouts will provide keys for those. "U+000000", "U+000001", ..., "U+FFFFFF" are Unicode based key identifiers ([Unicode 3.0]). When a key cannot be mapped to Unicode, a specific identifier is used (see also Guidelines for defining key identifiers). In any case, no assumption should be made between the sequence of keyboard events and the text events. The following three examples illustrated the concept of keyboard layout mappings and its relation with keyboard events. The keystroke "U+000051" (Latin Capital Letter Q key) will produce (on a PC/AT US keyboard using a US keyboard layout mapping and without any modifier activated) the Unicode character q (Latin Small Letter Q): 1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000051" (Latin Capital Letter Q key) 2. {"http://www.w3.org/2001/xml-events", "textInput"}: "q" 3. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000051" (Latin Capital Letter Q key) If the keyboard layout mapping is switched to a french mapping, pressing the same key will produce: 1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000041" 2. {"http://www.w3.org/2001/xml-events", "textInput"}: "a" 3. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000041" If the keyboard layout mapping is switched to a serbian (cyrillic) mapping, pressing the same key will produce: 1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000409" 2. {"http://www.w3.org/2001/xml-events", "textInput"}: "?" 3. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000409" Note: The order between the text event and keyboard events may differ depending on the keyboard devices. A.1.1: Modifier keys Keyboard input use modifier keys to change the normal behavior of a key. The KeyboardEvent interface provides specific attributes for them: KeyboardEvent.ctrlKey, KeyboardEvent.shiftKey, KeyboardEvent.altKey, KeyboardEvent.metaKey, and KeyboardEvent.altGraphKey. The following example describes a possible sequence of keys to generate the Unicode character Q (Latin Capital Letter Q) on a PC/AT US keyboard using a US mapping: 1. {"http://www.w3.org/2001/xml-events", "keydown"}: "Shift", shiftKey 2. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000051" (Latin Capital Letter Q key), shiftKey 3. {"http://www.w3.org/2001/xml-events", "textInput"}: "Q" 4. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000051" (Latin Capital Letter Q key), shiftKey 5. {"http://www.w3.org/2001/xml-events", "keyup"}: "Shift" The following example describes a possible sequence of keys that does not generate a Unicode character (using the same configuration): 1. {"http://www.w3.org/2001/xml-events", "keydown"}: "Control", ctrlKey 2. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000056" (Latin Capital Letter V key), ctrlKey 3. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000056" (Latin Capital Letter V key), ctrlKey 4. {"http://www.w3.org/2001/xml-events", "keyup"}: "Control" A.1.2: Dead keys Keyboard input use dead keys for the input of composed character sequences. Unlike the handwriting sequence, in which users type the base character first, keyboard input require to enter a special state when a dead key is pressed and emit the character(s) only when one of a limited number of "legal" base character is entered. The dead keys are represented in the key identifiers set using combining diacritical marks. The sequence of keystrokes "U+000302" (Combining Circumflex Accent key) and "U+000045" (Latin Capital Letter E key) will likely produce (on a PC/AT french keyboard using a french mapping and without any modifier activated) the Unicode character é (Latin Small Letter E With Acute) or the composed Unicode character sequence e (Latin Small Letter E) and 000302 (Combining Circumflex Accent). In practice, french keyboard input will generate the Unicode character é instead of the composed Unicode character sequence, as shown in the following example: 1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000302" (Combining Circumflex Accent key) 2. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000302" (Combining Circumflex Accent key) 3. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000045" (Latin Capital Letter E key) 4. {"http://www.w3.org/2001/xml-events", "textInput"}: "é" 5. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000045" (Latin Capital Letter E key) A.1.3: Input Method Editors Also known as front end processor, an input method editor (IME) is an application that performs the conversion between keystrokes and ideographs or other characters, usually by user-guided dictionary lookup. The IMEs function keys are not represented in this set. As an example, receiving an keydown for the "Accept" key identifier does not necessarily implies that the text currently selected in the IME is being accepted. It only indicates that a keystroke happened, disconnected from the IME Accept functionality. Depending on the device in use, the IME Accept functionality can be obtain using the Accept key or the Return key. Keyboard events cannot be used to determine the current state of the input method editor. Keyboard events correspond to the events generated by the input device after the keyboard layout mapping but before the processing of the input method editor. The following example describes a possible sequence of keys to generate the Unicode character ? (Hiragana Letter SI) using Japanese input methods. This assumes that the input method editor is activated and in the Japanese-Romaji input mode. The keys "Convert" and "Accept" may be replaced by others depending on the input device in use and the configuration of the IME, e.g. it could be respectively "U+000020" (Space key) and "Enter". 1. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000053" (Latin Capital Letter S key) 2. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000053" (Latin Capital Letter S key) 3. {"http://www.w3.org/2001/xml-events", "keydown"}: "U+000049" (Latin Capital Letter I key) 4. {"http://www.w3.org/2001/xml-events", "keyup"}: "U+000049" (Latin Capital Letter I key) 5. {"http://www.w3.org/2001/xml-events", "keydown"}: "Convert" 6. {"http://www.w3.org/2001/xml-events", "keyup"}: "Convert" 7. {"http://www.w3.org/2001/xml-events", "keydown"}: "Accept" 8. {"http://www.w3.org/2001/xml-events", "textInput"}: "?" 9. {"http://www.w3.org/2001/xml-events", "keyup"}: "Accept" Note: This specification does not provide a representation of the input method editor (IME) events, e.g. representing the input context. A.1.4: Guidelines for defining key identifiers Note: This section is informative. The list of key identifiers contained in this appendix is not exhaustive and input devices may have to define their own key identifiers. Here is a algorithm to determine which key identifier to use: 1. Determine a representation for the key by looking at the keyboard layout mapping in use (and not the keyboard device in use). This representation should be unique, as human friendly as possible, platform independent, and consistent. For example, on PC/AT US keyboards with a US mapping, the 'Q' key is mapped to the key identifier "U+000051" (Latin Capital Letter Q key), the '1/!' key is mapped to the key identifier "U+000031" (Digit One key), the key '`/~' is mapped to the key identifier "U+000060" (Grave Accent key), and the 'Enter' key is mapped to the key identifier "Enter". 2. Find an appropriate mapping in the Unicode character set. There might not always be an appropriate and obvious mapping: the Unicode set contains characters and symbols, the key might generate different characters depending on the operating system, ... In general, unless the representation of the key can be mapped to a unique Unicode character, it is better to create a new one. 3. If no appropriate mapping was found, create an key identifier as human friendly as possible. As an example, the Enter key is mapped to the key identifier "Enter" and not to "U+00000A" (Line Feed), given that this key generates the character 00000A on Unix operating systems and the characters 00000D and 00000A on Windows operating systems. A.2: Key identifiers set Note: The keycodes Multiply, Add, Substract, Decimal, Separator, Divide, NumPad0, NumPad1, NumPad2, NumPad3, NumPad4, NumPad5, NumPad6, NumPad7, NumPad8, and NumPad9 are not part of this set. Use KeyBoard.keyLocation to know if a key originated from the numeric keypad. "Accept" The Accept (Commit) key. "Again" The Again key. "AllCandidates" The All Candidates key. "Alphanumeric" The Alphanumeric key. "Alt" The Alt (Menu) key. "AltGraph" The Alt-Graph key. "Apps" The Application key. "Attn" The ATTN key. "BrowserBack" The Browser Back key. "BrowserFavorites" The Browser Favorites key. "BrowserForward" The Browser Forward key. "BrowserHome" The Browser Home key. "BrowserRefresh" The Browser Refresh key. "BrowserSearch" The Browser Search key. "BrowserStop" The Browser Stop key. "CapsLock" The Caps Lock (Capital) key. "Clear" The Clear key. "CodeInput" The Code Input key. "Compose" The Compose key. "Control" The Control (Ctrl) key. "Crsel" The Crsel key. "Convert" The Convert key. "Copy" The Copy key. "Cut" The Cut key. "Down" The Down Arrow key. "End" The End key. "Enter" The Enter key. Note: This key identifier is also used for the Return (Macintosh numpad) key. "EraseEof" The Erase EOF key. "Execute" The Execute key. "Exsel" The Exsel key. "F1" The F1 key. "F2" The F2 key. "F3" The F3 key. "F4" The F4 key. "F5" The F5 key. "F6" The F6 key. "F7" The F7 key. "F8" The F8 key. "F9" The F9 key. "F10" The F10 key. "F11" The F11 key. "F12" The F12 key. "F13" The F13 key. "F14" The F14 key. "F15" The F15 key. "F16" The F16 key. "F17" The F17 key. "F18" The F18 key. "F19" The F19 key. "F20" The F20 key. "F21" The F21 key. "F22" The F22 key. "F23" The F23 key. "F24" The F24 key. "FinalMode" The Final Mode (Final) key used on some asian keyboards. "Find" The Find key. "FullWidth" The Full-Width Characters key. "HalfWidth" The Half-Width Characters key. "HangulMode" The Hangul (Korean characters) Mode key. "HanjaMode" The Hanja (Korean characters) Mode key. "Help" The Help key. "Hiragana" The Hiragana (Japanese Kana characters) key. "Home" The Home key. "Insert" The Insert (Ins) key. "JapaneseHiragana" The Japanese-Hiragana key. "JapaneseKatakana" The Japanese-Katakana key. "JapaneseRomaji" The Japanese-Romaji key. "JunjaMode" The Junja Mode key. "KanaMode" The Kana Mode (Kana Lock) key. "KanjiMode" The Kanji (Japanese name for ideographic characters of Chinese origin) Mode key. "Katakana" The Katakana (Japanese Kana characters) key. "LaunchApplication1" The Start Application One key. "LaunchApplication2" The Start Application Two key. "LaunchMail" The Start Mail key. "Left" The Left Arrow key. "Meta" The Meta key. "MediaNextTrack" The Media Next Track key. "MediaPlayPause" The Media Play Pause key. "MediaPreviousTrack" The Media Previous Track key. "MediaStop" The Media Stok key. "ModeChange" The Mode Change key. "Nonconvert" The Nonconvert (Don't Convert) key. "NumLock" The Num Lock key. "PageDown" The Page Down (Next) key. "PageUp" The Page Up key. "Paste" The Paste key. "Pause" The Pause key. "Play" The Play key. "PreviousCandidate" The Previous Candidate function key. "PrintScreen" The Print Screen (PrintScrn, SnapShot) key. "Process" The Process key. "Props" The Props key. "Right" The Right Arrow key. "RomanCharacters" The Roman Characters function key. "Scroll" The Scroll Lock key. "Select" The Select key. "SelectMedia" The Select Media key. "Shift" The Shift key. "Stop" The Stop key. "Up" The Up Arrow key. "Undo" The Undo key. "VolumeDown" The Volume Down key. "VolumeMute" The Volume Mute key. "VolumeUp" The Volume Up key. "Win" The Windows Logo key. "Zoom" The Zoom key. "U+000008" The Backspace (Back) key. "U+000009" The Horizontal Tabulation (Tab) key. "U+000018" The Cancel key. "U+00001B" The Escape (Esc) key. "U+000020" The Space (Spacebar) key. "U+000021" The Exclamation Mark (Factorial, Bang) key (!). "U+000022" The Quotation Mark (Quote Double) key ("). "U+000023" The Number Sign (Pound Sign, Hash, Crosshatch, Octothorpe) key (#). "U+000024" The Dollar Sign (milreis, escudo) key ($). "U+000026" The Ampersand key (&). "U+000027" The Apostrophe (Apostrophe-Quote, APL Quote) key ('). "U+000028" The Left Parenthesis (Opening Parenthesis) key ((). "U+000029" The Right Parenthesis (Closing Parenthesis) key ()). "U+00002A" The Asterix (Star) key (*). "U+00002B" The Plus Sign (Plus) key (+). "U+00002C" The Comma (decimal separator) sign key (,). "U+00002D" The Hyphen-minus (hyphen or minus sign) key (-). "U+00002E" The Full Stop (period, dot, decimal point) key (.). "U+00002F" The Solidus (slash, virgule, shilling) key (/). "U+000030" The Digit Zero key (0). "U+000031" The Digit One key (1). "U+000032" The Digit Two key (2). "U+000033" The Digit Three key (3). "U+000034" The Digit Four key (4). "U+000035" The Digit Five key (5). "U+000036" The Digit Six key (6). "U+000037" The Digit Seven key (7). "U+000038" The Digit Eight key (8). "U+000039" The Digit Nine key (9). "U+00003A" The Colon key (:). "U+00003B" The Semicolon key (;). "U+00003C" The Less-Than Sign key (<). "U+00003D" The Equals Sign key (=). "U+00003E" The Greater-Than Sign key (>). "U+00003F" The Question Mark key (?). "U+000040" The Commercial At (@) key. "U+000041" The Latin Capital Letter A key (A). "U+000042" The Latin Capital Letter B key (B). "U+000043" The Latin Capital Letter C key (C). "U+000044" The Latin Capital Letter D key (D). "U+000045" The Latin Capital Letter E key (E). "U+000046" The Latin Capital Letter F key (F). "U+000047" The Latin Capital Letter G key (G). "U+000048" The Latin Capital Letter H key (H). "U+000049" The Latin Capital Letter I key (I). "U+00004A" The Latin Capital Letter J key (J). "U+00004B" The Latin Capital Letter K key (K). "U+00004C" The Latin Capital Letter L key (L). "U+00004D" The Latin Capital Letter M key (M). "U+00004E" The Latin Capital Letter N key (N). "U+00004F" The Latin Capital Letter O key (O). "U+000050" The Latin Capital Letter P key (P). "U+000051" The Latin Capital Letter Q key (Q). "U+000052" The Latin Capital Letter R key (R). "U+000053" The Latin Capital Letter S key (S). "U+000054" The Latin Capital Letter T key (T). "U+000055" The Latin Capital Letter U key (U). "U+000056" The Latin Capital Letter V key (V). "U+000057" The Latin Capital Letter W key (W). "U+000058" The Latin Capital Letter X key (X). "U+000059" The Latin Capital Letter Y key (Y). "U+00005A" The Latin Capital Letter Z key (Z). "U+00005B" The Left Square Bracket (Opening Square Bracket) key ([). "U+00005C" The Reverse Solidus (Backslash) key (\). "U+00005D" The Right Square Bracket (Closing Square Bracket) key (]). "U+00005E" The Circumflex Accent key (^). "U+00005F" The Low Sign (Spacing Underscore, Underscore) key (_). "U+000060" The Grave Accent (Back Quote) key (`). "U+00007B" The Left Curly Bracket (Opening Curly Bracket, Opening Brace, Brace Left) key ({). "U+00007C" The Vertical Line (Vertical Bar, Pipe) key (|). "U+00007D" The Right Curly Bracket (Closing Curly Bracket, Closing Brace, Brace Right) key (}). "U+00007F" The Delete (Del) Key. "U+0000A1" The Inverted Exclamation Mark key (¡). "U+000300" The Combining Grave Accent (Greek Varia, Dead Grave) key. "U+000301" The Combining Acute Accent (Stress Mark, Greek Oxia, Tonos, Dead Eacute) key. "U+000302" The Combining Circumflex Accent (Hat, Dead Circumflex) key. "U+000303" The Combining Tilde (Dead Tilde) key. "U+000304" The Combining Macron (Long, Dead Macron) key. "U+000306" The Combining Breve (Short, Dead Breve) key. "U+000307" The Combining Dot Above (Derivative, Dead Above Dot) key. "U+000308" The Combining Diaeresis (Double Dot Abode, Umlaut, Greek Dialytika, Double Derivative, Dead Diaeresis) key. "U+00030A" The Combining Ring Above (Dead Above Ring) key. "U+00030B" The Combining Double Acute Accent (Dead Doubleacute) key. "U+00030C" The Combining Caron (Hacek, V Above, Dead Caron) key. "U+000327" The Combining Cedilla (Dead Cedilla) key. "U+000328" The Combining Ogonek (Nasal Hook, Dead Ogonek) key. "U+000345" The Combining Greek Ypogegrammeni (Greek Non-Spacing Iota Below, Iota Subscript, Dead Iota) key. "U+0020AC" The Euro Currency Sign key (EUR). "U+003099" The Combining Katakana-Hiragana Voiced Sound Mark (Dead Voiced Sound) key. "U+00309A" The Combining Katakana-Hiragana Semi-Voiced Sound Mark (Dead Semivoiced Sound) key. 31 March 2003 Appendix B: Changes Editor: Philippe Le Hégaret, W3C B.1: Changes between DOM Level 2 Events and DOM Level 3 Events This new specification provides a better separation between the DOM even flow, the event types, and the DOM interfaces. B.1.1: Changes to DOM Level 2 event flow This new specification introduced two new concepts in the event flow: * event groups: unlike DOM Level 2 Events, stopPropagation does no longer stop the event propagation entirely. It only stops it for a given event group. * partial ordering of event listeners: within an event group, event listeners are now ordered while ordering was unspecified in DOM Level 2 Events. B.1.2: Changes to DOM Level 2 event types Lots of clarifications have been made on the event types. The conformance is now explicitly defined against the event types, and not only the interfaces required by the event types. Support for namespaces and the feature "BasicEvents" have been introduced. The DOM Level 2 Event load event type can now be dispatched to more [HTML 4.01] elements. blur and focus have been clarified and restricted to [HTML 4.01] applications only. B.1.3: Changes to DOM Level 2 Events interfaces Interface Event The Event interface has a new attribute namespaceURI, and a four new methods: isDefaultPrevented, isCustom, stopImmediatePropagation, isPropagationStopped, initEventNS. Interface EventTarget The EventTarget interface has four new methods: addEventListenerNS, removeEventListenerNS, willTriggerNS, hasEventListenerNS. Interface DocumentEvent The Event interface has one new method: canDispatch. Interface UIEvent The UIEvent interface has a new method initUIEventNS. Interface MouseEvent The MouseEvent interface has a new method initMouseEventNS and a new attribute altGraphKey. Interface MutationEvent The MutationEvent interface has a new method initMutationEventNS. Exception EventException The DISPATCH_REQUEST_ERR constant has been added. B.1.4: New Interfaces The interfaces CustomEvent, TextEvent, KeyboardEvent, and MutationNameEvent were added to the Events module. 31 March 2003 Appendix C: IDL Definitions This appendix contains the complete OMG IDL [OMG IDL] for the Level 3 Document Object Model Events definitions. The IDL files are also available as: http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/idl.zip events.idl: // File: events.idl #ifndef _EVENTS_IDL_ #define _EVENTS_IDL_ #include "dom.idl" #include "views.idl" #pragma prefix "dom.w3c.org" module events { typedef dom::DOMString DOMString; typedef dom::DOMTimeStamp DOMTimeStamp; typedef dom::DOMObject DOMObject; typedef dom::Node Node; interface EventTarget; interface EventListener; // Introduced in DOM Level 2: exception EventException { unsigned short code; }; // EventExceptionCode const unsigned short UNSPECIFIED_EVENT_TYPE_ERR = 0; // Introduced in DOM Level 3: const unsigned short DISPATCH_REQUEST_ERR = 1; // Introduced in DOM Level 2: interface Event { // PhaseType const unsigned short CAPTURING_PHASE = 1; const unsigned short AT_TARGET = 2; const unsigned short BUBBLING_PHASE = 3; readonly attribute DOMString type; readonly attribute EventTarget target; readonly attribute EventTarget currentTarget; readonly attribute unsigned short eventPhase; readonly attribute boolean bubbles; readonly attribute boolean cancelable; readonly attribute DOMTimeStamp timeStamp; void stopPropagation(); void preventDefault(); void initEvent(in DOMString eventTypeArg, in boolean canBubbleArg, in boolean cancelableArg); // Introduced in DOM Level 3: readonly attribute DOMString namespaceURI; // Introduced in DOM Level 3: boolean isCustom(); // Introduced in DOM Level 3: void stopImmediatePropagation(); // Introduced in DOM Level 3: boolean isDefaultPrevented(); // Introduced in DOM Level 3: void initEventNS(in DOMString namespaceURIArg, in DOMString eventTypeArg, in boolean canBubbleArg, in boolean cancelableArg); }; // Introduced in DOM Level 2: interface EventTarget { void addEventListener(in DOMString type, in EventListener listener, in boolean useCapture); void removeEventListener(in DOMString type, in EventListener listener, in boolean useCapture); // Modified in DOM Level 3: boolean dispatchEvent(in Event evt) raises(EventException); // Introduced in DOM Level 3: void addEventListenerNS(in DOMString namespaceURI, in DOMString type, in EventListener listener, in boolean useCapture, in DOMObject evtGroup); // Introduced in DOM Level 3: void removeEventListenerNS(in DOMString namespaceURI, in DOMString type, in EventListener listener, in boolean useCapture); // Introduced in DOM Level 3: boolean willTriggerNS(in DOMString namespaceURI, in DOMString type); // Introduced in DOM Level 3: boolean hasEventListenerNS(in DOMString namespaceURI, in DOMString type); }; // Introduced in DOM Level 2: interface EventListener { void handleEvent(in Event evt); }; // Introduced in DOM Level 2: interface DocumentEvent { Event createEvent(in DOMString eventType) raises(dom::DOMException); // Introduced in DOM Level 3: boolean canDispatch(in DOMString namespaceURI, in DOMString type); }; // Introduced in DOM Level 3: interface CustomEvent : Event { void setDispatchState(in EventTarget target, in unsigned short phase); boolean isPropagationStopped(); boolean isImmediatePropagationStopped(); }; // Introduced in DOM Level 2: interface UIEvent : Event { readonly attribute views::AbstractView view; readonly attribute long detail; void initUIEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg); // Introduced in DOM Level 3: void initUIEventNS(in DOMString namespaceURI, in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg); }; // Introduced in DOM Level 3: interface TextEvent : UIEvent { readonly attribute DOMString data; void initTextEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in DOMString dataArg); void initTextEventNS(in DOMString namespaceURI, in DOMString type, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in DOMString dataArg); }; // Introduced in DOM Level 2: interface MouseEvent : UIEvent { readonly attribute long screenX; readonly attribute long screenY; readonly attribute long clientX; readonly attribute long clientY; readonly attribute boolean ctrlKey; readonly attribute boolean shiftKey; readonly attribute boolean altKey; readonly attribute boolean metaKey; readonly attribute unsigned short button; readonly attribute EventTarget relatedTarget; void initMouseEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg, in long screenXArg, in long screenYArg, in long clientXArg, in long clientYArg, in boolean ctrlKeyArg, in boolean altKeyArg, in boolean shiftKeyArg, in boolean metaKeyArg, in unsigned short buttonArg, in EventTarget relatedTargetArg); // Introduced in DOM Level 3: void initMouseEventNS(in DOMString namespaceURI, in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg, in long screenXArg, in long screenYArg, in long clientXArg, in long clientYArg, in boolean ctrlKeyArg, in boolean altKeyArg, in boolean shiftKeyArg, in boolean metaKeyArg, in unsigned short buttonArg, in EventTarget relatedTargetArg, in boolean altGraphKeyArg); // Introduced in DOM Level 3: readonly attribute boolean altGraphKey; }; // Introduced in DOM Level 3: interface KeyboardEvent : UIEvent { // KeyLocationCode const unsigned long DOM_KEY_LOCATION_STANDARD = 0x00; const unsigned long DOM_KEY_LOCATION_LEFT = 0x01; const unsigned long DOM_KEY_LOCATION_RIGHT = 0x02; const unsigned long DOM_KEY_LOCATION_NUMPAD = 0x03; const unsigned long DOM_KEY_LOCATION_UNKNOWN = 0x04; readonly attribute DOMString keyIdentifier; readonly attribute unsigned long keyLocation; readonly attribute boolean ctrlKey; readonly attribute boolean shiftKey; readonly attribute boolean altKey; readonly attribute boolean metaKey; readonly attribute boolean altGraphKey; void initKeyboardEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in DOMString keyIdentifierArg, in unsigned long keyLocationArg, in boolean ctrlKeyArg, in boolean shiftKeyArg, in boolean altKeyArg, in boolean metaKeyArg, in boolean altGraphKeyArg); void initKeyboardEventNS(in DOMString namespaceURI, in DOMString type, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in DOMString keyIdentifierArg, in unsigned long keyLocationArg, in boolean ctrlKeyArg, in boolean shiftKeyArg, in boolean altKeyArg, in boolean metaKeyArg, in boolean altGraphKeyArg); }; // Introduced in DOM Level 2: interface MutationEvent : Event { // attrChangeType const unsigned short MODIFICATION = 1; const unsigned short ADDITION = 2; const unsigned short REMOVAL = 3; readonly attribute Node relatedNode; readonly attribute DOMString prevValue; readonly attribute DOMString newValue; readonly attribute DOMString attrName; readonly attribute unsigned short attrChange; void initMutationEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevValueArg, in DOMString newValueArg, in DOMString attrNameArg, in unsigned short attrChangeArg); // Introduced in DOM Level 3: void initMutationEventNS(in DOMString namespaceURI, in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevValueArg, in DOMString newValueArg, in DOMString attrNameArg, in unsigned short attrChangeArg); }; // Introduced in DOM Level 3: interface MutationNameEvent : MutationEvent { readonly attribute DOMString prevNamespaceURI; readonly attribute DOMString prevNodeName; // Introduced in DOM Level 3: void initMutationNameEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevNamespaceURI, in DOMString prevNodeName); // Introduced in DOM Level 3: void initMutationNameEventNS(in DOMString namespaceURI, in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevNamespaceURI, in DOMString prevNodeName); }; }; #endif // _EVENTS_IDL_ 31 March 2003 Appendix D: Java Language Binding This appendix contains the complete Java [Java] bindings for the Level 3 Document Object Model Events. The Java files are also available as http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/java-binding.zip org/w3c/dom/events/EventException.java: package org.w3c.dom.events; public class EventException extends RuntimeException { public EventException(short code, String message) { super(message); this.code = code; } public short code; // EventExceptionCode public static final short UNSPECIFIED_EVENT_TYPE_ERR = 0; public static final short DISPATCH_REQUEST_ERR = 1; } org/w3c/dom/events/Event.java: package org.w3c.dom.events; public interface Event { // PhaseType public static final short CAPTURING_PHASE = 1; public static final short AT_TARGET = 2; public static final short BUBBLING_PHASE = 3; public String getType(); public EventTarget getTarget(); public EventTarget getCurrentTarget(); public short getEventPhase(); public boolean getBubbles(); public boolean getCancelable(); public long getTimeStamp(); public void stopPropagation(); public void preventDefault(); public void initEvent(String eventTypeArg, boolean canBubbleArg, boolean cancelableArg); public String getNamespaceURI(); public boolean isCustom(); public void stopImmediatePropagation(); public boolean isDefaultPrevented(); public void initEventNS(String namespaceURIArg, String eventTypeArg, boolean canBubbleArg, boolean cancelableArg); } org/w3c/dom/events/EventTarget.java: package org.w3c.dom.events; public interface EventTarget { public void addEventListener(String type, EventListener listener, boolean useCapture); public void removeEventListener(String type, EventListener listener, boolean useCapture); public boolean dispatchEvent(Event evt) throws EventException; public void addEventListenerNS(String namespaceURI, String type, EventListener listener, boolean useCapture, Object evtGroup); public void removeEventListenerNS(String namespaceURI, String type, EventListener listener, boolean useCapture); public boolean willTriggerNS(String namespaceURI, String type); public boolean hasEventListenerNS(String namespaceURI, String type); } org/w3c/dom/events/EventListener.java: package org.w3c.dom.events; public interface EventListener { public void handleEvent(Event evt); } org/w3c/dom/events/DocumentEvent.java: package org.w3c.dom.events; import org.w3c.dom.DOMException; public interface DocumentEvent { public Event createEvent(String eventType) throws DOMException; public boolean canDispatch(String namespaceURI, String type); } org/w3c/dom/events/CustomEvent.java: package org.w3c.dom.events; public interface CustomEvent extends Event { public void setDispatchState(EventTarget target, short phase); public boolean isPropagationStopped(); public boolean isImmediatePropagationStopped(); } org/w3c/dom/events/UIEvent.java: package org.w3c.dom.events; import org.w3c.dom.views.AbstractView; public interface UIEvent extends Event { public AbstractView getView(); public int getDetail(); public void initUIEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, int detailArg); public void initUIEventNS(String namespaceURI, String typeArg, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, int detailArg); } org/w3c/dom/events/TextEvent.java: package org.w3c.dom.events; import org.w3c.dom.views.AbstractView; public interface TextEvent extends UIEvent { public String getData(); public void initTextEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, String dataArg); public void initTextEventNS(String namespaceURI, String type, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, String dataArg); } org/w3c/dom/events/MouseEvent.java: package org.w3c.dom.events; import org.w3c.dom.views.AbstractView; public interface MouseEvent extends UIEvent { public int getScreenX(); public int getScreenY(); public int getClientX(); public int getClientY(); public boolean getCtrlKey(); public boolean getShiftKey(); public boolean getAltKey(); public boolean getMetaKey(); public short getButton(); public EventTarget getRelatedTarget(); public void initMouseEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, int detailArg, int screenXArg, int screenYArg, int clientXArg, int clientYArg, boolean ctrlKeyArg, boolean altKeyArg, boolean shiftKeyArg, boolean metaKeyArg, short buttonArg, EventTarget relatedTargetArg); public void initMouseEventNS(String namespaceURI, String typeArg, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, int detailArg, int screenXArg, int screenYArg, int clientXArg, int clientYArg, boolean ctrlKeyArg, boolean altKeyArg, boolean shiftKeyArg, boolean metaKeyArg, short buttonArg, EventTarget relatedTargetArg, boolean altGraphKeyArg); public boolean getAltGraphKey(); } org/w3c/dom/events/KeyboardEvent.java: package org.w3c.dom.events; import org.w3c.dom.views.AbstractView; public interface KeyboardEvent extends UIEvent { // KeyLocationCode public static final int DOM_KEY_LOCATION_STANDARD = 0x00; public static final int DOM_KEY_LOCATION_LEFT = 0x01; public static final int DOM_KEY_LOCATION_RIGHT = 0x02; public static final int DOM_KEY_LOCATION_NUMPAD = 0x03; public static final int DOM_KEY_LOCATION_UNKNOWN = 0x04; public String getKeyIdentifier(); public int getKeyLocation(); public boolean getCtrlKey(); public boolean getShiftKey(); public boolean getAltKey(); public boolean getMetaKey(); public boolean getAltGraphKey(); public void initKeyboardEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, String keyIdentifierArg, int keyLocationArg, boolean ctrlKeyArg, boolean shiftKeyArg, boolean altKeyArg, boolean metaKeyArg, boolean altGraphKeyArg); public void initKeyboardEventNS(String namespaceURI, String type, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, String keyIdentifierArg, int keyLocationArg, boolean ctrlKeyArg, boolean shiftKeyArg, boolean altKeyArg, boolean metaKeyArg, boolean altGraphKeyArg); } org/w3c/dom/events/MutationEvent.java: package org.w3c.dom.events; import org.w3c.dom.Node; public interface MutationEvent extends Event { // attrChangeType public static final short MODIFICATION = 1; public static final short ADDITION = 2; public static final short REMOVAL = 3; public Node getRelatedNode(); public String getPrevValue(); public String getNewValue(); public String getAttrName(); public short getAttrChange(); public void initMutationEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg, Node relatedNodeArg, String prevValueArg, String newValueArg, String attrNameArg, short attrChangeArg); public void initMutationEventNS(String namespaceURI, String typeArg, boolean canBubbleArg, boolean cancelableArg, Node relatedNodeArg, String prevValueArg, String newValueArg, String attrNameArg, short attrChangeArg); } org/w3c/dom/events/MutationNameEvent.java: package org.w3c.dom.events; import org.w3c.dom.Node; public interface MutationNameEvent extends MutationEvent { public String getPrevNamespaceURI(); public String getPrevNodeName(); public void initMutationNameEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg, Node relatedNodeArg, String prevNamespaceURI, String prevNodeName); public void initMutationNameEventNS(String namespaceURI, String typeArg, boolean canBubbleArg, boolean cancelableArg, Node relatedNodeArg, String prevNamespaceURI, String prevNodeName); } 31 March 2003 Appendix E: ECMAScript Language Binding This appendix contains the complete ECMAScript [ECMAScript] binding for the Level 3 Document Object Model Events definitions. Properties of the Event Constructor function: Event.CAPTURING_PHASE The value of the constant Event.CAPTURING_PHASE is 1. Event.AT_TARGET The value of the constant Event.AT_TARGET is 2. Event.BUBBLING_PHASE The value of the constant Event.BUBBLING_PHASE is 3. Objects that implement the Event interface: Properties of objects that implement the Event interface: type This read-only property is a String. target This read-only property is an object that implements the EventTarget interface. currentTarget This read-only property is an object that implements the EventTarget interface. eventPhase This read-only property is a Number. bubbles This read-only property is a Boolean. cancelable This read-only property is a Boolean. timeStamp This read-only property is an object that implements the Date interface. namespaceURI This read-only property is a String. Functions of objects that implement the Event interface: stopPropagation() This function has no return value. preventDefault() This function has no return value. initEvent(eventTypeArg, canBubbleArg, cancelableArg) This function has no return value. The eventTypeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. isCustom() This function returns a Boolean. stopImmediatePropagation() This function has no return value. isDefaultPrevented() This function returns a Boolean. initEventNS(namespaceURIArg, eventTypeArg, canBubbleArg, cancelableArg) This function has no return value. The namespaceURIArg parameter is a String. The eventTypeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. Objects that implement the EventTarget interface: Functions of objects that implement the EventTarget interface: addEventListener(type, listener, useCapture) This function has no return value. The type parameter is a String. The listener parameter is an object that implements the EventListener interface. The useCapture parameter is a Boolean. removeEventListener(type, listener, useCapture) This function has no return value. The type parameter is a String. The listener parameter is an object that implements the EventListener interface. The useCapture parameter is a Boolean. dispatchEvent(evt) This function returns a Boolean. The evt parameter is an object that implements the Event interface. This function can raise an object that implements the EventException interface. addEventListenerNS(namespaceURI, type, listener, useCapture, evtGroup) This function has no return value. The namespaceURI parameter is a String. The type parameter is a String. The listener parameter is an object that implements the EventListener interface. The useCapture parameter is a Boolean. The evtGroup parameter is an object that implements the Object interface. removeEventListenerNS(namespaceURI, type, listener, useCapture) This function has no return value. The namespaceURI parameter is a String. The type parameter is a String. The listener parameter is an object that implements the EventListener interface. The useCapture parameter is a Boolean. willTriggerNS(namespaceURI, type) This function returns a Boolean. The namespaceURI parameter is a String. The type parameter is a String. hasEventListenerNS(namespaceURI, type) This function returns a Boolean. The namespaceURI parameter is a String. The type parameter is a String. EventListener function: This function has no return value. The parameter is an object that implements the Event interface. Properties of the EventException Constructor function: EventException.UNSPECIFIED_EVENT_TYPE_ERR The value of the constant EventException.UNSPECIFIED_EVENT_TYPE_ERR is 0. EventException.DISPATCH_REQUEST_ERR The value of the constant EventException.DISPATCH_REQUEST_ERR is 1. Objects that implement the EventException interface: Properties of objects that implement the EventException interface: code This property is a Number. Objects that implement the DocumentEvent interface: Functions of objects that implement the DocumentEvent interface: createEvent(eventType) This function returns an object that implements the Event interface. The eventType parameter is a String. This function can raise an object that implements the DOMException interface. canDispatch(namespaceURI, type) This function returns a Boolean. The namespaceURI parameter is a String. The type parameter is a String. Objects that implement the CustomEvent interface: Objects that implement the CustomEvent interface have all properties and functions of the Event interface as well as the properties and functions defined below. Functions of objects that implement the CustomEvent interface: setDispatchState(target, phase) This function has no return value. The target parameter is an object that implements the EventTarget interface. The phase parameter is a Number. isPropagationStopped() This function returns a Boolean. isImmediatePropagationStopped() This function returns a Boolean. Objects that implement the UIEvent interface: Objects that implement the UIEvent interface have all properties and functions of the Event interface as well as the properties and functions defined below. Properties of objects that implement the UIEvent interface: view This read-only property is an object that implements the AbstractView interface. detail This read-only property is a Number. Functions of objects that implement the UIEvent interface: initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg) This function has no return value. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The viewArg parameter is an object that implements the AbstractView interface. The detailArg parameter is a Number. initUIEventNS(namespaceURI, typeArg, canBubbleArg, cancelableArg, viewArg, detailArg) This function has no return value. The namespaceURI parameter is a String. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The viewArg parameter is an object that implements the AbstractView interface. The detailArg parameter is a Number. Objects that implement the TextEvent interface: Objects that implement the TextEvent interface have all properties and functions of the UIEvent interface as well as the properties and functions defined below. Properties of objects that implement the TextEvent interface: data This read-only property is a String. Functions of objects that implement the TextEvent interface: initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, dataArg) This function has no return value. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The viewArg parameter is an object that implements the AbstractView interface. The dataArg parameter is a String. initTextEventNS(namespaceURI, type, canBubbleArg, cancelableArg, viewArg, dataArg) This function has no return value. The namespaceURI parameter is a String. The type parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The viewArg parameter is an object that implements the AbstractView interface. The dataArg parameter is a String. Objects that implement the MouseEvent interface: Objects that implement the MouseEvent interface have all properties and functions of the UIEvent interface as well as the properties and functions defined below. Properties of objects that implement the MouseEvent interface: screenX This read-only property is a Number. screenY This read-only property is a Number. clientX This read-only property is a Number. clientY This read-only property is a Number. ctrlKey This read-only property is a Boolean. shiftKey This read-only property is a Boolean. altKey This read-only property is a Boolean. metaKey This read-only property is a Boolean. button This read-only property is a Number. relatedTarget This read-only property is an object that implements the EventTarget interface. altGraphKey This read-only property is a Boolean. Functions of objects that implement the MouseEvent interface: initMouseEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg, relatedTargetArg) This function has no return value. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The viewArg parameter is an object that implements the AbstractView interface. The detailArg parameter is a Number. The screenXArg parameter is a Number. The screenYArg parameter is a Number. The clientXArg parameter is a Number. The clientYArg parameter is a Number. The ctrlKeyArg parameter is a Boolean. The altKeyArg parameter is a Boolean. The shiftKeyArg parameter is a Boolean. The metaKeyArg parameter is a Boolean. The buttonArg parameter is a Number. The relatedTargetArg parameter is an object that implements the EventTarget interface. initMouseEventNS(namespaceURI, typeArg, canBubbleArg, cancelableArg, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg, relatedTargetArg, altGraphKeyArg) This function has no return value. The namespaceURI parameter is a String. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The viewArg parameter is an object that implements the AbstractView interface. The detailArg parameter is a Number. The screenXArg parameter is a Number. The screenYArg parameter is a Number. The clientXArg parameter is a Number. The clientYArg parameter is a Number. The ctrlKeyArg parameter is a Boolean. The altKeyArg parameter is a Boolean. The shiftKeyArg parameter is a Boolean. The metaKeyArg parameter is a Boolean. The buttonArg parameter is a Number. The relatedTargetArg parameter is an object that implements the EventTarget interface. The altGraphKeyArg parameter is a Boolean. Properties of the KeyboardEvent Constructor function: KeyboardEvent.DOM_KEY_LOCATION_STANDARD The value of the constant KeyboardEvent.DOM_KEY_LOCATION_STANDARD is 0x00. KeyboardEvent.DOM_KEY_LOCATION_LEFT The value of the constant KeyboardEvent.DOM_KEY_LOCATION_LEFT is 0x01. KeyboardEvent.DOM_KEY_LOCATION_RIGHT The value of the constant KeyboardEvent.DOM_KEY_LOCATION_RIGHT is 0x02. KeyboardEvent.DOM_KEY_LOCATION_NUMPAD The value of the constant KeyboardEvent.DOM_KEY_LOCATION_NUMPAD is 0x03. KeyboardEvent.DOM_KEY_LOCATION_UNKNOWN The value of the constant KeyboardEvent.DOM_KEY_LOCATION_UNKNOWN is 0x04. Objects that implement the KeyboardEvent interface: Objects that implement the KeyboardEvent interface have all properties and functions of the UIEvent interface as well as the properties and functions defined below. Properties of objects that implement the KeyboardEvent interface: keyIdentifier This read-only property is a String. keyLocation This read-only property is a Number. ctrlKey This read-only property is a Boolean. shiftKey This read-only property is a Boolean. altKey This read-only property is a Boolean. metaKey This read-only property is a Boolean. altGraphKey This read-only property is a Boolean. Functions of objects that implement the KeyboardEvent interface: initKeyboardEvent(typeArg, canBubbleArg, cancelableArg, viewArg, keyIdentifierArg, keyLocationArg, ctrlKeyArg, shiftKeyArg, altKeyArg, metaKeyArg, altGraphKeyArg) This function has no return value. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The viewArg parameter is an object that implements the AbstractView interface. The keyIdentifierArg parameter is a String. The keyLocationArg parameter is a Number. The ctrlKeyArg parameter is a Boolean. The shiftKeyArg parameter is a Boolean. The altKeyArg parameter is a Boolean. The metaKeyArg parameter is a Boolean. The altGraphKeyArg parameter is a Boolean. initKeyboardEventNS(namespaceURI, type, canBubbleArg, cancelableArg, viewArg, keyIdentifierArg, keyLocationArg, ctrlKeyArg, shiftKeyArg, altKeyArg, metaKeyArg, altGraphKeyArg) This function has no return value. The namespaceURI parameter is a String. The type parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The viewArg parameter is an object that implements the AbstractView interface. The keyIdentifierArg parameter is a String. The keyLocationArg parameter is a Number. The ctrlKeyArg parameter is a Boolean. The shiftKeyArg parameter is a Boolean. The altKeyArg parameter is a Boolean. The metaKeyArg parameter is a Boolean. The altGraphKeyArg parameter is a Boolean. Properties of the MutationEvent Constructor function: MutationEvent.MODIFICATION The value of the constant MutationEvent.MODIFICATION is 1. MutationEvent.ADDITION The value of the constant MutationEvent.ADDITION is 2. MutationEvent.REMOVAL The value of the constant MutationEvent.REMOVAL is 3. Objects that implement the MutationEvent interface: Objects that implement the MutationEvent interface have all properties and functions of the Event interface as well as the properties and functions defined below. Properties of objects that implement the MutationEvent interface: relatedNode This read-only property is an object that implements the Node interface. prevValue This read-only property is a String. newValue This read-only property is a String. attrName This read-only property is a String. attrChange This read-only property is a Number. Functions of objects that implement the MutationEvent interface: initMutationEvent(typeArg, canBubbleArg, cancelableArg, relatedNodeArg, prevValueArg, newValueArg, attrNameArg, attrChangeArg) This function has no return value. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The relatedNodeArg parameter is an object that implements the Node interface. The prevValueArg parameter is a String. The newValueArg parameter is a String. The attrNameArg parameter is a String. The attrChangeArg parameter is a Number. initMutationEventNS(namespaceURI, typeArg, canBubbleArg, cancelableArg, relatedNodeArg, prevValueArg, newValueArg, attrNameArg, attrChangeArg) This function has no return value. The namespaceURI parameter is a String. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The relatedNodeArg parameter is an object that implements the Node interface. The prevValueArg parameter is a String. The newValueArg parameter is a String. The attrNameArg parameter is a String. The attrChangeArg parameter is a Number. Objects that implement the MutationNameEvent interface: Objects that implement the MutationNameEvent interface have all properties and functions of the MutationEvent interface as well as the properties and functions defined below. Properties of objects that implement the MutationNameEvent interface: prevNamespaceURI This read-only property is a String. prevNodeName This read-only property is a String. Functions of objects that implement the MutationNameEvent interface: initMutationNameEvent(typeArg, canBubbleArg, cancelableArg, relatedNodeArg, prevNamespaceURI, prevNodeName) This function has no return value. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The relatedNodeArg parameter is an object that implements the Node interface. The prevNamespaceURI parameter is a String. The prevNodeName parameter is a String. initMutationNameEventNS(namespaceURI, typeArg, canBubbleArg, cancelableArg, relatedNodeArg, prevNamespaceURI, prevNodeName) This function has no return value. The namespaceURI parameter is a String. The typeArg parameter is a String. The canBubbleArg parameter is a Boolean. The cancelableArg parameter is a Boolean. The relatedNodeArg parameter is an object that implements the Node interface. The prevNamespaceURI parameter is a String. The prevNodeName parameter is a String. 31 March 2003 Glossary Editors: Arnaud Le Hors, W3C Robert S. Sutor, IBM Research (for DOM Level 1) Several of the following term definitions have been borrowed or modified from similar definitions in other W3C or standards documents. See the links within the definitions for more information. bubbling phase The process by which an event can be handled by one of the target ancestors after being handled by the target node. capture phase The process by which an event can be handled by one of the target ancestors before being handled by the target node. child A child is an immediate descendant node of a node. document element There is only one document element in a Document. This element node is a child of the Document node. See Well-Formed XML Documents in XML [XML 1.0]. document order There is an ordering, document order, defined on all the nodes in the document corresponding to the order in which the first character of the XML representation of each node occurs in the XML representation of the document after expansion of general entities. Thus, the document element node will be the first node. Element nodes occur before their children. Thus, document order orders element nodes in order of the occurrence of their start-tag in the XML (after expansion of entities). The attribute nodes of an element occur after the element and before its children. The relative order of attribute nodes is implementation-dependent. DOM Level 0 The term "DOM Level 0" refers to a mix (not formally specified) of HTML document functionalities offered by Netscape Navigator version 3.0 and Microsoft Internet Explorer version 3.0. In some cases, attributes or methods have been included for reasons of backward compatibility with "DOM Level 0". event An event is the representation of some asynchronous occurrence (such as a mouse click on the presentation of the element, or the removal of child node from an element, or any of unthinkably many other possibilities) that gets associated with an event target. event target The object to which an event is targeted. local name A local name is the local part of a qualified name. This is called the local part in Namespaces in XML [XML Namespaces]. namespace URI A namespace URI is a URI that identifies an XML namespace. This is called the namespace name in Namespaces in XML [XML Namespaces]. string comparison When string matching is required, it is to occur as though the comparison was between 2 sequences of code points from [Unicode 2.0]. target node The target node is the node representing the event target to which an event is targeted using the DOM event flow. target phase The process by which an event can be handled by the event target. tokenized The description given to various information items (for example, attribute values of various types, but not including the StringType CDATA) after having been processed by the XML processor. The process includes stripping leading and trailing white space, and replacing multiple space characters by one. See the definition of tokenized type. well-formed A node is a well-formed XML node if it matches its respective production in [XML 1.0], meets all well-formedness constraints related to the production, if the entities which are referenced within the node are also well-formed. See also the definition for well-formed XML documents in [XML 1.0]. XML name See XML name in the XML specification ([XML 1.0]). 31 March 2003 References For the latest version of any W3C specification please consult the list of W3C Technical Reports available at http://www.w3.org/TR. G.1: Normative references [DOM Level 2 Core] Document Object Model Level 2 Core Specification, A. Le Hors, et al., Editors. World Wide Web Consortium, 13 November 2000. This version of the DOM Level 2 Core Recommendation is http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113. The latest version of DOM Level 2 Core is available at http://www.w3.org/TR/DOM-Level-2-Core. [DOM Level 3 Core] Document Object Model Level 3 Core Specification, A. Le Hors, et al., Editors. World Wide Web Consortium, October 2002. This version of the Document Object Model Level 3 Core Specification is http://www.w3.org/TR/2002/WD-DOM-Level-3-Core-20021022. The latest version of DOM Level 3 Core is available at http://www.w3.org/TR/DOM-Level-3-Core. [DOM Level 2 Events] Document Object Model Level 2 Events Specification, T. Pixley, Editor. World Wide Web Consortium, 13 November 2000. This version of the Document Object Model Level 2 Events Recommendation is http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113. The latest version of Document Object Model Level 2 Events is available at http://www.w3.org/TR/DOM-Level-2-Events. [DOM Level 2 HTML] Document Object Model Level 2 HTML Specification, J. Stenback, et al., Editors. World Wide Web Consortium, 9 January 2003. This version of the Document Object Model Level 2 HTML Recommendation is http://www.w3.org/TR/2003/REC-DOM-Level-2-HTML-20030109. The latest version of Document Object Model Level 2 HTML is available at http://www.w3.org/TR/DOM-Level-2-HTML. [DOM Level 2 Views] Document Object Model Level 2 Views Specification, A. Le Hors, L. Cable, Editors. World Wide Web Consortium, 13 November 2000. This version of the Document Object Model Level 2 Views Recommendation is http://www.w3.org/TR/2000/REC-DOM-Level-2-Views-20001113. The latest version of Document Object Model Level 2 Views is available at http://www.w3.org/TR/DOM-Level-2-Views. [ECMAScript] ECMAScript Language Specification, Third Edition. European Computer Manufacturers Association, Standard ECMA-262, December 1999. [HTML 4.01] HTML 4.01 Specification, D. Raggett, A. Le Hors, and I. Jacobs, Editors. World Wide Web Consortium, 17 December 1997, revised 24 April 1998, revised 24 December 1999. This version of the HTML 4.01 Recommendation is http://www.w3.org/TR/1999/REC-html401-19991224. The latest version of HTML 4 is available at http://www.w3.org/TR/html4. [Java] The Java Language Specification, J. Gosling, B. Joy, and G. Steele, Authors. Addison-Wesley, September 1996. Available at http://java.sun.com/docs/books/jls [OMG IDL] "OMG IDL Syntax and Semantics" defined in The Common Object Request Broker: Architecture and Specification, version 2, Object Management Group. The latest version of CORBA version 2.0 is available at http://www.omg.org/technology/documents/formal/corba_2.htm. [Unicode 3.0] The Unicode Standard, Version 3.0.. The Unicode Consortium, 2000. Reading, Mass.: Addison-Wesley Developers Press. ISBN 0-201-61633-5. [XML 1.0] Extensible Markup Language (XML) 1.0 (Second Edition), T. Bray, J. Paoli, C. M. Sperberg-McQueen, and E. Maler, Editors. World Wide Web Consortium, 10 February 1998, revised 6 October 2000. This version of the XML 1.0 Recommendation is http://www.w3.org/TR/2000/REC-xml-20001006. The latest version of XML 1.0 is available at http://www.w3.org/TR/REC-xml. [XML Namespaces] Namespaces in XML, T. Bray, D. Hollander, and A. Layman, Editors. World Wide Web Consortium, 14 January 1999. This version of the XML Information Set Recommendation is http://www.w3.org/TR/1999/REC-xml-names-19990114. The latest version of Namespaces in XML is available at http://www.w3.org/TR/REC-xml-names. G.2: Informative references [DOM Level 3 Load and Save] Document Object Model Level 3 Load and Save Specification, J. Stenback, A. Heninger, Editors. World Wide Web Consortium, July 2002. This version of the DOM Level 3 Load and Save Specification is http://www.w3.org/TR/DOM-Level-3-LS. The latest version of DOM Level 3 Load and Save is available at http://www.w3.org/TR/DOM-Level-3-LS. [DWW95] Developing International Software for Windows 95 and Windows NT: A Handbook for International Software Design, N. Kano, Author. Microsoft Press, 1995. ISBN 1-55615-840-8. [KeyEvent for Java] Java 2 SDK, Standard Edition Documentation, Version 1.4.1, Class java.awt.events.KeyEvent. Sun Microsystems. Available at http://java.sun.com/j2se/1.4.1/docs/api/java/awt/event/KeyEvent.html. [Keys enumeration for .Net] .NET Framework Class Library, Keys Enumeration. Microsoft. Available at http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemWindowsFormsKeysClassTopic.asp. [SVG 1.0] Scalable Vector Graphics (SVG) 1.0 Specification, J. Ferraiolo, Editor. World Wide Web Consortium, 4 September 2001. This version of the SVG 1.0 Recommendation is http://www.w3.org/TR/2001/REC-SVG-20010904. The latest version of SVG 1.0 is available at http://www.w3.org/TR/SVG. [Unicode 2.0] The Unicode Standard, Version 2.0.. The Unicode Consortium, 1996. Reading, Mass.: Addison-Wesley Developers Press. ISBN 0-201-48345-9. [VoiceXML 2.0] Voice Extensible Markup Language (VoiceXML) Version 2.0, S. McGlashan, et al., Editors. World Wide Web Consortium, February 2003. This version of the Voice Extensible Markup Language Version 2.0 specification is http://www.w3.org/TR/2003/CR-voicexml20-20030220. The latest version of Voice Extensible Markup Language Version 2.0 is available at http://www.w3.org/TR/voicexml20/. [XForms 1.0] XForms 1.0, M. Dubinko, et al., Editors. World Wide Web Consortium, November 2002. This version of the XForms 1.0 specification is http://www.w3.org/TR/2002/CR-xforms-20021112/. The latest version of XForms 1.0 is available at http://www.w3.org/TR/xforms/. [XHTML 1.0] XHTML 1.0: The Extensible HyperText Markup Language, S. Pemberton, et al., Authors. World Wide Web Consortium, 26 January 2000, revised 1 August 2002. This version of the XHTML 1.0 Recommendation is http://www.w3.org/TR/2002/REC-xhtml1-20020801. The latest version of XHTML 1.0 is available at http://www.w3.org/TR/xhtml1. [XML Events] XML Events, S. McCarron, S. Pemberton, and T.V. Raman, Editors. World Wide Web Consortium, February 2003. This version of the XML Events specification is http://www.w3.org/TR/2003/CR-xml-events-20030207. The latest version of XML Events is available at http://www.w3.org/TR/xml-events. [XML Schema Part 2] XML Schema Part 2: Datatypes, P. Byron and Ashok Malhotra, Editors. World Wide Web Consortium, 2 May 2001. This version of the XML Part 2 Recommendation is http://www.w3.org/TR/2001/REC-xmlschema-2-20010502. The latest version of XML Schema Part 2 is available at http://www.w3.org/TR/xmlschema-2. 31 March 2003 Index addEventListener addEventListenerNS ADDITION altGraphKey 1, 2 altKey 1, 2 AT_TARGET attrChange attrName bubbles bubbling phase 1, 2, 3, BUBBLING_PHASE 4, 5, 6, 7, 8, 9, 10 button cancelable cancelable event 1, 2 canDispatch capture phase 1, 2, 3, 4, 5, 6, 7 CAPTURING_PHASE child 1, 2 clientX clientY createEvent ctrlKey 1, 2 currentTarget CustomEvent data detail DISPATCH_REQUEST_ERR dispatchEvent document element document order DocumentEvent DOM event flow DOM Level 0 1, 2, 3 DOM Level 2 Core 1, 2 DOM Level 2 Events 1, 2, DOM Level 2 HTML 1, 2, 3 3, 4, 5, 6, 7 DOM Level 2 Views 1, 2 DOM Level 3 Core 1, 2, DOM Level 3 Load and Save 1, 3, 4, 5, 6, 7, 8, 9, 10 2 DOM_KEY_LOCATION_LEFT DOM_KEY_LOCATION_NUMPAD DOM_KEY_LOCATION_RIGHT DOM_KEY_LOCATION_STANDARD DOM_KEY_LOCATION_UNKNOWN DWW95 ECMAScript Event 1, 2, 3, 4, 5 event target 1, 2, 3, 4, 5, 6, 7, 8 EventException EventListener eventPhase EventTarget handleEvent hasEventListenerNS HTML 4.01 1, 2, 3, 4, 5, 6, 7 initEvent initEventNS initKeyboardEvent initKeyboardEventNS initMouseEvent initMouseEventNS initMutationEvent initMutationEventNS initMutationNameEvent initMutationNameEventNS initTextEvent initTextEventNS initUIEvent initUIEventNS Input Method Editor 1 isCustom isDefaultPrevented isImmediatePropagationStopped isPropagationStopped Java KeyboardEvent KeyEvent for Java keyIdentifier keyLocation Keys enumeration for .Net local name 1, 2, 3, 4, 5 metaKey 1, 2 MODIFICATION MouseEvent MutationEvent MutationNameEvent namespace URI 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 namespaceURI newValue OMG IDL preventDefault prevNamespaceURI prevNodeName prevValue relatedNode relatedTarget REMOVAL removeEventListener removeEventListenerNS screenX screenY setDispatchState shiftKey 1, 2 stopImmediatePropagation stopPropagation string comparison 1, 2 SVG 1.0 1, 2, 3 target target node 1, 2, 3, 4, target phase 1, 2, 3, 4, 5, 5, 6 6, 7, 8 TextEvent timeStamp tokenized type UIEvent Unicode 2.0 1, 2 Unicode 3.0 UNSPECIFIED_EVENT_TYPE_ERR view VoiceXML 2.0 1, 2 well-formed willTriggerNS XForms 1.0 1, 2 XHTML 1.0 1, 2, 3, 4 XML 1.0 1, 2, 3, 4, 5 XML Events 1, 2, 3 XML name 1, 2 XML Namespaces 1, 2, 3, 4, 5, 6 XML Schema Part 2 1, 2