User interaction

The hidden attribute

Because this attribute is typically implemented using CSS, it's also possible to override it using CSS. For instance, a rule that applies 'display: block' to all elements will cancel the effects of the <{global/hidden}> attribute. Authors therefore have to take care when writing their style sheets to make sure that the attribute is still styled as expected.

Inert subtrees

This section does not define or create any content attribute named "inert". This section merely defines an abstract concept of inertness.

For example, consider a page that consists of just a single inert paragraph positioned in the middle of a <{body}>. If a user moves their pointing device from the body over to the inert paragraph and clicks on the paragraph, no mouseover event would be fired, and the mousemove and click events would be fired on the <{body}> element rather than the paragraph.

When a node is inert, it generally cannot be focused. Inert nodes that are commands will also get disabled.

The <{dialog}> element's showModal() method makes use of this mechanism.

Activation

For accessibility, the keyboard's `Enter` and `Space` keys are often used to trigger an element's [=activation behavior=]. [[wai-aria-practices-1.1]]

1. If the element's click in progress flag is set to true, then abort these steps.
2. Set the click in progress flag on the element to true.
3. Run pre-click activation steps on the element.
4. Fire a click event at the element. If the run synthetic click activation steps algorithm was invoked because the click() method was invoked, then the isTrusted attribute must be initialized to false.
5. If this click event is not canceled, run post-click activation steps on the element. If the event is canceled, the user agent must run canceled activation steps on the element instead.
6. Set the click in progress flag on the element to false.

1. Let target be the element designated by the user (the target of event).
2. If target is a <{canvas}> element, run the canvas {{MouseEvent}} rerouting steps. If this changes event's target, then let target be the new target.
3. Set the click in progress flag on target to true.
4. Let e be the nearest activatable element of target (defined below), if any.
5. If there is an element e, run pre-click activation steps on it.
6. Dispatch event (the required click event) at target. If there is an element e and the click event is not canceled, run post-click activation steps on element e. If there is an element e and the event is canceled, run canceled activation steps on element e.
7. Set the click in progress flag on target to false.

The algorithms above don't run for arbitrary synthetic events dispatched by author script. The click() method can be used to make the run synthetic click activation steps algorithm happen programmatically.

Click-focusing behavior (e.g., the focusing of a text field when user clicks in one) typically happens before the click, when the mouse button is first depressed, and is therefore not discussed here.

1. If target has a defined activation behavior, then return target and abort these steps.
2. If target has a parent element, then set target to that parent element and return to the first step.
3. Otherwise, there is no nearest activatable element.

element . click()

Acts as if the element was clicked.

Focus

Introduction

Consider an HTML application running in a browser tab running in a graphical environment. Suppose this application had a page with some text fields and links, and was currently showing a modal dialog, which itself had a text field and a button. The hierarchy of focusable widgets, in this scenario, would include the browser window, which would have, amongst its children, the browser tab containing the HTML application. The tab itself would have as its children the various links and text fields, as well as the dialog. The dialog itself would have as its children the text field and the button. If the widget with focus in this example was the text field in the dialog box, then key input would be channeled from the graphical system to ① the Web browser, then to ② the tab, then to ③ the dialog, and finally to ④ the text field.

Data model

A browsing context container (e.g., an <{iframe}>) is a focusable area, but key events routed to a browsing context container get immediately routed to the nested browsing context's active document. Similarly, in sequential focus navigation a browsing context container essentially acts merely as a placeholder for its nested browsing context's active document.

• {{Document}} object that have browsing contexts.
• <{dialog}> elements that have an open attribute specified and that are being rendered.

1. Let candidate be the Document of the top-level browsing context.
2. If candidate has a dialog group with a designated focused dialog of the dialog group, then let candidate be the designated focused dialog of the dialog group, and redo this step. Otherwise, if candidate has a non-empty control group, and the designated focused area of the control group is a browsing context container, then let candidate be the active document of that browsing context container's nested browsing context, and redo this step. Otherwise, if candidate has a non-empty control group, let candidate be the designated focused area of the control group.
3. Return candidate.

1. Let current object be subject.
2. Let output be an empty list.
3. Loop: Append current object to output.
4. If current object is an <{area}> element's shape, append that <{area}> element to output. Otherwise, if current object is a focusable area whose DOM anchor is an element that is not current object itself, append that DOM anchor element to output.
5. If current object is a dialog object in a dialog group, let current object be that dialog group's manager, and return to the step labeled loop. Otherwise, if current object is a focusable area, let current object be that focusable area's control group's owner, and return to the step labeled loop. Otherwise, if current object is a Document in a nested browsing context, let current object be its browsing context container, and return to the step labeled loop.
6. Return output.

   The chain starts with subject and (if subject is or can be the currently focused area of a top-level browsing context) continues up the focus hierarchy up to the Document of the top-level browsing context.

The tabindex attribute

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 and any focusable areas that have the element as their DOM anchor can be reached using sequential focus navigation, and if so, what their relative position in the sequential focus navigation order is to be. Modulo platform conventions, it is suggested that for the following elements, the tabindex focus flag be set:

• <{a}> elements that have an <{links/href}> attribute
• <{link}> elements that have an <{link/href}> attribute
• <{button}> elements
• <{input}> elements whose <{input/type}> attribute are not in the <{input/Hidden}> state
• <{select}> elements
• <{textarea}> elements
• Elements with a <{global/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
• <{audio}> and <{video}> elements with a controls attribute
• Editing hosts
• Browsing context containers

If the value is a negative integer

The user agent must set the element's tabindex focus flag, but should omit the element from the sequential focus navigation order.

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 <{global/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 and any focusable areas that have the element as their DOM anchor to be reached using sequential focus navigation, following platform conventions to determine the element's relative position in the sequential focus navigation order.

If the value is greater than zero

The user agent must set the element's tabindex focus flag, should allow the element and any focusable areas that have the element as their DOM anchor to be reached using sequential focus navigation, and should place the element — referenced as candidate below — and the aforementioned focusable areas in the sequential focus navigation order so that, relative to other focusable areas in the sequential focus navigation order, they are:

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

In current user agent implementations, an element that is only focusable because of its <{global/tabindex}> attribute will generally not fire a click event in response to a non-mouse activation (e.g., hitting the "enter" key while the element is focused).

Most current browsers instead give the {{HTMLElement/tabIndex}} IDL attribute a value of 0 for some list of elements that are by default a focusable area, and -1 for other elements, if there is no <{global/tabindex}> content attribute set. This behaviour is not well-defined and will hopefully be improved in the future.

Processing model

1. If new focus target is neither a <{dialog}> element that has an open attribute specified and that is being rendered (i.e., that is a control group owner object), nor a focusable area, then run the first matching set of steps from the following list:

   If new focus target is an <{area}> element with one or more shapes that are focusable areas

   Let new focus target be the shape corresponding to the first <{img}> element in tree order that uses the image map to which the area element belongs.

   If new focus target is an element with one or more scrollable regions that are focusable areas

   Let new focus target be the element's first scrollable region, according to a pre-order, depth-first traversal of the box tree. [[!CSS-2015]]

   If new focus target is the document element of its Document

   Let new focus target be the Document's viewport.

   If new focus target is a browsing context

   Let new focus target be the browsing context's active document.

   If new focus target is a browsing context container

   Let new focus target be the browsing context container's nested browsing context's active document.

   Otherwise

   If no fallback target was specified, abort the focusing steps. Otherwise, let new focus target be the fallback target.

2. If new focus target is a control group owner object that is not a focusable area, but does have a dialog group, and that dialog group has a designated focused dialog, then let new focus target be the focused dialog of the dialog group, and redo this step. Otherwise, if new focus target is a control group owner object that is not a focusable area, and its control group is not empty, then designate new focus target as the focused area of the control group, and redo this step. Otherwise, if new focus target is a browsing context container, then let new focus target be the nested browsing context's active document, and redo this step.

   A <{dialog}> element can be both a control group owner object and a focusable area, if it has both an open attribute specified and a <{global/tabindex}> attribute specified and is being rendered.

3. If new focus target is a focusable area and its DOM anchor is inert, then abort these steps.
4. If new focus target is the currently focused area of a top-level browsing context, then abort these steps.
5. Let old chain be the focus chain of the currently focused area of the top-level browsing context in which new focus target finds itself.
6. Let new chain be the focus chain of new focus target.
7. Run the focus update steps with old chain, new chain, and new focus target respectively.

1. If old focus target is inert, then abort these steps.
2. If old focus target is an <{area}> element and one of its shapes is the currently focused area of a top-level browsing context, or, if old focus target is an element with one or more scrollable regions, and one of them is the currently focused area of a top-level browsing context, then let old focus target be that currently focused area of a top-level browsing context.
3. Let old chain be the focus chain of the currently focused area of a top-level browsing context.
4. If old focus target is not one of the entries in old chain, then abort these steps.
5. If old focus target is a dialog in a dialog group, and the dialog group manager has a non-empty control group, then let new focus target be the designated focused area of that focus group. Otherwise, if old focus target is a focusable area, then let new focus target be the first focusable area of its control group (if the control group owner is a {{Document}}, this will always be a viewport). Otherwise, let new focus target be null.
6. If new focus target is not null, then run the focusing steps for new focus target.

The unfocusing steps do not always result in the focus changing, even when applied to the currently focused area of a top-level browsing context. For example, if the currently focused area of a top-level browsing context is a viewport, then it will usually keep its focus regardless until another focusable area is explicitly focused with the focusing steps.

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

1. Let old focus target be whatever the currently focused area of the top-level browsing context was immediately before this algorithm became applicable (e.g., before the element was disabled, or the dialog was closed, or whatever caused this algorithm to run).
2. Let old chain be the focus chain of the currently focused area of the top-level browsing context at the same time.
3. Make sure that the changes implied by the focus fixup rules one, two, and three above are applied.
4. Let new focus target be the currently focused area of a top-level browsing context.
5. If old focus target and new focus target are the same, abort these steps.
6. Let new chain be the focus chain of new focus target.
7. Run the focus update steps with old chain, new chain, and new focus target respectively.

1. If the last entry in old chain and the last entry in new chain are the same, pop the last entry from old chain and the last entry from new chain and redo this step.
2. For each entry entry in old chain, in order, run these substeps:
   1. If entry 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. If entry is an element, let blur event target be entry. If entry is a Document object, let blur event target be that Document object's Window object. Otherwise, let blur event target be null.
   3. If entry is the last entry in old chain, and entry is an {{Element}}, and the last entry in new chain is also an {{Element}}, then let related blur target be the last entry in new chain. Otherwise, let related blur target be null.
   4. If blur event target is not null, fire a focus event named blur at blur event target, with related blur target as the related target.

      In some cases, e.g., if entry is an area element's shape, a scrollable region, or a viewport, no event is fired.

   5. If blur event target is not null, fire an event named focusout at the blur event target.
3. Apply any relevant platform-specific conventions for focusing new focus target. (For example, some platforms select the contents of a text field when that field is focused.)
4. For each entry entry in new chain, in reverse order, run these substeps:
   1. If entry is a <{dialog}> element: Let entry be the designated focused dialog of its dialog group.
   2. If entry is a focusable area: Designate entry as the focused area of the control group. If its control group's owner is also a dialog group manager, then let there be no designated focused dialog in that dialog group.

      It is possible for entry to be both a dialog element and a focusable area, in which case it is its own control group owner.

   3. If entry is an element, let focus event target be entry. If entry is a Document object, let focus event target be that Document object's Window object. Otherwise, let focus event target be null.
   4. If entry is the last entry in new chain, and entry is an {{Element}}, and the last entry in old chain is also an {{Element}}, then let related focus target be the last entry in old chain. Otherwise, let related focus target be null.
   5. If focus event target is not null, fire a focus event named focus at focus event target, with related focus target as the related target.

      In some cases, e.g., if entry is an area element's shape, a scrollable region, or a viewport, no event is fired.

   6. If focus event target is not null, fire an event named focusin at the focus event target.

1. Let target area be the currently focused area of the top-level browsing context.
2. If target area is a focusable area, let target node be target area's DOM anchor. Otherwise, target area is a dialog; let target node be target area.
3. If target node is a Document that has a <{body}> element, then let target node be the <{body}> element of that {{Document}}. Otherwise, if target node is a {{Document}} object that has a non-null document element, then let target node be that document element.
4. If target node is not inert, fire the event at target node.

   It is possible for the currently focused area of a top-level browsing context to be inert, for example if a modal dialog is shown, and then that dialog element is made inert. It is likely to be the result of a logic error in the application, though.

5. If the event was not canceled, then let target area handle the key event. This might include running synthetic click activation steps for target node.

1. Let candidate be the Document of the top-level browsing context.
2. If candidate is target, return true and abort these steps.
3. If candidate has a dialog group with a designated focused dialog of the dialog group, then let candidate be the designated focused dialog of the dialog group, and redo this step. Otherwise, if candidate has a non-empty control group, and the designated focused area of the control group is a browsing context container, and the active document of that browsing context container's nested browsing context is target, then return true and abort these steps. Otherwise, if candidate has a non-empty control group, and the designated focused area of the control group is a browsing context container, then let candidate be the active document of that browsing context container's nested browsing context, and redo this step. Otherwise, return false and abort these steps.

Sequential focus navigation

For example, the user agent could set it to the position of the user's click if the user clicks on the document contents.

1. Let starting point be the currently focused area of a top-level browsing context, if the user requested to move focus sequentially from there, or else the top-level browsing context itself, if the user instead requested to move focus from outside the top-level browsing context.
2. If there is a sequential focus navigation starting point defined and it is inside starting point, then let starting point be the sequential focus navigation starting point instead.
3. Let direction be forward if the user requested the next control, and backward if the user requested the previous control.

   Typically, pressing tab requests the next control, and pressing shift+tab requests the previous control.

4. Loop: Let selection mechanism be sequential if the starting point is a browsing context or if starting point is in its control group's sequential focus navigation order. Otherwise, starting point is not in its control group's sequential focus navigation order; let selection mechanism be DOM.
5. Let candidate be the result of running the sequential navigation search algorithm with starting point, direction, and selection mechanism as the arguments.
6. If candidate is not null, then run the focusing steps for candidate and abort these steps.
7. Otherwise, unset the sequential focus navigation starting point.
8. If starting point is the top-level browsing context, or a focusable area in the top-level browsing context, the user agent should transfer focus to its own controls appropriately (if any), honouring direction, and then abort these steps.

   For example, if direction is backward, then the last focusable control before the browser's rendering area would be the control to focus.

   If the user agent has no focusable controls — a kiosk-mode browser, for instance — then the user agent may instead restart these steps with the starting point being the top-level browsing context itself.
9. Otherwise, starting point is a focusable area in a nested browsing context. Let starting point be that nested browsing context's browsing context container, and return to the step labeled loop.

1. Pick the appropriate cell from the following table, and follow the instructions in that cell. The appropriate cell is the one that is from the column whose header describes direction and from the first row whose header describes starting point and selection mechanism.

   	direction is forward	direction is backward
   starting point is a browsing context	Let candidate be the first suitable sequentially focusable area in starting point's active document's primary control group, if any; or else null	Let candidate be the last suitable sequentially focusable area in starting point's active document's primary control group, if any; or else null
   selection mechanism is DOM	Let candidate be the first suitable sequentially focusable area in the home control group following starting point, if any; or else null	Let candidate be the last suitable sequentially focusable area in the home control group preceding starting point, if any; or else null
   selection mechanism is sequential	Let candidate be the first suitable sequentially focusable area in the home sequential focus navigation order following starting point, if any; or else null	Let candidate be the last suitable sequentially focusable area in the home sequential focus navigation order preceding starting point, if any; or else null

   A suitable sequentially focusable area is a focusable area whose DOM anchor is not inert and that is in its control group's sequential focus navigation order. The primary control group of a control group owner object X is the control group of X if X has no dialog group or if its dialog group has no designated focused dialog of the dialog group, otherwise, it is the primary control group of X's dialog group's designated focused dialog of the dialog group. The home control group is the control group to which starting point belongs. The home sequential focus navigation order is the sequential focus navigation order to which starting point belongs.

   The home sequential focus navigation order is the home control group's sequential focus navigation order, but is only used when the starting point is in that sequential focus navigation order (when it's not, selection mechanism will be DOM).

2. If candidate is a browsing context container, then let new candidate be the result of running the sequential navigation search algorithm with candidate's nested browsing context as the first argument, direction as the second, and sequential as the third. If new candidate is null, then let starting point be candidate, and return to the top of this algorithm. Otherwise, let candidate be new candidate.
3. Return candidate.

Focus management APIs

document . activeElement

Returns the deepest element in the document through which or to which key events are being routed. This is, roughly speaking, the focused element in the document. For the purposes of this API, when a child browsing context is focused, its browsing context container is focused in the parent browsing context. For example, if the user moves the focus to a text field in an <{iframe}>, the iframe is the element returned by the activeElement API in the iframe's node document.

document . hasFocus()

Returns true if key events are being routed through or to the document; otherwise, returns false. Roughly speaking, this corresponds to the document, or a document nested inside this one, being focused.

window . focus()

Moves the focus to the window's browsing context, if any.

element . focus()

Moves the focus to the element. If the element is a browsing context container, moves the focus to the nested browsing context instead.

element . blur()

Moves the focus to the viewport. Use of this method is discouraged; if you want to focus the viewport, call the focus() method on the Document's document element. Do not use this method to hide the focus ring if you find the focus ring unsightly. Instead, use a CSS rule to override the 'outline' property, and provide a different way to show what element is focused. Be aware that if an alternative focusing style isn't made available, the page will be significantly less usable for people who primarily navigate pages using a keyboard, or those with reduced vision who use focus outlines to help them navigate the page.

For example, to hide the outline from links and instead use a yellow background to indicate focus, you could use:

:link:focus, :visited:focus { outline: none; background: yellow; color: black; }

Do not use this method to hide the focus ring. Do not use any other method that hides the focus ring from keyboard users, in particular do not use a CSS rule to override the 'outline' property. Removal of the focus ring leads to serious accessibility issues for users who navigate and interact with interactive content using the keyboard.

1. Let candidate be the Document on which the method was invoked.
2. If candidate has a dialog group with a designated focused dialog of the dialog group, then let candidate be the designated focused dialog of the dialog group, and redo this step.
3. If candidate has a non-empty control group, let candidate be the designated focused area of the control group.
4. If candidate is a focusable area, let candidate be candidate's DOM anchor.
5. If candidate is a Document that has a <{body}> element, then let candidate be the <{body}> element of that {{Document}}. Otherwise, if candidate is a {{Document}} with a non-null document element, then let candidate be that document element. Otherwise, if candidate is a {{Document}}, then let candidate be null.
6. Return candidate.

Historically, the focus() and blur() methods actually affected the system-level focus of the system widget (e.g., tab or window) that contained the browsing context, but hostile sites widely abuse this behavior to the user's detriment.

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.

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.

Clipboard actions and focus

There are three clipboard actions that affect selection: cut, copy, and paste. Focus may follow selection, and user-agents handle this by default, but when custom clipboard actions are implemented the author needs to provide the following behaviors:

Cut action:

When a cut action is performed, the selected object should be removed and the collapsed section set in place of the cut object.

Copy action:

When a copy action is performed, it does not affect the collapsed section or selection.

Paste action:

When a paste action is performed, the collapsed section should be placed at the end of the pasted content.

Assigning keyboard shortcuts

Introduction

User agents may not assign any shortcut, or assigned shortcuts may be overridden by other browser- or system-level shortcuts.

The accesskey attribute

Processing model

1. If the element has no <{global/accesskey}> attribute, then skip to the fallback step below.
2. The user agent may assign a key combination based on stored user preferences as the element's assigned access key and then abort these steps.
3. Let value be the value of the <{global/accesskey}> attribute.
4. The user agent may strip content from value to reduce the length of value to a single Unicode code point.
5. If value is not a string of exactly one printable character, then the user agent may abort these steps.
6. The user agent may assign a combination of a mix of zero or more modifier keys and value as the element's assigned access key and abort these steps.
7. 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.
8. If this step is reached, the element has no assigned access key.

User agents might expose elements that have an <{global/accesskey}> attribute in other ways as well, e.g., in a menu displayed in response to a specific key combination, or with a user gesture.

Editing

Making document regions editable: The contenteditable content attribute

    [NoInterfaceObject]
    interface ElementContentEditable {
      attribute DOMString contentEditable;
      readonly attribute boolean isContentEditable;
    };
  

element . {{ElementContentEditable/contentEditable}} [ = value ]

Returns "true", "false", or "inherit", based on the state of the <{global/contenteditable}> attribute. Can be set, to change that state. Throws a "{{SyntaxError}}" {{DOMException}} if the new value isn't one of those strings.

element . isContentEditable

Returns true if the element is editable; otherwise, returns false.

Making entire documents editable: The designMode IDL attribute

document . {{Document/designMode}} [ = value ]

Returns "on" if the document is editable, and "off" if it isn't. Can be set, to change the document's current state. This focuses the document and resets the selection in that document.

Best practices for in-page editors

Editing APIs

Spelling and grammar checking

true-by-default

The element will be checked for spelling and grammar if its contents are editable and spellchecking is not explicitly disabled through the <{global/spellcheck}> attribute.

false-by-default

The element will never be checked for spelling and grammar unless spellchecking is explicitly enabled through the <{global/spellcheck}> attribute.

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 true state indicates that the element is to have its spelling and grammar checked. The default state indicates that the element is to act according to a default behavior, possibly based on the parent element's own <{global/spellcheck}> state, as defined below. The false state indicates that the element is not to be checked.

element . {{HTMLElement/spellcheck}} [ = value ]

Returns true if the element is to have its spelling and grammar checked; otherwise, returns false. Can be set, to override the default and set the <{global/spellcheck}> content attribute.

element . forceSpellCheck()

Forces the user agent to report spelling and grammar errors on the element (if checking is enabled), even if the user has never focused the element. (If the method is not invoked, user agents can hide errors in text that wasn't just entered by the user.)

The {{HTMLElement/spellcheck}} IDL attribute is not affected by user preferences that override the <{global/spellcheck}> content attribute, and therefore might not reflect the actual spellchecking state.

• The value of <{input}> elements whose <{input/type}> attributes are in the <{input/Text}>, <{input/Search}>, <{input/URL}>, or <{input/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.

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 <{global/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 <{global/spellcheck}> content attribute that is not in the default state, then: if the nearest such ancestor's <{global/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.

This specification does not define the user interface for spelling and grammar checkers. A user agent could offer on-demand checking, could perform continuous checking while the checking is enabled, or could use other interfaces.

Drag and drop

Introduction

A drop target can handle the dragenter event (to report whether or not the drop target is to accept the drop) and the dragover event (to specify what feedback is to be shown to the user).

The drag data store

• A drag data store item list, which is a list of items representing the dragged data, each consisting of the following information:

  The drag data item kind

  The kind of data:

  Plain Unicode string

  Text. Values must not be escaped.

  File

  Binary data with a file name.

  The drag data item type string

  A Unicode string giving the type or format of the data, generally given by a MIME type. Some values that are not MIME types are special-cased for legacy reasons. The API does not enforce the use of MIME types; other values can be used as well. In all cases, however, the values are all converted to ASCII lowercase by the API. There is a limit of one Plain Unicode string item per item type string.

  The actual data

  A Unicode or binary string, in some cases with a file name (itself a Unicode string), as per the drag data item kind.

  The drag data store item list is ordered in the order that the items were added to the list; most recently added last.
• The following information, used to generate the UI feedback during the drag:
  • User-agent-defined default feedback information, known as the drag data store default feedback.
  • Optionally, a bitmap image and the coordinate of a point within that image, known as the drag data store bitmap and drag data store hot spot coordinate.
• A drag data store mode, which is one of the following:

  Read/write mode

  For the dragstart event. New data can be added to the drag data store.

  Read-only mode

  For the drop event. The list of items representing dragged data can be read, including the data. No new data can be added.

  Protected mode

  For all other events. The formats and kinds in the drag data store list of items representing dragged data can be enumerated, but the data itself is unavailable and no new data can be added.

• A drag data store allowed effects state, which is a string.

The DataTransfer interface

    interface DataTransfer {
      attribute DOMString dropEffect;
      attribute DOMString effectAllowed;

      [SameObject] readonly attribute DataTransferItemList items;

      void setDragImage(Element image, long x, long y);

      /* old interface */
      [SameObject] readonly attribute DOMString[] types;
      DOMString getData(DOMString format);
      void setData(DOMString format, DOMString data);
      void clearData(optional DOMString format);
      [SameObject] readonly attribute FileList files;
    };
  

dataTransfer . {{DataTransfer/dropEffect}} [ = value ]

Returns the kind of operation that is currently selected. If the kind of operation isn't one of those that is allowed by the {{DataTransfer/effectAllowed}} attribute, then the operation will fail. Can be set, to change the selected operation. The possible values are "none", "copy", "link", and "move".

dataTransfer . {{DataTransfer/effectAllowed}} [ = value ]

Returns the kinds of operations that are to be allowed. Can be set (during the dragstart event), to change the allowed operations. The possible values are "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", and "uninitialized",

dataTransfer . {{DataTransfer/items}}

Returns a {{DataTransferItemList}} object, with the drag data.

dataTransfer . {{DataTransfer/setDragImage()|setDragImage}}(element, x, y)

Uses the given element to update the drag feedback, replacing any previously specified feedback.

dataTransfer . {{DataTransfer/types}}

Returns an array listing the formats that were set in the dragstart event. In addition, if any files are being dragged, then one of the types will be the string "Files".

data = dataTransfer . {{DataTransfer/getData()|getData}}(format)

Returns the specified data. If there is no such data, returns the empty string.

dataTransfer . {{DataTransfer/setData()|setData}}(format, data)

Adds the specified data.

dataTransfer . {{DataTransfer/clearData()|clearData}}( [ format ] )

Removes the data of the specified formats. Removes all data if the argument is omitted.

dataTransfer . {{DataTransfer/files}}

Returns a FileList of the files being dragged, if any.

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.

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 {{DataTransferItem/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 {{DataTransferItem/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.

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, in 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 {{DataTransferItem/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 {{DataTransferItem/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.

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, in 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 {{DataTransferItem/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 {{DataTransferItem/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.

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 {{DataTransferItem/kind}} is Plain Unicode string, and abort these steps.
4. Let format be the first argument, in 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 {{DataTransferItem/kind}} is Plain Unicode string and whose type string is equal to format, if there is one.

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

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 {{DataTransferItem/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.

The DataTransferItemList interface

    interface DataTransferItemList {
      readonly attribute unsigned long length;
      getter DataTransferItem (unsigned long index);
      DataTransferItem? add(DOMString data, DOMString type);
      DataTransferItem? add(File data);
      void remove(unsigned long index);
      void clear();
    };
  

items . {{DataTransferItemList/length}}

Returns the number of items in the drag data store.

items[index]

Returns the {{DataTransferItem}} object representing the indexth entry in the drag data store.

items . {{DataTransferItemList/remove()|remove}}(index)

Removes the indexth entry in the drag data store.

items . {{DataTransferItemList/clear()}}

Removes all the entries in the drag data store.

items . {{DataTransferItemList/add()|add}}(data)

items . {{DataTransferItemList/add()|add}}(data, type)

Adds a new entry for the given data to the drag data store. If the data is plain text then a type string has to be provided also.

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 {{DataTransferItem/kind}} is Plain Unicode string and whose type string is equal to the value of the method's second argument, in ASCII lowercase, then throw a {{NotSupportedError}} exception and abort these steps. Otherwise, add an item to the drag data store item list whose {{DataTransferItem/kind}} is Plain Unicode string, whose type string is equal to the value of the method's second argument, in 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 {{DataTransferItem/kind}} is File, whose type string is the {{DataTransferItem/type}} of the File, in 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).

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 DataTransferItem interface

    interface DataTransferItem {
      readonly attribute DOMString kind;
      readonly attribute DOMString type;
      void getAsString(FunctionStringCallback? _callback);
      File? getAsFile();
    };

    callback FunctionStringCallback = void (DOMString data);
  

item . {{DataTransferItem/kind}}

Returns the drag data item kind, one of: "string", "file".

item . {{DataTransferItem/type}}

Returns the drag data item type string.

item . {{DataTransferItem/getAsString()|getAsString}}(callback)

Invokes the callback with the string data as the argument, if the drag data item kind is Plain Unicode string.

file = item . {{DataTransferItem/getAsFile()}}

Returns a File object, if the drag data item kind is File.

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.

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 DragEvent interface

    [Constructor(DOMString type, optional DragEventInit eventInitDict)]
    interface DragEvent : MouseEvent {
      readonly attribute DataTransfer? dataTransfer;
    };

    dictionary DragEventInit : MouseEventInit {
      DataTransfer? dataTransfer = null;
    };
  

event . {{DragEvent/dataTransfer}}

Returns the {{DataTransfer}} object for the event.

Although, for consistency with other event interfaces, the {{DragEvent}} interface has a constructor, it is not particularly useful. In particular, there's no way to create a useful {{DataTransfer}} object from script, as {{DataTransfer}} objects have a processing and security model that is coordinated by the browser during drag-and-drops.

1. Let dataDragStoreWasChanged be false.
2. If no specific related target was provided, set related target to null.
3. Let window be the Window object of the Document object of the specified target element.
4. If e is dragstart, then set the drag data store mode to the read/write mode and set dataDragStoreWasChanged to true. If e is drop, set the drag data store mode to the read-only mode.
5. Let dataTransfer be a newly created {{DataTransfer}} object associated with the given drag data store.
6. Set the {{DataTransfer/effectAllowed}} attribute to the drag data store's drag data store allowed effects state.
7. Set the {{DataTransfer/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 {{DataTransfer/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):

   {{DataTransfer/effectAllowed}}	{{DataTransfer/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 <{links/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".

8. 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 view attribute initialized to window, 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 related target, and the {{DragEvent/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.
9. Dispatch the newly created {{DragEvent}} object at the specified target element.
10. Set the drag data store allowed effects state to the current value of dataTransfer's {{DataTransfer/effectAllowed}} attribute. (It can only have changed value if e is dragstart.)
11. If dataDragStoreWasChanged is true, then set the drag data store mode back to the protected mode.
12. Break the association between dataTransfer and the drag data store.

Drag-and-drop processing model

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 {{HTMLElement/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 <{links/href}> attribute have their <{global/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 in 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. If the list of dragged nodes is not empty, then extract the microdata from those nodes into a JSON form, and add one item to the drag data store item list, with its properties set as follows:

   The drag data item type string

   application/microdata+json

   The drag data item kind

   Plain Unicode string

   The actual data

   The resulting JSON string.

7. 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 <{links/href}> attribute

      Add to urls the result of parsing the element's <{links/href}> content attribute relative to the element's node document

      If the node is an <{img}> element with a <{img/src}> attribute

      Add to urls the result of parsing the element's src content attribute relative to the element's node document

   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

8. 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).
9. 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.

10. 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-2015]]
    2. The drag data store default feedback.

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 <{input/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 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, with the new current target element as the specific related target.
   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 <{input/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.

      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 {{DataTransfer/effectAllowed}} and {{DataTransfer/dropEffect}} attributes of the {{DragEvent}} object's {{DragEvent/dataTransfer}} object as they stood after the event dispatch finished, as per the following table:

      {{DataTransfer/effectAllowed}}	{{DataTransfer/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 cancelation.
      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 {{DataTransfer/dropEffect}} attribute of the {{DragEvent}} object's {{DragEvent/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 <{input/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 <{input/type}> attribute is in one of the <{input/Text}>, <{input/Search}>, <{input/Telephone}>, <{input/URL}>, <{input/E-mail}>, <{input/Password}>, or <{input/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.

Events summary

The draggable attribute

element . {{HTMLElement/draggable}} [ = value ]

Returns true if the element is draggable; otherwise, returns false. Can be set, to override the default and set the <{global/draggable}> content attribute.

Security risks in the drag-and-drop model