HTML5

The hidden IDL attribute must reflect the content attribute of the same name.

The click() method must run synthetic click activation steps on the element.

When an element is focused, key events received by the document must be targeted at that element. There may be no element focused; when no element is focused, key events received by the document must be targeted at the body element, if there is one, or else at the Document's root element, if there is one. If there is no root element, key events must not be fired.

User agents may track focus for each browsing context or Document individually, or may support only one focused element per top-level browsing context — user agents should follow platform conventions in this regard.

Which elements within a top-level browsing context currently have focus must be independent of whether or not the top-level browsing context itself has the system focus.

When a child browsing context is focused, its browsing context container must also have focus.

When an element is focused, the element matches the CSS :focus pseudo-class.

Each element can have a tabindex focus flag set, as defined below. This flag is a factor that contributes towards determining whether an element is focusable, as described in the next section.

If the attribute is specified, it must be parsed using the rules for parsing integers. The attribute's values have the following meanings:

If the attribute is omitted or parsing the value returns an error

The user agent should follow platform conventions to determine if the element's tabindex focus flag is set and, if so, whether the element can be reached using sequential focus navigation, and if so, what its relative order should be.

Modulo platform conventions, it is suggested that for the following elements, the tabindex focus flag be set:

• a elements that have an href attribute
• link elements that have an href attribute
• button elements
• input elements whose type attribute are not in the Hidden state
• select elements
• textarea elements
• Elements with a draggable attribute set, if that would enable the user agent to allow the user to begin a drag operations for those elements without the use of a pointing device
• Editing hosts
• Browsing context containers

One valid reason to ignore the platform conventions and always allow an element to be focused (by setting its tabindex focus flag) would be if the user's only mechanism for activating an element is through a keyboard action that triggers the focused element.

If the value is a negative integer

The user agent must set the element's tabindex focus flag, but should not allow the element to be reached using sequential focus navigation.

One valid reason to ignore the requirement that sequential focus navigation not allow the author to lead to the element would be if the user's only mechanism for moving the focus is sequential focus navigation. For instance, a keyboard-only user would be unable to click on a text field with a negative tabindex, so that user's user agent would be well justified in allowing the user to tab to the control regardless.

If the value is a zero

The user agent must set the element's tabindex focus flag, should allow the element to be reached using sequential focus navigation, and should follow platform conventions to determine the element's relative order.

If the value is greater than zero

The user agent must set the element's tabindex focus flag, should allow the element to be reached using sequential focus navigation, and should place the element in the sequential focus navigation order so that it is:

• before any focusable element whose tabindex attribute has been omitted or whose value, when parsed, returns an error,
• before any focusable element whose tabindex attribute has a value equal to or less than zero,
• after any element whose tabindex attribute has a value greater than zero but less than the value of the tabindex attribute on the element,
• after any element whose tabindex attribute has a value equal to the value of the tabindex attribute on the element but that is earlier in the document in tree order than the element,
• before any element whose tabindex attribute has a value equal to the value of the tabindex attribute on the element but that is later in the document in tree order than the element, and
• before any element whose tabindex attribute has a value greater than the value of the tabindex attribute on the element.

An element that has its tabindex focus flag set but does not otherwise have an activation behavior defined has an activation behavior that does nothing.

This means that an element that is only focusable because of its tabindex attribute will fire a click event in response to a non-mouse activation (e.g. hitting the "enter" key while the element is focused).

The tabIndex IDL attribute must reflect the value of the tabindex content attribute. Its default value is 0 for elements that are focusable and −1 for elements that are not focusable.

7.4.2 Focus management

An element is focusable if all of the following conditions are met:

• The element's tabindex focus flag is set.
• The element is either being rendered or is a descendant of a canvas element that represents embedded content.
• The element is not inert.
• The element is not disabled.

In addition, each shape that is generated for an area element, any user-agent-provided interface components of media elements (e.g. a play button), and distinct user interface components of form controls (e.g. "up" and "down" buttons on an <input type=number> spin control), should be focusable, unless platform conventions dictate otherwise or unless their corresponding element is disabled. (A single area element can correspond to multiple shapes, since image maps can be reused with multiple images on a page.)

Notwithstanding the above, user agents may make any element or part of an element focusable, especially to aid with accessibility or to better match platform conventions.

The focusing steps for an element are as follows:

1. If the element is not in a Document, or if the element's Document has no browsing context, or if the element's Document's browsing context has no top-level browsing context, or if the element is not focusable, or if the element is already focused, then abort these steps.

2. If focusing the element will remove the focus from another element, then run the unfocusing steps for that element.

3. Make the element the currently focused element in its top-level browsing context.

   Some elements, most notably area, can correspond to more than one distinct focusable area. If a particular area was indicated when the element was focused, then that is the area that must get focus; otherwise, e.g. when using the focus() method, the first such region in tree order is the one that must be focused.

4. The user agent may apply relevant platform-specific conventions for focusing widgets.

   For example, some platforms select the contents of a text field when that field is focused.

5. Fire a simple event named focus at the element.

User agents must synchronously run the focusing steps for an element whenever the user moves the focus to a focusable element.

The unfocusing steps for an element are as follows:

1. If the element is an input element, and the change event applies to the element, and the element does not have a defined activation behavior, and the user has changed the element's value or its list of selected files while the control was focused without committing that change, then fire a simple event that bubbles named change at the element.

2. Unfocus the element.

3. Fire a simple event named blur at the element.

When an element that is focused stops being a focusable element, or stops being focused without another element being explicitly focused in its stead, the user agent should synchronously run the unfocusing steps for the affected element only.

For example, this might happen because the element is removed from its Document, or has a hidden attribute added. It would also happen to an input element when the element gets disabled.

The activeElement attribute on Document objects must return the element in the document that is focused. If no element in the Document is focused, this must return the body element.

When a child browsing context is focused, its browsing context container is also focused, by definition. For example, if the user moves the focus to a text field in an iframe, the iframe is the element with focus in the parent browsing context.

The hasFocus() method on Document objects must return true if the Document's browsing context is focused, and all its ancestor browsing contexts are also focused, and the top-level browsing context has the system focus. If the Document has no browsing context or if its browsing context has no top-level browsing context, then the method will always return false.

The focus() method on the Window object, when invoked, provides a hint to the user agent that the script believes the user might be interested in the contents of the browsing context of the Window object on which the method was invoked.

User agents are encouraged to have this focus() method trigger some kind of notification.

The blur() method on the Window object, when invoked, provides a hint to the user agent that the script believes the user probably is not currently interested in the contents of the browsing context of the Window object on which the method was invoked, but that the contents might become interesting again in the future.

User agents are encouraged to ignore calls to this blur() method entirely.

Historically the focus() and blur() methods actually affected the system focus, but hostile sites widely abuse this behavior to the user's detriment.

The focus() method, when invoked, must run the following algorithm:

1. If the element is marked as locked for focus, then abort these steps.

2. Mark the element as locked for focus.

3. Run the focusing steps for the element.

4. Unmark the element as locked for focus.

The blur() method, when invoked, should run the unfocusing steps for the element on which the method was called instead. User agents may selectively or uniformly ignore calls to this method for usability reasons.

For example, if the blur() method is unwisely being used to remove the focus ring for aesthetics reasons, the page would become unusable by keyboard users. Ignoring calls to this method would thus allow keyboard users to interact with the page.

7.5.3 Processing model

An element's assigned access key is a key combination derived from the element's accesskey content attribute. Initially, an element must not have an assigned access key.

Whenever an element's accesskey attribute is set, changed, or removed, the user agent must update the element's assigned access key by running the following steps:

1. If the element has no accesskey attribute, then skip to the fallback step below.

2. Otherwise, split the attribute's value on spaces, and let keys be the resulting tokens.

3. For each value in keys in turn, in the order the tokens appeared in the attribute's value, run the following substeps:

   1. If the value is not a string exactly one Unicode code point in length, then skip the remainder of these steps for this value.

   2. If the value does not correspond to a key on the system's keyboard, then skip the remainder of these steps for this value.

   3. If the user agent can find a mix of zero or more modifier keys that, combined with the key that corresponds to the value given in the attribute, can be used as the access key, then the user agent may assign that combination of keys as the element's assigned access key and abort these steps.

4. Fallback: Optionally, the user agent may assign a key combination of its choosing as the element's assigned access key and then abort these steps.

5. If this step is reached, the element has no assigned access key.

Once a user agent has selected and assigned an access key for an element, the user agent should not change the element's assigned access key unless the accesskey content attribute is changed or the element is moved to another Document.

User agents might expose elements that have an accesskey attribute in other ways as well, e.g. in a menu displayed in response to a specific key combination.

The accessKey IDL attribute must reflect the accesskey content attribute.

The accessKeyLabel IDL attribute must return a string that represents the element's assigned access key, if any. If the element does not have one, then the IDL attribute must return the empty string.

The contentEditable IDL attribute, on getting, must return the string "true" if the content attribute is set to the true state, "false" if the content attribute is set to the false state, and "inherit" otherwise. On setting, if the new value is an ASCII case-insensitive match for the string "inherit" then the content attribute must be removed, if the new value is an ASCII case-insensitive match for the string "true" then the content attribute must be set to the string "true", if the new value is an ASCII case-insensitive match for the string "false" then the content attribute must be set to the string "false", and otherwise the attribute setter must throw a SyntaxError exception.

The isContentEditable IDL attribute, on getting, must return true if the element is either an editing host or editable, and false otherwise.

Documents have a designMode, which can be either enabled or disabled.

The designMode IDL attribute on the Document object takes two values, "on" and "off". On setting, the new value must be compared in an ASCII case-insensitive manner to these two values; if it matches the "on" value, then designMode must be enabled, and if it matches the "off" value, then designMode must be disabled. Other values must be ignored.

On getting, if designMode is enabled, the IDL attribute must return the value "on"; otherwise it is disabled, and the attribute must return the value "off".

The last state set must persist until the document is destroyed or the state is changed. Initially, documents must have their designMode disabled.

When the designMode changes from being disabled to being enabled, the user agent must synchronously reset the document's active range's start and end boundary points to be at the start of the Document and then run the focusing steps for the root element of the Document, if any.

User agents can support the checking of spelling and grammar of editable text, either in form controls (such as the value of textarea elements), or in elements in an editing host (e.g. using contenteditable).

For each element, user agents must establish a default behavior, either through defaults or through preferences expressed by the user. There are three possible default behaviors for each element:

true-by-default

The element will be checked for spelling and grammar if its contents are editable.

false-by-default

The element will never be checked for spelling and grammar.

inherit-by-default

The element's default behavior is the same as its parent element's. Elements that have no parent element cannot have this as their default behavior.

The spellcheck IDL attribute, on getting, must return true if the element's spellcheck content attribute is in the true state, or if the element's spellcheck content attribute is in the default state and the element's default behavior is true-by-default, or if the element's spellcheck content attribute is in the default state and the element's default behavior is inherit-by-default and the element's parent element's spellcheck IDL attribute would return true; otherwise, if none of those conditions applies, then the attribute must instead return false.

The spellcheck IDL attribute is not affected by user preferences that override the spellcheck content attribute, and therefore might not reflect the actual spellchecking state.

On setting, if the new value is true, then the element's spellcheck content attribute must be set to the literal string "true", otherwise it must be set to the literal string "false".

User agents must only consider the following pieces of text as checkable for the purposes of this feature:

• The value of input elements whose type attributes are in the Text, Search, URL, or E-mail states and that are mutable (i.e. that do not have the readonly attribute specified and that are not disabled).
• The value of textarea elements that do not have a readonly attribute and that are not disabled.
• Text in Text nodes that are children of editing hosts or editable elements.
• Text in attributes of editable elements.

For text that is part of a Text node, the element with which the text is associated is the element that is the immediate parent of the first character of the word, sentence, or other piece of text. For text in attributes, it is the attribute's element. For the values of input and textarea elements, it is the element itself.

To determine if a word, sentence, or other piece of text in an applicable element (as defined above) is to have spelling- and grammar-checking enabled, the UA must use the following algorithm:

1. If the user has disabled the checking for this text, then the checking is disabled.
2. Otherwise, if the user has forced the checking for this text to always be enabled, then the checking is enabled.
3. Otherwise, if the element with which the text is associated has a spellcheck content attribute, then: if that attribute is in the true state, then checking is enabled; otherwise, if that attribute is in the false state, then checking is disabled.
4. Otherwise, if there is an ancestor element with a spellcheck content attribute that is not in the default state, then: if the nearest such ancestor's spellcheck content attribute is in the true state, then checking is enabled; otherwise, checking is disabled.
5. Otherwise, if the element's default behavior is true-by-default, then checking is enabled.
6. Otherwise, if the element's default behavior is false-by-default, then checking is disabled.
7. Otherwise, if the element's parent element has its checking enabled, then checking is enabled.
8. Otherwise, checking is disabled.

If the checking is enabled for a word/sentence/text, the user agent should indicate spelling and grammar errors in that text. User agents should take into account the other semantics given in the document when suggesting spelling and grammar corrections. User agents may use the language of the element to determine what spelling and grammar rules to use, or may use the user's preferred language settings. UAs should use input element attributes such as pattern to ensure that the resulting value is valid, where possible.

If checking is disabled, the user agent should not indicate spelling or grammar errors for that text.

Even when checking is enabled, user agents may opt to not report spelling or grammar errors in text that the user agent deems the user has no interest in having checked (e.g. text that was already present when the page was loaded, or that the user did not type, or text in controls that the user has not focused, or in parts of e-mail addresses that the user agent is not confident were misspelt).

<div contenteditable="true">
 <span spellcheck="false" id="a">Hell</span><em>o!</em>
</div>

<p spellcheck="true">
 <label>Name: <input spellcheck=" false" id="b"></label>
</p>

However it is implemented, drag-and-drop operations must have a starting point (e.g. where the mouse was clicked, or the start of the selection or element that was selected for the drag), may have any number of intermediate steps (elements that the mouse moves over during a drag, or elements that the user picks as possible drop points as he cycles through possibilities), and must either have an end point (the element above which the mouse button was released, or the element that was finally selected), or be canceled. The end point must be the last element selected as a possible drop point before the drop occurs (so if the operation is not canceled, there must be at least one element in the middle step).

A DataTransfer object is associated with a drag data store while it is valid.

The dropEffect attribute controls the drag-and-drop feedback that the user is given during a drag-and-drop operation. When the DataTransfer object is created, the dropEffect attribute is set to a string value. On getting, it must return its current value. On setting, if the new value is one of "none", "copy", "link", or "move", then the attribute's current value must be set to the new value. Other values must be ignored.

The effectAllowed attribute is used in the drag-and-drop processing model to initialize the dropEffect attribute during the dragenter and dragover events. When the DataTransfer object is created, the effectAllowed attribute is set to a string value. On getting, it must return its current value. On setting, if drag data store's mode is the read/write mode and the new value is one of "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", or "uninitialized", then the attribute's current value must be set to the new value. Otherwise it must be left unchanged.

The items attribute must return a DataTransferItemList object associated with the DataTransfer object. The same object must be returned each time.

The setDragImage(element, x, y) method must run the following steps:

1. If the DataTransfer object is no longer associated with a drag data store, abort these steps. Nothing happens.

2. If the drag data store's mode is not the read/write mode, abort these steps. Nothing happens.

3. If the element argument is an img element, then set the drag data store bitmap to the element's image (at its intrinsic size); otherwise, set the drag data store bitmap to an image generated from the given element (the exact mechanism for doing so is not currently specified).

4. Set the drag data store hot spot coordinate to the given x, y coordinate.

The types attribute must return a live read only array giving the strings that the following steps would produce. The same object must be returned each time.

1. Start with an empty list L.

2. If the DataTransfer object is no longer associated with a drag data store, the array is empty. Abort these steps; return the empty list L.

3. For each item in the drag data store item list whose kind is Plain Unicode string, add an entry to the list L consisting of the item's type string.

4. If there are any items in the drag data store item list whose kind is File, then add an entry to the list L consisting of the string "Files". (This value can be distinguished from the other values because it is not lowercase.)

5. The strings produced by these steps are those in the list L.

The getData(format) method must run the following steps:

1. If the DataTransfer object is no longer associated with a drag data store, return the empty string and abort these steps.

2. If the drag data store's mode is the protected mode, return the empty string and abort these steps.

3. Let format be the first argument, converted to ASCII lowercase.

4. Let convert-to-URL be false.

5. If format equals "text", change it to "text/plain".

6. If format equals "url", change it to "text/uri-list" and set convert-to-URL to true.

7. If there is no item in the drag data store item list whose kind is Plain Unicode string and whose type string is equal to format, return the empty string and abort these steps.

8. Let result be the data of the item in the drag data store item list whose kind is Plain Unicode string and whose type string is equal to format.

9. If convert-to-URL is true, then parse result as appropriate for text/uri-list data, and then set result to the first URL from the list, if any, or the empty string otherwise. [RFC2483]

10. Return result.

The setData(format, data) method must run the following steps:

1. If the DataTransfer object is no longer associated with a drag data store, abort these steps. Nothing happens.

2. If the drag data store's mode is not the read/write mode, abort these steps. Nothing happens.

3. Let format be the first argument, converted to ASCII lowercase.

4. If format equals "text", change it to "text/plain".

   If format equals "url", change it to "text/uri-list".

5. Remove the item in the drag data store item list whose kind is Plain Unicode string and whose type string is equal to format, if there is one.

6. Add an item to the drag data store item list whose kind is Plain Unicode string, whose type string is equal to format, and whose data is the string given by the method's second argument.

The clearData() method must run the following steps:

1. If the DataTransfer object is no longer associated with a drag data store, abort these steps. Nothing happens.

2. If the drag data store's mode is not the read/write mode, abort these steps. Nothing happens.

3. If the method was called with no arguments, remove each item in the drag data store item list whose kind is Plain Unicode string, and abort these steps.

4. Let format be the first argument, converted to ASCII lowercase.

5. If format equals "text", change it to "text/plain".

   If format equals "url", change it to "text/uri-list".

6. Remove the item in the drag data store item list whose kind is Plain Unicode string and whose type string is equal to format, if there is one.

The clearData() method does not affect whether any files were included in the drag, so the types attribute's list might still not be empty after calling clearData() (it would still contain the "Files" string if any files were included in the drag).

The files attribute must return a live FileList sequence consisting of File objects representing the files found by the following steps. The same object must be returned each time. Furthermore, for a given FileList object and a given underlying file, the same File object must be used each time.

1. Start with an empty list L.

2. If the DataTransfer object is no longer associated with a drag data store, the FileList is empty. Abort these steps; return the empty list L.

3. If the drag data store's mode is the protected mode, abort these steps; return the empty list L.

4. For each item in the drag data store item list whose kind is File , add the item's data (the file, in particular its name and contents, as well as its type) to the list L.

5. The files found by these steps are those in the list L.

This version of the API does not expose the types of the files during the drag.

While the DataTransferItemList object's DataTransfer object is associated with a drag data store, the DataTransferItemList object's mode is the same as the drag data store mode. When the DataTransferItemList object's DataTransfer object is not associated with a drag data store, the DataTransferItemList object's mode is the disabled mode. The drag data store referenced in this section (which is used only when the DataTransferItemList object is not in the disabled mode) is the drag data store with which the DataTransferItemList object's DataTransfer object is associated.

The length attribute must return zero if the object is in the disabled mode; otherwise it must return the number of items in the drag data store item list.

When a DataTransferItemList object is not in the disabled mode, its supported property indices are the numbers in the range 0 .. n-1, where n is the number of items in the drag data store item list.

To determine the value of an indexed property i of a DataTransferItemList object, the user agent must return a DataTransferItem object representing the ith item in the drag data store. The same object must be returned each time a particular item is obtained from this DataTransferItemList object. The DataTransferItem object must be associated with the same DataTransfer object as the DataTransferItemList object when it is first created.

The add() method must run the following steps:

1. If the DataTransferItemList object is not in the read/write mode, return null and abort these steps.

2. Jump to the appropriate set of steps from the following list:

   If the first argument to the method is a string

   If there is already an item in the drag data store item list whose kind is Plain Unicode string and whose type string is equal to the value of the method's second argument, converted to ASCII lowercase, then throw a NotSupportedError exception and abort these steps.

   Otherwise, add an item to the drag data store item list whose kind is Plain Unicode string, whose type string is equal to the value of the method's second argument, converted to ASCII lowercase, and whose data is the string given by the method's first argument.

   If the first argument to the method is a File

   Add an item to the drag data store item list whose kind is File, whose type string is the type of the File, converted to ASCII lowercase, and whose data is the same as the File's data.

3. Determine the value of the indexed property corresponding to the newly added item, and return that value (a newly created DataTransferItem object).

The remove() method, when invoked with the argument i, must run these steps:

1. If the DataTransferItemList object is not in the read/write mode, throw an InvalidStateError exception and abort these steps.

2. Remove the ith item from the drag data store.

The clear method, if the DataTransferItemList object is in the read/write mode, must remove all the items from the drag data store. Otherwise, it must do nothing.

While the DataTransferItem object's DataTransfer object is associated with a drag data store and that drag data store's drag data store item list still contains the item that the DataTransferItem object represents, the DataTransferItem object's mode is the same as the drag data store mode. When the DataTransferItem object's DataTransfer object is not associated with a drag data store, or if the item that the DataTransferItem object represents has been removed from the relevant drag data store item list, the DataTransferItem object's mode is the disabled mode. The drag data store referenced in this section (which is used only when the DataTransferItem object is not in the disabled mode) is the drag data store with which the DataTransferItem object's DataTransfer object is associated.

The kind attribute must return the empty string if the DataTransferItem object is in the disabled mode; otherwise it must return the string given in the cell from the second column of the following table from the row whose cell in the first column contains the drag data item kind of the item represented by the DataTransferItem object:

The type attribute must return the empty string if the DataTransferItem object is in the disabled mode; otherwise it must return the drag data item type string of the item represented by the DataTransferItem object.

The getAsString(callback) method must run the following steps:

1. If the callback is null, abort these steps.

2. If the DataTransferItem object is not in the read/write mode or the read-only mode, abort these steps. The callback is never invoked.

3. If the drag data item kind is not Plain Unicode string, abort these steps. The callback is never invoked.

4. Otherwise, queue a task to invoke callback, passing the actual data of the item represented by the DataTransferItem object as the argument.

The getAsFile() method must run the following steps:

1. If the DataTransferItem object is not in the read/write mode or the read-only mode, return null and abort these steps.

2. If the drag data item kind is not File, then return null and abort these steps.

3. Return a new File object representing the actual data of the item represented by the DataTransferItem object.

The dataTransfer attribute of the DragEvent interface must return the value it was initialized to. When the object is created, this attribute must be initialized to null. It represents the context information for the event.

When a user agent is required to fire a DND event named e at an element, using a particular drag data store, the user agent must run the following steps:

1. If e is dragstart, set the drag data store mode to the read/write mode.

   If e is drop, set the drag data store mode to the read-only mode.

2. Let dataTransfer be a newly created DataTransfer object associated with the given drag data store.

3. Set the effectAllowed attribute to the drag data store's drag data store allowed effects state.

4. Set the dropEffect attribute to "none" if e is dragstart, drag, dragexit, or dragleave; to the value corresponding to the current drag operation if e is drop or dragend; and to a value based on the effectAllowed attribute's value and the drag-and-drop source, as given by the following table, otherwise (i.e. if e is dragenter or dragover):

   effectAllowed	dropEffect
   "none"	"none"
   "copy"	"copy"
   "copyLink"	"copy", or, if appropriate, "link"
   "copyMove"	"copy", or, if appropriate, "move"
   "all"	"copy", or, if appropriate, either "link" or "move"
   "link"	"link"
   "linkMove"	"link", or, if appropriate, "move"
   "move"	"move"
   "uninitialized" when what is being dragged is a selection from a text field	"move", or, if appropriate, either "copy" or "link"
   "uninitialized" when what is being dragged is a selection	"copy", or, if appropriate, either "link" or "move"
   "uninitialized" when what is being dragged is an a element with an href attribute	"link", or, if appropriate, either "copy" or "move"
   Any other case	"copy", or, if appropriate, either "link" or "move"

   Where the table above provides possibly appropriate alternatives, user agents may instead use the listed alternative values if platform conventions dictate that the user has requested those alternate effects.

   For example, Windows platform conventions are such that dragging while holding the "alt" key indicates a preference for linking the data, rather than moving or copying it. Therefore, on a Windows system, if "link" is an option according to the table above while the "alt" key is depressed, the user agent could select that instead of "copy" or "move".

5. Create a trusted DragEvent object and initialize it to have the given name e, to bubble, to be cancelable unless e is dragexit, dragleave, or dragend, and to have the detail attribute initialized to zero, the mouse and key attributes initialized according to the state of the input devices as they would be for user interaction events, the relatedTarget attribute initialized to null, and the dataTransfer attribute initialized to dataTransfer, the DataTransfer object created above.

   If there is no relevant pointing device, the object must have its screenX, screenY, clientX, clientY, and button attributes set to 0.

6. Dispatch the newly created DragEvent object at the specified target element.

7. Set the drag data store allowed effects state to the current value of dataTransfer's effectAllowed attribute. (It can only have changed value if e is dragstart.)

8. Set the drag data store mode back to the protected mode if it was changed in the first step.

9. Break the association between dataTransfer and the drag data store.

7.7.5 Drag-and-drop processing model

When the user attempts to begin a drag operation, the user agent must run the following steps. User agents must act as if these steps were run even if the drag actually started in another document or application and the user agent was not aware that the drag was occurring until it intersected with a document under the user agent's purview.

1. Determine what is being dragged, as follows:

   If the drag operation was invoked on a selection, then it is the selection that is being dragged.

   Otherwise, if the drag operation was invoked on a Document, it is the first element, going up the ancestor chain, starting at the node that the user tried to drag, that has the IDL attribute draggable set to true. If there is no such element, then nothing is being dragged; abort these steps, the drag-and-drop operation is never started.

   Otherwise, the drag operation was invoked outside the user agent's purview. What is being dragged is defined by the document or application where the drag was started.

   img elements and a elements with an href attribute have their draggable attribute set to true by default.

2. Create a drag data store. All the DND events fired subsequently by the steps in this section must use this drag data store.

3. Establish which DOM node is the source node, as follows:

   If it is a selection that is being dragged, then the source node is the Text node that the user started the drag on (typically the Text node that the user originally clicked). If the user did not specify a particular node, for example if the user just told the user agent to begin a drag of "the selection", then the source node is the first Text node containing a part of the selection.

   Otherwise, if it is an element that is being dragged, then the source node is the element that is being dragged.

   Otherwise, the source node is part of another document or application. When this specification requires that an event be dispatched at the source node in this case, the user agent must instead follow the platform-specific conventions relevant to that situation.

   Multiple events are fired on the source node during the course of the drag-and-drop operation.

4. Determine the list of dragged nodes, as follows:

   If it is a selection that is being dragged, then the list of dragged nodes contains, in tree order, every node that is partially or completely included in the selection (including all their ancestors).

   Otherwise, the list of dragged nodes contains only the source node, if any.

5. If it is a selection that is being dragged, then add an item to the drag data store item list, with its properties set as follows:

   The drag data item type string

   "text/plain"

   The drag data item kind

   Plain Unicode string

   The actual data

   The text of the selection

   Otherwise, if any files are being dragged, then add one item per file to the drag data store item list, with their properties set as follows:

   The drag data item type string

   The MIME type of the file, if known, or "application/octet-stream" otherwise.

   The drag data item kind

   File

   The actual data

   The file's contents and name.

   Dragging files can currently only happen from outside a browsing context, for example from a file system manager application.

   If the drag initiated outside of the application, the user agent must add items to the drag data store item list as appropriate for the data being dragged, honoring platform conventions where appropriate; however, if the platform conventions do not use MIME types to label dragged data, the user agent must make a best-effort attempt to map the types to MIME types, and, in any case, all the drag data item type strings must be converted to ASCII lowercase.

   User agents may also add one or more items representing the selection or dragged element(s) in other forms, e.g. as HTML.

6. Run the following substeps:

   1. Let urls be an empty list of absolute URLs.

   2. For each node in the list of dragged nodes:

      If the node is an a element with an href attribute

      Add to urls the result of resolving the element's href content attribute relative to the element.

      If the node is an img element with a src attribute

      Add to urls the result of resolving the element's src content attribute relative to the element.

   3. If urls is still empty, abort these substeps.

   4. Let url string be the result of concatenating the strings in urls, in the order they were added, separated by a U+000D CARRIAGE RETURN U+000A LINE FEED character pair (CRLF).

   5. Add one item to the drag data store item list, with its properties set as follows:

      The drag data item type string

      text/uri-list

      The drag data item kind

      Plain Unicode string

      The actual data

      url string

7. Update the drag data store default feedback as appropriate for the user agent (if the user is dragging the selection, then the selection would likely be the basis for this feedback; if the user is dragging an element, then that element's rendering would be used; if the drag began outside the user agent, then the platform conventions for determining the drag feedback should be used).

8. Fire a DND event named dragstart at the source node.

   If the event is canceled, then the drag-and-drop operation should not occur; abort these steps.

   Since events with no event listeners registered are, almost by definition, never canceled, drag-and-drop is always available to the user if the author does not specifically prevent it.

9. Initiate the drag-and-drop operation in a manner consistent with platform conventions, and as described below.

   The drag-and-drop feedback must be generated from the first of the following sources that is available:

   1. The drag data store bitmap, if any. In this case, the drag data store hot spot coordinate should be used as hints for where to put the cursor relative to the resulting image. The values are expressed as distances in CSS pixels from the left side and from the top side of the image respectively. [CSS]
   2. The drag data store default feedback.

From the moment that the user agent is to initiate the drag-and-drop operation, until the end of the drag-and-drop operation, device input events (e.g. mouse and keyboard events) must be suppressed.

During the drag operation, the element directly indicated by the user as the drop target is called the immediate user selection. (Only elements can be selected by the user; other nodes must not be made available as drop targets.) However, the immediate user selection is not necessarily the current target element, which is the element currently selected for the drop part of the drag-and-drop operation.

The immediate user selection changes as the user selects different elements (either by pointing at them with a pointing device, or by selecting them in some other way). The current target element changes when the immediate user selection changes, based on the results of event listeners in the document, as described below.

Both the current target element and the immediate user selection can be null, which means no target element is selected. They can also both be elements in other (DOM-based) documents, or other (non-Web) programs altogether. (For example, a user could drag text to a word-processor.) The current target element is initially null.

In addition, there is also a current drag operation, which can take on the values "none", "copy", "link", and "move". Initially, it has the value "none". It is updated by the user agent as described in the steps below.

User agents must, as soon as the drag operation is initiated and every 350ms (±200ms) thereafter for as long as the drag operation is ongoing, queue a task to perform the following steps in sequence:

1. If the user agent is still performing the previous iteration of the sequence (if any) when the next iteration becomes due, abort these steps for this iteration (effectively "skipping missed frames" of the drag-and-drop operation).

2. Fire a DND event named drag at the source node. If this event is canceled, the user agent must set the current drag operation to "none" (no drag operation).

3. If the drag event was not canceled and the user has not ended the drag-and-drop operation, check the state of the drag-and-drop operation, as follows:

   1. If the user is indicating a different immediate user selection than during the last iteration (or if this is the first iteration), and if this immediate user selection is not the same as the current target element, then fire a DND event named dragexit at the current target element, and then update the current target element as follows:

      If the new immediate user selection is null

      Set the current target element to null also.

      If the new immediate user selection is in a non-DOM document or application

      Set the current target element to the immediate user selection.

      Otherwise

      Fire a DND event named dragenter at the immediate user selection.

      If the event is canceled, then set the current target element to the immediate user selection.

      Otherwise, run the appropriate step from the following list:

      If the immediate user selection is a text field (e.g. textarea, or an input element whose type attribute is in the Text state) or an editing host or editable element, and the drag data store item list has an item with the drag data item type string "text/plain" and the drag data item kind Plain Unicode string

      Set the current target element to the immediate user selection anyway.

      If the immediate user selection is an element with a dropzone attribute that matches the drag data store

      Set the current target element to the immediate user selection anyway.

      If the immediate user selection is an element that itself has an ancestor element with a dropzone attribute that matches the drag data store

      Let new target be the nearest (deepest) such ancestor element.

      If the immediate user selection is new target, then leave the current target element unchanged.

      Otherwise, fire a DND event named dragenter at new target. Then, set the current target element to new target, regardless of whether that event was canceled or not.

      If the immediate user selection is the body element

      Leave the current target element unchanged.

      Otherwise

      Fire a DND event named dragenter at the body element, if there is one, or at the Document object, if not. Then, set the current target element to the body element, regardless of whether that event was canceled or not.

   2. If the previous step caused the current target element to change, and if the previous target element was not null or a part of a non-DOM document, then fire a DND event named dragleave at the previous target element.

   3. If the current target element is a DOM element, then fire a DND event named dragover at this current target element.

      If the dragover event is not canceled, run the appropriate step from the following list:

      If the current target element is a text field (e.g. textarea, or an input element whose type attribute is in the Text state) or an editing host or editable element, and the drag data store item list has an item with the drag data item type string "text/plain" and the drag data item kind Plain Unicode string

      Set the current drag operation to either "copy" or "move", as appropriate given the platform conventions.

      If the current target element is an element with a dropzone attribute that matches the drag data store and specifies an operation

      Set the current drag operation to the operation specified by the dropzone attribute of the current target element.

      If the current target element is an element with a dropzone attribute that matches the drag data store and does not specify an operation

      Set the current drag operation to "copy".

      Otherwise

      Reset the current drag operation to "none".

      Otherwise (if the dragover event is canceled), set the current drag operation based on the values of the effectAllowed and dropEffect attributes of the DragEvent object's dataTransfer object as they stood after the event dispatch finished, as per the following table:

      effectAllowed	dropEffect	Drag operation
      "uninitialized", "copy", "copyLink", "copyMove", or "all"	"copy"	"copy"
      "uninitialized", "link", "copyLink", "linkMove", or "all"	"link"	"link"
      "uninitialized", "move", "copyMove", "linkMove", or "all"	"move"	"move"
      Any other case		"none"

   4. Otherwise, if the current target element is not a DOM element, use platform-specific mechanisms to determine what drag operation is being performed (none, copy, link, or move), and set the current drag operation accordingly.

   5. Update the drag feedback (e.g. the mouse cursor) to match the current drag operation, as follows:

      Drag operation	Feedback
      "copy"	Data will be copied if dropped here.
      "link"	Data will be linked if dropped here.
      "move"	Data will be moved if dropped here.
      "none"	No operation allowed, dropping here will cancel the drag-and-drop operation.

4. Otherwise, if the user ended the drag-and-drop operation (e.g. by releasing the mouse button in a mouse-driven drag-and-drop interface), or if the drag event was canceled, then this will be the last iteration. Run the following steps, then stop the drag-and-drop operation:

   1. If the current drag operation is "none" (no drag operation), or, if the user ended the drag-and-drop operation by canceling it (e.g. by hitting the Escape key), or if the current target element is null, then the drag operation failed. Run these substeps:

      1. Let dropped be false.

      2. If the current target element is a DOM element, fire a DND event named dragleave at it; otherwise, if it is not null, use platform-specific conventions for drag cancellation.

      3. Set the current drag operation to "none".

      Otherwise, the drag operation might be a success; run these substeps:

      1. Let dropped be true.

      2. If the current target element is a DOM element, fire a DND event named drop at it; otherwise, use platform-specific conventions for indicating a drop.

      3. If the event is canceled, set the current drag operation to the value of the dropEffect attribute of the DragEvent object's dataTransfer object as it stood after the event dispatch finished.

         Otherwise, the event is not canceled; perform the event's default action, which depends on the exact target as follows:

         If the current target element is a text field (e.g. textarea, or an input element whose type attribute is in the Text state) or an editing host or editable element, and the drag data store item list has an item with the drag data item type string "text/plain" and the drag data item kind Plain Unicode string

         Insert the actual data of the first item in the drag data store item list to have a drag data item type string of "text/plain" and a drag data item kind that is Plain Unicode string into the text field or editing host or editable element in a manner consistent with platform-specific conventions (e.g. inserting it at the current mouse cursor position, or inserting it at the end of the field).

         Otherwise

         Reset the current drag operation to "none".

   2. Fire a DND event named dragend at the source node.

   3. Run the appropriate steps from the following list as the default action of the dragend event:

      If dropped is true, the current target element is a text field (see below), the current drag operation is "move", and the source of the drag-and-drop operation is a selection in the DOM that is entirely contained within an editing host

      Delete the selection.

      If dropped is true, the current target element is a text field (see below), the current drag operation is "move", and the source of the drag-and-drop operation is a selection in a text field

      The user agent should delete the dragged selection from the relevant text field.

      If dropped is false or if the current drag operation is "none"

      The drag was canceled. If the platform conventions dictate that this be represented to the user (e.g. by animating the dragged selection going back to the source of the drag-and-drop operation), then do so.

      Otherwise

      The event has no default action.

      For the purposes of this step, a text field is a textarea element or an input element whose type attribute is in one of the Text, Search, Tel, URL, E-mail, Password, or Number states.

User agents are encouraged to consider how to react to drags near the edge of scrollable regions. For example, if a user drags a link to the bottom of the viewport on a long page, it might make sense to scroll the page so that the user can drop the link lower on the page.

This model is independent of which Document object the nodes involved are from; the events are fired as described above and the rest of the processing model runs as described above, irrespective of how many documents are involved in the operation.

The draggable IDL attribute, whose value depends on the content attribute's in the way described below, controls whether or not the element is draggable. Generally, only text selections are draggable, but elements whose draggable IDL attribute is true become draggable as well.

If an element's draggable content attribute has the state true, the draggable IDL attribute must return true.

Otherwise, if the element's draggable content attribute has the state false, the draggable IDL attribute must return false.

Otherwise, the element's draggable content attribute has the state auto. If the element is an img element, an object element that represents an image, or an a element with an href content attribute, the draggable IDL attribute must return true; otherwise, the draggable IDL attribute must return false.

If the draggable IDL attribute is set to the value false, the draggable content attribute must be set to the literal value false. If the draggable IDL attribute is set to the value true, the draggable content attribute must be set to the literal value true.

A dropzone attribute matches a drag data store if the dropzone processing steps result in a match.

A dropzone attribute specifies an operation if the dropzone processing steps result in a specified operation. The specified operation is as given by those steps.

The dropzone processing steps are as follows. They either result in a match or not, and separate from this result either in a specified operation or not, as defined below.

1. Let value be the value of the dropzone attribute.

2. Let keywords be the result of splitting value on spaces.

3. Let matched be false.

4. Let operation be unspecified.

5. For each value in keywords, if any, in the order that they were found in value, run the following steps.

   1. Let keyword be the keyword.

   2. If keyword is one of "copy", "move", or "link", then: run the following substeps:

      1. If operation is still unspecified, then let operation be the string given by keyword.

      2. Skip to the step labeled end of keyword below.

   3. If keyword does not contain a ":" (U+003A) character, or if the first such character in keyword is either the first character or the last character in the string, then skip to the step labeled end of keyword below.

   4. Let kind code be the substring of keyword from the first character in the string to the last character in the string that is before the first ":" (U+003A) character in the string, converted to ASCII lowercase.

   5. Jump to the appropriate step from the list below, based on the value of kind code:

      If kind code is the string "string"

      Let kind be Plain Unicode string.

      If kind code is the string "file"

      Let kind be File.

      Otherwise

      Skip to the step labeled end of keyword below.

   6. Let type be the substring of keyword from the first character after the first ":" (U+003A) character in the string, to the last character in the string, converted to ASCII lowercase.

   7. If there exist any items in the drag data store item list whose drag data item kind is the kind given in kind and whose drag data item type string is type, then let matched be true.

   8. End of keyword: Go on to the next keyword, if any, or the next step in the overall algorithm, if there are no more.

6. The algorithm results in a match if matched is true, and does not otherwise.

   The algorithm results in a specified operation if operation is not unspecified. The specified operation, if one is specified, is the one given by operation.

The dropzone IDL attribute must reflect the content attribute of the same name.

7.7.9 Security risks in the drag-and-drop model

User agents must not make the data added to the DataTransfer object during the dragstart event available to scripts until the drop event, because otherwise, if a user were to drag sensitive information from one document to a second document, crossing a hostile third document in the process, the hostile document could intercept the data.

For the same reason, user agents must consider a drop to be successful only if the user specifically ended the drag operation — if any scripts end the drag operation, it must be considered unsuccessful (canceled) and the drop event must not be fired.

User agents should take care to not start drag-and-drop operations in response to script actions. For example, in a mouse-and-window environment, if a script moves a window while the user has his mouse button depressed, the UA would not consider that to start a drag. This is important because otherwise UAs could cause data to be dragged from sensitive sources and dropped into hostile documents without the user's consent.

User agents should filter potentially active (scripted) content (e.g. HTML) when it is dragged and when it is dropped, using a whitelist of known-safe features. Similarly, relative URLs should be turned into absolute URLs to avoid references changing in unexpected ways. This specification does not specify how this is performed.