[html5] r6319 - [e] (0) moving sections around
whatwg at whatwg.org
whatwg at whatwg.org
Fri Jul 22 00:23:10 PDT 2011
Author: ianh
Date: 2011-07-22 00:23:08 -0700 (Fri, 22 Jul 2011)
New Revision: 6319
Modified:
complete.html
index
source
Log:
[e] (0) moving sections around
Modified: complete.html
===================================================================
--- complete.html 2011-07-22 07:01:41 UTC (rev 6318)
+++ complete.html 2011-07-22 07:23:08 UTC (rev 6319)
@@ -377,10 +377,10 @@
<li><a href=#htmlpropertiescollection-0><span class=secno>2.8.2.5 </span>HTMLPropertiesCollection</a></ol></li>
<li><a href=#domtokenlist-0><span class=secno>2.8.3 </span>DOMTokenList</a></li>
<li><a href=#domsettabletokenlist-0><span class=secno>2.8.4 </span>DOMSettableTokenList</a></li>
- <li><a href=#transferable-objects><span class=secno>2.8.5 </span>Transferable objects</a></li>
- <li><a href=#safe-passing-of-structured-data><span class=secno>2.8.6 </span>Safe passing of structured data</a></li>
- <li><a href=#domstringmap-0><span class=secno>2.8.7 </span>DOMStringMap</a></li>
- <li><a href=#domelementmap-0><span class=secno>2.8.8 </span>DOMElementMap</a></li>
+ <li><a href=#domstringmap-0><span class=secno>2.8.5 </span>DOMStringMap</a></li>
+ <li><a href=#domelementmap-0><span class=secno>2.8.6 </span>DOMElementMap</a></li>
+ <li><a href=#transferable-objects><span class=secno>2.8.7 </span>Transferable objects</a></li>
+ <li><a href=#safe-passing-of-structured-data><span class=secno>2.8.8 </span>Safe passing of structured data</a></li>
<li><a href=#dom-feature-strings><span class=secno>2.8.9 </span>DOM feature strings</a></li>
<li><a href=#exceptions><span class=secno>2.8.10 </span>Exceptions</a></li>
<li><a href=#garbage-collection><span class=secno>2.8.11 </span>Garbage collection</a></ol></li>
@@ -8645,9 +8645,142 @@
</div>
+ <h4 id=domstringmap-0><span class=secno>2.8.5 </span>DOMStringMap</h4>
- <h4 id=transferable-objects><span class=secno>2.8.5 </span>Transferable objects</h4>
+ <p>The <code><a href=#domstringmap>DOMStringMap</a></code> interface represents a set of
+ name-value pairs. It exposes these using the scripting language's
+ native mechanisms for property access.</p>
+ <div class=impl>
+
+ <p>When a <code><a href=#domstringmap>DOMStringMap</a></code> object is instantiated, it is
+ associated with three algorithms, one for getting the list of
+ name-value pairs, one for setting names to certain values, and one
+ for deleting names.</p>
+
+ <pre class=idl>interface <dfn id=domstringmap>DOMStringMap</dfn> {
+ <a href=#dom-domstringmap-nameditem title=dom-DOMStringMap-namedItem>getter</a> DOMString (in DOMString name);
+ <a href=#dom-domstringmap-setitem title=dom-DOMStringMap-setItem>setter</a> void (in DOMString name, in DOMString value);
+ <a href=#dom-domstringmap-additem title=dom-DOMStringMap-addItem>creator</a> void (in DOMString name, in DOMString value);
+ <a href=#dom-domstringmap-removeitem title=dom-DOMStringMap-removeItem>deleter</a> void (in DOMString name);
+};</pre>
+
+ <p>The <a href=#supported-property-names>supported property names</a> on a
+ <code><a href=#domstringmap>DOMStringMap</a></code> object at any instant are the names of
+ each pair returned from the algorithm for getting the list of
+ name-value pairs at that instant.</p>
+
+ <p>To <dfn id=dom-domstringmap-nameditem title=dom-DOMStringMap-namedItem>determine the value of
+ a named property</dfn> <var title="">name</var> in a
+ <code><a href=#domstringmap>DOMStringMap</a></code>, the user agent must return the value
+ component of the name-value pair whose name component is <var title="">name</var> in the list returned by the algorithm for
+ getting the list of name-value pairs.</p>
+
+ <p>To set the value of a <dfn id=dom-domstringmap-additem title=dom-DOMStringMap-addItem>new</dfn> or <dfn id=dom-domstringmap-setitem title=dom-DOMStringMap-setItem>existing</dfn> named property <var title="">name</var> to value <var title="">value</var>, the
+ algorithm for setting names to certain values must be run, passing
+ <var title="">name</var> as the name and the result of converting
+ <var title="">value</var> to a <code>DOMString</code> as the
+ value.</p>
+
+ <p>To <dfn id=dom-domstringmap-removeitem title=dom-DOMStringMap-removeItem>delete an existing
+ named property</dfn> <var title="">name</var>, the algorithm for
+ deleting names must be run, passing <var title="">name</var> as the
+ name.</p>
+
+ <p class=note>The <code><a href=#domstringmap>DOMStringMap</a></code> interface definition
+ here is only intended for JavaScript environments. Other language
+ bindings will need to define how <code><a href=#domstringmap>DOMStringMap</a></code> is to be
+ implemented for those languages.</p>
+
+ </div>
+
+ <div class=example>
+
+ <p>The <code title=dom-dataset><a href=#dom-dataset>dataset</a></code> attribute on
+ elements exposes the <code title=attr-data-*><a href=#attr-data-*>data-*</a></code>
+ attributes on the element.</p>
+
+ <p>Given the following fragment and elements with similar
+ constructions:</p>
+
+ <pre><img class="tower" id="tower5" data-x="12" data-y="5"
+ data-ai="robotarget" data-hp="46" data-ability="flames"
+ src="towers/rocket.png alt="Rocket Tower"></pre>
+
+ <p>...one could imagine a function <code title="">splashDamage()</code> that takes some arguments, the first
+ of which is the element to process:</p>
+
+ <pre>function splashDamage(node, x, y, damage) {
+ if (node.classList.contains('tower') && // checking the 'class' attribute
+ node.dataset.x == x && // reading the 'data-x' attribute
+ node.dataset.y == y) { // reading the 'data-y' attribute
+ var hp = parseInt(node.dataset.hp); // reading the 'data-hp' attribute
+ hp = hp - damage;
+ if (hp < 0) {
+ hp = 0;
+ node.dataset.ai = 'dead'; // setting the 'data-ai' attribute
+ delete node.dataset.ability; // removing the 'data-ability' attribute
+ }
+ node.dataset.hp = hp; // setting the 'data-hp' attribute
+ }
+}</pre>
+
+ </div>
+
+
+<!--CSSREF-->
+ <h4 id=domelementmap-0><span class=secno>2.8.6 </span>DOMElementMap</h4>
+
+ <p>The <code><a href=#domelementmap>DOMElementMap</a></code> interface represents a set of
+ name-element mappings. It exposes these using the scripting
+ language's native mechanisms for property access.</p>
+
+ <div class=impl>
+
+ <p>When a <code><a href=#domelementmap>DOMElementMap</a></code> object is instantiated, it is
+ associated with three algorithms, one for getting the list of
+ name-element mappings, one for mapping a name to a certain element,
+ and one for deleting mappings by name.</p>
+
+ <pre class=idl>interface <dfn id=domelementmap>DOMElementMap</dfn> {
+ <a href=#dom-domelementmap-nameditem title=dom-DOMElementMap-namedItem>getter</a> DOMString (in DOMString name);
+ <a href=#dom-domelementmap-setitem title=dom-DOMElementMap-setItem>setter</a> void (in DOMString name, in <a href=#element>Element</a> value);
+ <a href=#dom-domelementmap-additem title=dom-DOMElementMap-addItem>creator</a> void (in DOMString name, in <a href=#element>Element</a> value);
+ <a href=#dom-domelementmap-removeitem title=dom-DOMElementMap-removeItem>deleter</a> void (in DOMString name);
+};</pre>
+
+ <p>The <a href=#supported-property-names>supported property names</a> on a
+ <code><a href=#domelementmap>DOMElementMap</a></code> object at any instant are the names for
+ each mapping returned from the algorithm for getting the list of
+ name-element mappings at that instant.</p>
+
+ <p>To <dfn id=dom-domelementmap-nameditem title=dom-DOMElementMap-namedItem>determine the value
+ of a named property</dfn> <var title="">name</var> in a
+ <code><a href=#domelementmap>DOMElementMap</a></code>, the user agent must return the element
+ component of the name-element mapping whose name component is <var title="">name</var> in the list returned by the algorithm for
+ getting the list of name-element mappings.</p>
+
+ <p>To set the value of a <dfn id=dom-domelementmap-additem title=dom-DOMElementMap-addItem>new</dfn> or <dfn id=dom-domelementmap-setitem title=dom-DOMElementMap-setItem>existing</dfn> named property <var title="">name</var> to value <var title="">value</var>, the
+ algorithm for mapping a name to a certain element must be run,
+ passing <var title="">name</var> as the name <var title="">value</var> as the element.</p>
+
+ <p>To <dfn id=dom-domelementmap-removeitem title=dom-DOMElementMap-removeItem>delete an existing
+ named property</dfn> <var title="">name</var>, the algorithm for
+ deleting mappings must be run, passing <var title="">name</var> as
+ the name component of the mapping to be deleted.</p>
+
+ <p class=note>The <code><a href=#domelementmap>DOMElementMap</a></code> interface definition
+ here is only intended for JavaScript environments. Other language
+ bindings will need to define how <code><a href=#domelementmap>DOMElementMap</a></code> is to be
+ implemented for those languages.</p>
+
+ </div>
+<!--CSSREF-->
+
+
+
+ <h4 id=transferable-objects><span class=secno>2.8.7 </span>Transferable objects</h4>
+
<p>Some objects support being copied and closed in one operation.
This is called <i>transferring</i> the object, and is used in
particular to transfer ownership of unsharable or expensive
@@ -8671,9 +8804,9 @@
<ul class=brief><li><code><a href=#messageport>MessagePort</a></code>
<!--<li><code>ArrayBuffer</code>-->
- </ul><div class=impl><!-- should move down two sections XXX -->
+ </ul><div class=impl>
- <h4 id=safe-passing-of-structured-data><span class=secno>2.8.6 </span>Safe passing of structured data</h4>
+ <h4 id=safe-passing-of-structured-data><span class=secno>2.8.8 </span>Safe passing of structured data</h4>
<p>When a user agent is required to obtain a <dfn id=structured-clone>structured
clone</dfn> of a value, optionally with a <i>transfer map</i>, it
@@ -8853,139 +8986,6 @@
</div>
- <h4 id=domstringmap-0><span class=secno>2.8.7 </span>DOMStringMap</h4>
-
- <p>The <code><a href=#domstringmap>DOMStringMap</a></code> interface represents a set of
- name-value pairs. It exposes these using the scripting language's
- native mechanisms for property access.</p>
-
- <div class=impl>
-
- <p>When a <code><a href=#domstringmap>DOMStringMap</a></code> object is instantiated, it is
- associated with three algorithms, one for getting the list of
- name-value pairs, one for setting names to certain values, and one
- for deleting names.</p>
-
- <pre class=idl>interface <dfn id=domstringmap>DOMStringMap</dfn> {
- <a href=#dom-domstringmap-nameditem title=dom-DOMStringMap-namedItem>getter</a> DOMString (in DOMString name);
- <a href=#dom-domstringmap-setitem title=dom-DOMStringMap-setItem>setter</a> void (in DOMString name, in DOMString value);
- <a href=#dom-domstringmap-additem title=dom-DOMStringMap-addItem>creator</a> void (in DOMString name, in DOMString value);
- <a href=#dom-domstringmap-removeitem title=dom-DOMStringMap-removeItem>deleter</a> void (in DOMString name);
-};</pre>
-
- <p>The <a href=#supported-property-names>supported property names</a> on a
- <code><a href=#domstringmap>DOMStringMap</a></code> object at any instant are the names of
- each pair returned from the algorithm for getting the list of
- name-value pairs at that instant.</p>
-
- <p>To <dfn id=dom-domstringmap-nameditem title=dom-DOMStringMap-namedItem>determine the value of
- a named property</dfn> <var title="">name</var> in a
- <code><a href=#domstringmap>DOMStringMap</a></code>, the user agent must return the value
- component of the name-value pair whose name component is <var title="">name</var> in the list returned by the algorithm for
- getting the list of name-value pairs.</p>
-
- <p>To set the value of a <dfn id=dom-domstringmap-additem title=dom-DOMStringMap-addItem>new</dfn> or <dfn id=dom-domstringmap-setitem title=dom-DOMStringMap-setItem>existing</dfn> named property <var title="">name</var> to value <var title="">value</var>, the
- algorithm for setting names to certain values must be run, passing
- <var title="">name</var> as the name and the result of converting
- <var title="">value</var> to a <code>DOMString</code> as the
- value.</p>
-
- <p>To <dfn id=dom-domstringmap-removeitem title=dom-DOMStringMap-removeItem>delete an existing
- named property</dfn> <var title="">name</var>, the algorithm for
- deleting names must be run, passing <var title="">name</var> as the
- name.</p>
-
- <p class=note>The <code><a href=#domstringmap>DOMStringMap</a></code> interface definition
- here is only intended for JavaScript environments. Other language
- bindings will need to define how <code><a href=#domstringmap>DOMStringMap</a></code> is to be
- implemented for those languages.</p>
-
- </div>
-
- <div class=example>
-
- <p>The <code title=dom-dataset><a href=#dom-dataset>dataset</a></code> attribute on
- elements exposes the <code title=attr-data-*><a href=#attr-data-*>data-*</a></code>
- attributes on the element.</p>
-
- <p>Given the following fragment and elements with similar
- constructions:</p>
-
- <pre><img class="tower" id="tower5" data-x="12" data-y="5"
- data-ai="robotarget" data-hp="46" data-ability="flames"
- src="towers/rocket.png alt="Rocket Tower"></pre>
-
- <p>...one could imagine a function <code title="">splashDamage()</code> that takes some arguments, the first
- of which is the element to process:</p>
-
- <pre>function splashDamage(node, x, y, damage) {
- if (node.classList.contains('tower') && // checking the 'class' attribute
- node.dataset.x == x && // reading the 'data-x' attribute
- node.dataset.y == y) { // reading the 'data-y' attribute
- var hp = parseInt(node.dataset.hp); // reading the 'data-hp' attribute
- hp = hp - damage;
- if (hp < 0) {
- hp = 0;
- node.dataset.ai = 'dead'; // setting the 'data-ai' attribute
- delete node.dataset.ability; // removing the 'data-ability' attribute
- }
- node.dataset.hp = hp; // setting the 'data-hp' attribute
- }
-}</pre>
-
- </div>
-
-
-<!--CSSREF-->
- <h4 id=domelementmap-0><span class=secno>2.8.8 </span>DOMElementMap</h4>
-
- <p>The <code><a href=#domelementmap>DOMElementMap</a></code> interface represents a set of
- name-element mappings. It exposes these using the scripting
- language's native mechanisms for property access.</p>
-
- <div class=impl>
-
- <p>When a <code><a href=#domelementmap>DOMElementMap</a></code> object is instantiated, it is
- associated with three algorithms, one for getting the list of
- name-element mappings, one for mapping a name to a certain element,
- and one for deleting mappings by name.</p>
-
- <pre class=idl>interface <dfn id=domelementmap>DOMElementMap</dfn> {
- <a href=#dom-domelementmap-nameditem title=dom-DOMElementMap-namedItem>getter</a> DOMString (in DOMString name);
- <a href=#dom-domelementmap-setitem title=dom-DOMElementMap-setItem>setter</a> void (in DOMString name, in <a href=#element>Element</a> value);
- <a href=#dom-domelementmap-additem title=dom-DOMElementMap-addItem>creator</a> void (in DOMString name, in <a href=#element>Element</a> value);
- <a href=#dom-domelementmap-removeitem title=dom-DOMElementMap-removeItem>deleter</a> void (in DOMString name);
-};</pre>
-
- <p>The <a href=#supported-property-names>supported property names</a> on a
- <code><a href=#domelementmap>DOMElementMap</a></code> object at any instant are the names for
- each mapping returned from the algorithm for getting the list of
- name-element mappings at that instant.</p>
-
- <p>To <dfn id=dom-domelementmap-nameditem title=dom-DOMElementMap-namedItem>determine the value
- of a named property</dfn> <var title="">name</var> in a
- <code><a href=#domelementmap>DOMElementMap</a></code>, the user agent must return the element
- component of the name-element mapping whose name component is <var title="">name</var> in the list returned by the algorithm for
- getting the list of name-element mappings.</p>
-
- <p>To set the value of a <dfn id=dom-domelementmap-additem title=dom-DOMElementMap-addItem>new</dfn> or <dfn id=dom-domelementmap-setitem title=dom-DOMElementMap-setItem>existing</dfn> named property <var title="">name</var> to value <var title="">value</var>, the
- algorithm for mapping a name to a certain element must be run,
- passing <var title="">name</var> as the name <var title="">value</var> as the element.</p>
-
- <p>To <dfn id=dom-domelementmap-removeitem title=dom-DOMElementMap-removeItem>delete an existing
- named property</dfn> <var title="">name</var>, the algorithm for
- deleting mappings must be run, passing <var title="">name</var> as
- the name component of the mapping to be deleted.</p>
-
- <p class=note>The <code><a href=#domelementmap>DOMElementMap</a></code> interface definition
- here is only intended for JavaScript environments. Other language
- bindings will need to define how <code><a href=#domelementmap>DOMElementMap</a></code> is to be
- implemented for those languages.</p>
-
- </div>
-<!--CSSREF-->
-
-
<h4 id=dom-feature-strings><span class=secno>2.8.9 </span>DOM feature strings</h4>
<p>DOM3 Core defines mechanisms for checking for interface support,
Modified: index
===================================================================
--- index 2011-07-22 07:01:41 UTC (rev 6318)
+++ index 2011-07-22 07:23:08 UTC (rev 6319)
@@ -377,10 +377,10 @@
<li><a href=#htmlpropertiescollection-0><span class=secno>2.8.2.5 </span>HTMLPropertiesCollection</a></ol></li>
<li><a href=#domtokenlist-0><span class=secno>2.8.3 </span>DOMTokenList</a></li>
<li><a href=#domsettabletokenlist-0><span class=secno>2.8.4 </span>DOMSettableTokenList</a></li>
- <li><a href=#transferable-objects><span class=secno>2.8.5 </span>Transferable objects</a></li>
- <li><a href=#safe-passing-of-structured-data><span class=secno>2.8.6 </span>Safe passing of structured data</a></li>
- <li><a href=#domstringmap-0><span class=secno>2.8.7 </span>DOMStringMap</a></li>
- <li><a href=#domelementmap-0><span class=secno>2.8.8 </span>DOMElementMap</a></li>
+ <li><a href=#domstringmap-0><span class=secno>2.8.5 </span>DOMStringMap</a></li>
+ <li><a href=#domelementmap-0><span class=secno>2.8.6 </span>DOMElementMap</a></li>
+ <li><a href=#transferable-objects><span class=secno>2.8.7 </span>Transferable objects</a></li>
+ <li><a href=#safe-passing-of-structured-data><span class=secno>2.8.8 </span>Safe passing of structured data</a></li>
<li><a href=#dom-feature-strings><span class=secno>2.8.9 </span>DOM feature strings</a></li>
<li><a href=#exceptions><span class=secno>2.8.10 </span>Exceptions</a></li>
<li><a href=#garbage-collection><span class=secno>2.8.11 </span>Garbage collection</a></ol></li>
@@ -8514,9 +8514,142 @@
</div>
+ <h4 id=domstringmap-0><span class=secno>2.8.5 </span>DOMStringMap</h4>
- <h4 id=transferable-objects><span class=secno>2.8.5 </span>Transferable objects</h4>
+ <p>The <code><a href=#domstringmap>DOMStringMap</a></code> interface represents a set of
+ name-value pairs. It exposes these using the scripting language's
+ native mechanisms for property access.</p>
+ <div class=impl>
+
+ <p>When a <code><a href=#domstringmap>DOMStringMap</a></code> object is instantiated, it is
+ associated with three algorithms, one for getting the list of
+ name-value pairs, one for setting names to certain values, and one
+ for deleting names.</p>
+
+ <pre class=idl>interface <dfn id=domstringmap>DOMStringMap</dfn> {
+ <a href=#dom-domstringmap-nameditem title=dom-DOMStringMap-namedItem>getter</a> DOMString (in DOMString name);
+ <a href=#dom-domstringmap-setitem title=dom-DOMStringMap-setItem>setter</a> void (in DOMString name, in DOMString value);
+ <a href=#dom-domstringmap-additem title=dom-DOMStringMap-addItem>creator</a> void (in DOMString name, in DOMString value);
+ <a href=#dom-domstringmap-removeitem title=dom-DOMStringMap-removeItem>deleter</a> void (in DOMString name);
+};</pre>
+
+ <p>The <a href=#supported-property-names>supported property names</a> on a
+ <code><a href=#domstringmap>DOMStringMap</a></code> object at any instant are the names of
+ each pair returned from the algorithm for getting the list of
+ name-value pairs at that instant.</p>
+
+ <p>To <dfn id=dom-domstringmap-nameditem title=dom-DOMStringMap-namedItem>determine the value of
+ a named property</dfn> <var title="">name</var> in a
+ <code><a href=#domstringmap>DOMStringMap</a></code>, the user agent must return the value
+ component of the name-value pair whose name component is <var title="">name</var> in the list returned by the algorithm for
+ getting the list of name-value pairs.</p>
+
+ <p>To set the value of a <dfn id=dom-domstringmap-additem title=dom-DOMStringMap-addItem>new</dfn> or <dfn id=dom-domstringmap-setitem title=dom-DOMStringMap-setItem>existing</dfn> named property <var title="">name</var> to value <var title="">value</var>, the
+ algorithm for setting names to certain values must be run, passing
+ <var title="">name</var> as the name and the result of converting
+ <var title="">value</var> to a <code>DOMString</code> as the
+ value.</p>
+
+ <p>To <dfn id=dom-domstringmap-removeitem title=dom-DOMStringMap-removeItem>delete an existing
+ named property</dfn> <var title="">name</var>, the algorithm for
+ deleting names must be run, passing <var title="">name</var> as the
+ name.</p>
+
+ <p class=note>The <code><a href=#domstringmap>DOMStringMap</a></code> interface definition
+ here is only intended for JavaScript environments. Other language
+ bindings will need to define how <code><a href=#domstringmap>DOMStringMap</a></code> is to be
+ implemented for those languages.</p>
+
+ </div>
+
+ <div class=example>
+
+ <p>The <code title=dom-dataset><a href=#dom-dataset>dataset</a></code> attribute on
+ elements exposes the <code title=attr-data-*><a href=#attr-data-*>data-*</a></code>
+ attributes on the element.</p>
+
+ <p>Given the following fragment and elements with similar
+ constructions:</p>
+
+ <pre><img class="tower" id="tower5" data-x="12" data-y="5"
+ data-ai="robotarget" data-hp="46" data-ability="flames"
+ src="towers/rocket.png alt="Rocket Tower"></pre>
+
+ <p>...one could imagine a function <code title="">splashDamage()</code> that takes some arguments, the first
+ of which is the element to process:</p>
+
+ <pre>function splashDamage(node, x, y, damage) {
+ if (node.classList.contains('tower') && // checking the 'class' attribute
+ node.dataset.x == x && // reading the 'data-x' attribute
+ node.dataset.y == y) { // reading the 'data-y' attribute
+ var hp = parseInt(node.dataset.hp); // reading the 'data-hp' attribute
+ hp = hp - damage;
+ if (hp < 0) {
+ hp = 0;
+ node.dataset.ai = 'dead'; // setting the 'data-ai' attribute
+ delete node.dataset.ability; // removing the 'data-ability' attribute
+ }
+ node.dataset.hp = hp; // setting the 'data-hp' attribute
+ }
+}</pre>
+
+ </div>
+
+
+<!--CSSREF-->
+ <h4 id=domelementmap-0><span class=secno>2.8.6 </span>DOMElementMap</h4>
+
+ <p>The <code><a href=#domelementmap>DOMElementMap</a></code> interface represents a set of
+ name-element mappings. It exposes these using the scripting
+ language's native mechanisms for property access.</p>
+
+ <div class=impl>
+
+ <p>When a <code><a href=#domelementmap>DOMElementMap</a></code> object is instantiated, it is
+ associated with three algorithms, one for getting the list of
+ name-element mappings, one for mapping a name to a certain element,
+ and one for deleting mappings by name.</p>
+
+ <pre class=idl>interface <dfn id=domelementmap>DOMElementMap</dfn> {
+ <a href=#dom-domelementmap-nameditem title=dom-DOMElementMap-namedItem>getter</a> DOMString (in DOMString name);
+ <a href=#dom-domelementmap-setitem title=dom-DOMElementMap-setItem>setter</a> void (in DOMString name, in <a href=#element>Element</a> value);
+ <a href=#dom-domelementmap-additem title=dom-DOMElementMap-addItem>creator</a> void (in DOMString name, in <a href=#element>Element</a> value);
+ <a href=#dom-domelementmap-removeitem title=dom-DOMElementMap-removeItem>deleter</a> void (in DOMString name);
+};</pre>
+
+ <p>The <a href=#supported-property-names>supported property names</a> on a
+ <code><a href=#domelementmap>DOMElementMap</a></code> object at any instant are the names for
+ each mapping returned from the algorithm for getting the list of
+ name-element mappings at that instant.</p>
+
+ <p>To <dfn id=dom-domelementmap-nameditem title=dom-DOMElementMap-namedItem>determine the value
+ of a named property</dfn> <var title="">name</var> in a
+ <code><a href=#domelementmap>DOMElementMap</a></code>, the user agent must return the element
+ component of the name-element mapping whose name component is <var title="">name</var> in the list returned by the algorithm for
+ getting the list of name-element mappings.</p>
+
+ <p>To set the value of a <dfn id=dom-domelementmap-additem title=dom-DOMElementMap-addItem>new</dfn> or <dfn id=dom-domelementmap-setitem title=dom-DOMElementMap-setItem>existing</dfn> named property <var title="">name</var> to value <var title="">value</var>, the
+ algorithm for mapping a name to a certain element must be run,
+ passing <var title="">name</var> as the name <var title="">value</var> as the element.</p>
+
+ <p>To <dfn id=dom-domelementmap-removeitem title=dom-DOMElementMap-removeItem>delete an existing
+ named property</dfn> <var title="">name</var>, the algorithm for
+ deleting mappings must be run, passing <var title="">name</var> as
+ the name component of the mapping to be deleted.</p>
+
+ <p class=note>The <code><a href=#domelementmap>DOMElementMap</a></code> interface definition
+ here is only intended for JavaScript environments. Other language
+ bindings will need to define how <code><a href=#domelementmap>DOMElementMap</a></code> is to be
+ implemented for those languages.</p>
+
+ </div>
+<!--CSSREF-->
+
+
+
+ <h4 id=transferable-objects><span class=secno>2.8.7 </span>Transferable objects</h4>
+
<p>Some objects support being copied and closed in one operation.
This is called <i>transferring</i> the object, and is used in
particular to transfer ownership of unsharable or expensive
@@ -8540,9 +8673,9 @@
<ul class=brief><li><code><a href=#messageport>MessagePort</a></code>
<!--<li><code>ArrayBuffer</code>-->
- </ul><div class=impl><!-- should move down two sections XXX -->
+ </ul><div class=impl>
- <h4 id=safe-passing-of-structured-data><span class=secno>2.8.6 </span>Safe passing of structured data</h4>
+ <h4 id=safe-passing-of-structured-data><span class=secno>2.8.8 </span>Safe passing of structured data</h4>
<p>When a user agent is required to obtain a <dfn id=structured-clone>structured
clone</dfn> of a value, optionally with a <i>transfer map</i>, it
@@ -8722,139 +8855,6 @@
</div>
- <h4 id=domstringmap-0><span class=secno>2.8.7 </span>DOMStringMap</h4>
-
- <p>The <code><a href=#domstringmap>DOMStringMap</a></code> interface represents a set of
- name-value pairs. It exposes these using the scripting language's
- native mechanisms for property access.</p>
-
- <div class=impl>
-
- <p>When a <code><a href=#domstringmap>DOMStringMap</a></code> object is instantiated, it is
- associated with three algorithms, one for getting the list of
- name-value pairs, one for setting names to certain values, and one
- for deleting names.</p>
-
- <pre class=idl>interface <dfn id=domstringmap>DOMStringMap</dfn> {
- <a href=#dom-domstringmap-nameditem title=dom-DOMStringMap-namedItem>getter</a> DOMString (in DOMString name);
- <a href=#dom-domstringmap-setitem title=dom-DOMStringMap-setItem>setter</a> void (in DOMString name, in DOMString value);
- <a href=#dom-domstringmap-additem title=dom-DOMStringMap-addItem>creator</a> void (in DOMString name, in DOMString value);
- <a href=#dom-domstringmap-removeitem title=dom-DOMStringMap-removeItem>deleter</a> void (in DOMString name);
-};</pre>
-
- <p>The <a href=#supported-property-names>supported property names</a> on a
- <code><a href=#domstringmap>DOMStringMap</a></code> object at any instant are the names of
- each pair returned from the algorithm for getting the list of
- name-value pairs at that instant.</p>
-
- <p>To <dfn id=dom-domstringmap-nameditem title=dom-DOMStringMap-namedItem>determine the value of
- a named property</dfn> <var title="">name</var> in a
- <code><a href=#domstringmap>DOMStringMap</a></code>, the user agent must return the value
- component of the name-value pair whose name component is <var title="">name</var> in the list returned by the algorithm for
- getting the list of name-value pairs.</p>
-
- <p>To set the value of a <dfn id=dom-domstringmap-additem title=dom-DOMStringMap-addItem>new</dfn> or <dfn id=dom-domstringmap-setitem title=dom-DOMStringMap-setItem>existing</dfn> named property <var title="">name</var> to value <var title="">value</var>, the
- algorithm for setting names to certain values must be run, passing
- <var title="">name</var> as the name and the result of converting
- <var title="">value</var> to a <code>DOMString</code> as the
- value.</p>
-
- <p>To <dfn id=dom-domstringmap-removeitem title=dom-DOMStringMap-removeItem>delete an existing
- named property</dfn> <var title="">name</var>, the algorithm for
- deleting names must be run, passing <var title="">name</var> as the
- name.</p>
-
- <p class=note>The <code><a href=#domstringmap>DOMStringMap</a></code> interface definition
- here is only intended for JavaScript environments. Other language
- bindings will need to define how <code><a href=#domstringmap>DOMStringMap</a></code> is to be
- implemented for those languages.</p>
-
- </div>
-
- <div class=example>
-
- <p>The <code title=dom-dataset><a href=#dom-dataset>dataset</a></code> attribute on
- elements exposes the <code title=attr-data-*><a href=#attr-data-*>data-*</a></code>
- attributes on the element.</p>
-
- <p>Given the following fragment and elements with similar
- constructions:</p>
-
- <pre><img class="tower" id="tower5" data-x="12" data-y="5"
- data-ai="robotarget" data-hp="46" data-ability="flames"
- src="towers/rocket.png alt="Rocket Tower"></pre>
-
- <p>...one could imagine a function <code title="">splashDamage()</code> that takes some arguments, the first
- of which is the element to process:</p>
-
- <pre>function splashDamage(node, x, y, damage) {
- if (node.classList.contains('tower') && // checking the 'class' attribute
- node.dataset.x == x && // reading the 'data-x' attribute
- node.dataset.y == y) { // reading the 'data-y' attribute
- var hp = parseInt(node.dataset.hp); // reading the 'data-hp' attribute
- hp = hp - damage;
- if (hp < 0) {
- hp = 0;
- node.dataset.ai = 'dead'; // setting the 'data-ai' attribute
- delete node.dataset.ability; // removing the 'data-ability' attribute
- }
- node.dataset.hp = hp; // setting the 'data-hp' attribute
- }
-}</pre>
-
- </div>
-
-
-<!--CSSREF-->
- <h4 id=domelementmap-0><span class=secno>2.8.8 </span>DOMElementMap</h4>
-
- <p>The <code><a href=#domelementmap>DOMElementMap</a></code> interface represents a set of
- name-element mappings. It exposes these using the scripting
- language's native mechanisms for property access.</p>
-
- <div class=impl>
-
- <p>When a <code><a href=#domelementmap>DOMElementMap</a></code> object is instantiated, it is
- associated with three algorithms, one for getting the list of
- name-element mappings, one for mapping a name to a certain element,
- and one for deleting mappings by name.</p>
-
- <pre class=idl>interface <dfn id=domelementmap>DOMElementMap</dfn> {
- <a href=#dom-domelementmap-nameditem title=dom-DOMElementMap-namedItem>getter</a> DOMString (in DOMString name);
- <a href=#dom-domelementmap-setitem title=dom-DOMElementMap-setItem>setter</a> void (in DOMString name, in <a href=#element>Element</a> value);
- <a href=#dom-domelementmap-additem title=dom-DOMElementMap-addItem>creator</a> void (in DOMString name, in <a href=#element>Element</a> value);
- <a href=#dom-domelementmap-removeitem title=dom-DOMElementMap-removeItem>deleter</a> void (in DOMString name);
-};</pre>
-
- <p>The <a href=#supported-property-names>supported property names</a> on a
- <code><a href=#domelementmap>DOMElementMap</a></code> object at any instant are the names for
- each mapping returned from the algorithm for getting the list of
- name-element mappings at that instant.</p>
-
- <p>To <dfn id=dom-domelementmap-nameditem title=dom-DOMElementMap-namedItem>determine the value
- of a named property</dfn> <var title="">name</var> in a
- <code><a href=#domelementmap>DOMElementMap</a></code>, the user agent must return the element
- component of the name-element mapping whose name component is <var title="">name</var> in the list returned by the algorithm for
- getting the list of name-element mappings.</p>
-
- <p>To set the value of a <dfn id=dom-domelementmap-additem title=dom-DOMElementMap-addItem>new</dfn> or <dfn id=dom-domelementmap-setitem title=dom-DOMElementMap-setItem>existing</dfn> named property <var title="">name</var> to value <var title="">value</var>, the
- algorithm for mapping a name to a certain element must be run,
- passing <var title="">name</var> as the name <var title="">value</var> as the element.</p>
-
- <p>To <dfn id=dom-domelementmap-removeitem title=dom-DOMElementMap-removeItem>delete an existing
- named property</dfn> <var title="">name</var>, the algorithm for
- deleting mappings must be run, passing <var title="">name</var> as
- the name component of the mapping to be deleted.</p>
-
- <p class=note>The <code><a href=#domelementmap>DOMElementMap</a></code> interface definition
- here is only intended for JavaScript environments. Other language
- bindings will need to define how <code><a href=#domelementmap>DOMElementMap</a></code> is to be
- implemented for those languages.</p>
-
- </div>
-<!--CSSREF-->
-
-
<h4 id=dom-feature-strings><span class=secno>2.8.9 </span>DOM feature strings</h4>
<p>DOM3 Core defines mechanisms for checking for interface support,
Modified: source
===================================================================
--- source 2011-07-22 07:01:41 UTC (rev 6318)
+++ source 2011-07-22 07:23:08 UTC (rev 6319)
@@ -8620,7 +8620,150 @@
</div>
+ <h4>DOMStringMap</h4>
+ <p>The <code>DOMStringMap</code> interface represents a set of
+ name-value pairs. It exposes these using the scripting language's
+ native mechanisms for property access.</p>
+
+ <div class="impl">
+
+ <p>When a <code>DOMStringMap</code> object is instantiated, it is
+ associated with three algorithms, one for getting the list of
+ name-value pairs, one for setting names to certain values, and one
+ for deleting names.</p>
+
+ <pre class="idl">interface <dfn>DOMStringMap</dfn> {
+ <span title="dom-DOMStringMap-namedItem">getter</span> DOMString (in DOMString name);
+ <span title="dom-DOMStringMap-setItem">setter</span> void (in DOMString name, in DOMString value);
+ <span title="dom-DOMStringMap-addItem">creator</span> void (in DOMString name, in DOMString value);
+ <span title="dom-DOMStringMap-removeItem">deleter</span> void (in DOMString name);
+};</pre>
+
+ <p>The <span>supported property names</span> on a
+ <code>DOMStringMap</code> object at any instant are the names of
+ each pair returned from the algorithm for getting the list of
+ name-value pairs at that instant.</p>
+
+ <p>To <dfn title="dom-DOMStringMap-namedItem">determine the value of
+ a named property</dfn> <var title="">name</var> in a
+ <code>DOMStringMap</code>, the user agent must return the value
+ component of the name-value pair whose name component is <var
+ title="">name</var> in the list returned by the algorithm for
+ getting the list of name-value pairs.</p>
+
+ <p>To set the value of a <dfn
+ title="dom-DOMStringMap-addItem">new</dfn> or <dfn
+ title="dom-DOMStringMap-setItem">existing</dfn> named property <var
+ title="">name</var> to value <var title="">value</var>, the
+ algorithm for setting names to certain values must be run, passing
+ <var title="">name</var> as the name and the result of converting
+ <var title="">value</var> to a <code>DOMString</code> as the
+ value.</p>
+
+ <p>To <dfn title="dom-DOMStringMap-removeItem">delete an existing
+ named property</dfn> <var title="">name</var>, the algorithm for
+ deleting names must be run, passing <var title="">name</var> as the
+ name.</p>
+
+ <p class="note">The <code>DOMStringMap</code> interface definition
+ here is only intended for JavaScript environments. Other language
+ bindings will need to define how <code>DOMStringMap</code> is to be
+ implemented for those languages.</p>
+
+ </div>
+
+ <div class="example">
+
+ <p>The <code title="dom-dataset">dataset</code> attribute on
+ elements exposes the <code title="attr-data-*">data-*</code>
+ attributes on the element.</p>
+
+ <p>Given the following fragment and elements with similar
+ constructions:</p>
+
+ <pre><img class="tower" id="tower5" data-x="12" data-y="5"
+ data-ai="robotarget" data-hp="46" data-ability="flames"
+ src="towers/rocket.png alt="Rocket Tower"></pre>
+
+ <p>...one could imagine a function <code
+ title="">splashDamage()</code> that takes some arguments, the first
+ of which is the element to process:</p>
+
+ <pre>function splashDamage(node, x, y, damage) {
+ if (node.classList.contains('tower') && // checking the 'class' attribute
+ node.dataset.x == x && // reading the 'data-x' attribute
+ node.dataset.y == y) { // reading the 'data-y' attribute
+ var hp = parseInt(node.dataset.hp); // reading the 'data-hp' attribute
+ hp = hp - damage;
+ if (hp < 0) {
+ hp = 0;
+ node.dataset.ai = 'dead'; // setting the 'data-ai' attribute
+ delete node.dataset.ability; // removing the 'data-ability' attribute
+ }
+ node.dataset.hp = hp; // setting the 'data-hp' attribute
+ }
+}</pre>
+
+ </div>
+
+
+<!--END w3c-html--><!--CSSREF-->
+ <h4>DOMElementMap</h4>
+
+ <p>The <code>DOMElementMap</code> interface represents a set of
+ name-element mappings. It exposes these using the scripting
+ language's native mechanisms for property access.</p>
+
+ <div class="impl">
+
+ <p>When a <code>DOMElementMap</code> object is instantiated, it is
+ associated with three algorithms, one for getting the list of
+ name-element mappings, one for mapping a name to a certain element,
+ and one for deleting mappings by name.</p>
+
+ <pre class="idl">interface <dfn>DOMElementMap</dfn> {
+ <span title="dom-DOMElementMap-namedItem">getter</span> DOMString (in DOMString name);
+ <span title="dom-DOMElementMap-setItem">setter</span> void (in DOMString name, in <span>Element</span> value);
+ <span title="dom-DOMElementMap-addItem">creator</span> void (in DOMString name, in <span>Element</span> value);
+ <span title="dom-DOMElementMap-removeItem">deleter</span> void (in DOMString name);
+};</pre>
+
+ <p>The <span>supported property names</span> on a
+ <code>DOMElementMap</code> object at any instant are the names for
+ each mapping returned from the algorithm for getting the list of
+ name-element mappings at that instant.</p>
+
+ <p>To <dfn title="dom-DOMElementMap-namedItem">determine the value
+ of a named property</dfn> <var title="">name</var> in a
+ <code>DOMElementMap</code>, the user agent must return the element
+ component of the name-element mapping whose name component is <var
+ title="">name</var> in the list returned by the algorithm for
+ getting the list of name-element mappings.</p>
+
+ <p>To set the value of a <dfn
+ title="dom-DOMElementMap-addItem">new</dfn> or <dfn
+ title="dom-DOMElementMap-setItem">existing</dfn> named property <var
+ title="">name</var> to value <var title="">value</var>, the
+ algorithm for mapping a name to a certain element must be run,
+ passing <var title="">name</var> as the name <var
+ title="">value</var> as the element.</p>
+
+ <p>To <dfn title="dom-DOMElementMap-removeItem">delete an existing
+ named property</dfn> <var title="">name</var>, the algorithm for
+ deleting mappings must be run, passing <var title="">name</var> as
+ the name component of the mapping to be deleted.</p>
+
+ <p class="note">The <code>DOMElementMap</code> interface definition
+ here is only intended for JavaScript environments. Other language
+ bindings will need to define how <code>DOMElementMap</code> is to be
+ implemented for those languages.</p>
+
+ </div>
+<!--START w3c-html--><!--CSSREF-->
+
+
+
<h4>Transferable objects</h4>
<p>Some objects support being copied and closed in one operation.
@@ -8650,7 +8793,7 @@
</ul>
- <div class="impl"><!-- should move down two sections XXX -->
+ <div class="impl">
<h4>Safe passing of structured data</h4>
@@ -8856,149 +8999,6 @@
</div>
- <h4>DOMStringMap</h4>
-
- <p>The <code>DOMStringMap</code> interface represents a set of
- name-value pairs. It exposes these using the scripting language's
- native mechanisms for property access.</p>
-
- <div class="impl">
-
- <p>When a <code>DOMStringMap</code> object is instantiated, it is
- associated with three algorithms, one for getting the list of
- name-value pairs, one for setting names to certain values, and one
- for deleting names.</p>
-
- <pre class="idl">interface <dfn>DOMStringMap</dfn> {
- <span title="dom-DOMStringMap-namedItem">getter</span> DOMString (in DOMString name);
- <span title="dom-DOMStringMap-setItem">setter</span> void (in DOMString name, in DOMString value);
- <span title="dom-DOMStringMap-addItem">creator</span> void (in DOMString name, in DOMString value);
- <span title="dom-DOMStringMap-removeItem">deleter</span> void (in DOMString name);
-};</pre>
-
- <p>The <span>supported property names</span> on a
- <code>DOMStringMap</code> object at any instant are the names of
- each pair returned from the algorithm for getting the list of
- name-value pairs at that instant.</p>
-
- <p>To <dfn title="dom-DOMStringMap-namedItem">determine the value of
- a named property</dfn> <var title="">name</var> in a
- <code>DOMStringMap</code>, the user agent must return the value
- component of the name-value pair whose name component is <var
- title="">name</var> in the list returned by the algorithm for
- getting the list of name-value pairs.</p>
-
- <p>To set the value of a <dfn
- title="dom-DOMStringMap-addItem">new</dfn> or <dfn
- title="dom-DOMStringMap-setItem">existing</dfn> named property <var
- title="">name</var> to value <var title="">value</var>, the
- algorithm for setting names to certain values must be run, passing
- <var title="">name</var> as the name and the result of converting
- <var title="">value</var> to a <code>DOMString</code> as the
- value.</p>
-
- <p>To <dfn title="dom-DOMStringMap-removeItem">delete an existing
- named property</dfn> <var title="">name</var>, the algorithm for
- deleting names must be run, passing <var title="">name</var> as the
- name.</p>
-
- <p class="note">The <code>DOMStringMap</code> interface definition
- here is only intended for JavaScript environments. Other language
- bindings will need to define how <code>DOMStringMap</code> is to be
- implemented for those languages.</p>
-
- </div>
-
- <div class="example">
-
- <p>The <code title="dom-dataset">dataset</code> attribute on
- elements exposes the <code title="attr-data-*">data-*</code>
- attributes on the element.</p>
-
- <p>Given the following fragment and elements with similar
- constructions:</p>
-
- <pre><img class="tower" id="tower5" data-x="12" data-y="5"
- data-ai="robotarget" data-hp="46" data-ability="flames"
- src="towers/rocket.png alt="Rocket Tower"></pre>
-
- <p>...one could imagine a function <code
- title="">splashDamage()</code> that takes some arguments, the first
- of which is the element to process:</p>
-
- <pre>function splashDamage(node, x, y, damage) {
- if (node.classList.contains('tower') && // checking the 'class' attribute
- node.dataset.x == x && // reading the 'data-x' attribute
- node.dataset.y == y) { // reading the 'data-y' attribute
- var hp = parseInt(node.dataset.hp); // reading the 'data-hp' attribute
- hp = hp - damage;
- if (hp < 0) {
- hp = 0;
- node.dataset.ai = 'dead'; // setting the 'data-ai' attribute
- delete node.dataset.ability; // removing the 'data-ability' attribute
- }
- node.dataset.hp = hp; // setting the 'data-hp' attribute
- }
-}</pre>
-
- </div>
-
-
-<!--END w3c-html--><!--CSSREF-->
- <h4>DOMElementMap</h4>
-
- <p>The <code>DOMElementMap</code> interface represents a set of
- name-element mappings. It exposes these using the scripting
- language's native mechanisms for property access.</p>
-
- <div class="impl">
-
- <p>When a <code>DOMElementMap</code> object is instantiated, it is
- associated with three algorithms, one for getting the list of
- name-element mappings, one for mapping a name to a certain element,
- and one for deleting mappings by name.</p>
-
- <pre class="idl">interface <dfn>DOMElementMap</dfn> {
- <span title="dom-DOMElementMap-namedItem">getter</span> DOMString (in DOMString name);
- <span title="dom-DOMElementMap-setItem">setter</span> void (in DOMString name, in <span>Element</span> value);
- <span title="dom-DOMElementMap-addItem">creator</span> void (in DOMString name, in <span>Element</span> value);
- <span title="dom-DOMElementMap-removeItem">deleter</span> void (in DOMString name);
-};</pre>
-
- <p>The <span>supported property names</span> on a
- <code>DOMElementMap</code> object at any instant are the names for
- each mapping returned from the algorithm for getting the list of
- name-element mappings at that instant.</p>
-
- <p>To <dfn title="dom-DOMElementMap-namedItem">determine the value
- of a named property</dfn> <var title="">name</var> in a
- <code>DOMElementMap</code>, the user agent must return the element
- component of the name-element mapping whose name component is <var
- title="">name</var> in the list returned by the algorithm for
- getting the list of name-element mappings.</p>
-
- <p>To set the value of a <dfn
- title="dom-DOMElementMap-addItem">new</dfn> or <dfn
- title="dom-DOMElementMap-setItem">existing</dfn> named property <var
- title="">name</var> to value <var title="">value</var>, the
- algorithm for mapping a name to a certain element must be run,
- passing <var title="">name</var> as the name <var
- title="">value</var> as the element.</p>
-
- <p>To <dfn title="dom-DOMElementMap-removeItem">delete an existing
- named property</dfn> <var title="">name</var>, the algorithm for
- deleting mappings must be run, passing <var title="">name</var> as
- the name component of the mapping to be deleted.</p>
-
- <p class="note">The <code>DOMElementMap</code> interface definition
- here is only intended for JavaScript environments. Other language
- bindings will need to define how <code>DOMElementMap</code> is to be
- implemented for those languages.</p>
-
- </div>
-<!--START w3c-html--><!--CSSREF-->
-
-
<h4>DOM feature strings</h4>
<p>DOM3 Core defines mechanisms for checking for interface support,
More information about the Commit-Watchers
mailing list