Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="exml:ext.data" xmlns:ed="exml:ext.data" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:exml="http://www.jangaroo.net/exml/0.8" xmlns:eu="exml:ext.util" >
  <xs:import namespace="http://www.jangaroo.net/exml/0.8"/>
  <xs:import namespace="exml:ext.util"/>
  <xs:complexType name='ArrayReader_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:JsonReader_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:attribute type='exml:Number' name='id'>
          <xs:annotation>
            <xs:documentation>
              The subscript within row Array that provides an ID for the Record. Deprecated. Use <a href="output/Ext.data.ArrayReader.html#Ext.data.ArrayReader-idIndex">idIndex</a> instead.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Number' name='idIndex'>
          <xs:annotation>
            <xs:documentation>
              The subscript within row Array that provides an ID for the Record.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='ArrayReader' type='ed:ArrayReader_TYPE' substitutionGroup='ed:JsonReader'>
    <xs:annotation>
      <xs:documentation>
        Data reader class to create an Array of <a href="Ext.data.Record.html">Ext.data.Record</a> objects from an Array. Each element of that Array represents a row of data fields. The fields are pulled into a Record object using as a subscript, the <code>mapping</code> property of the field definition if it exists, or the field's ordinal position in the definition. <p>Example code:</p><pre><code>var Employee = Ext.data.Record.create([ {name: 'name', mapping: 1}, // "mapping" only needed if an "id" field is present which {name: 'occupation', mapping: 2} // precludes using the ordinal position as the index. ]); var myReader = new Ext.data.ArrayReader({ <a href="output/Ext.data.ArrayReader.html#Ext.data.ArrayReader-idIndex">idIndex</a>: 0 }, Employee); </code></pre><p>This would consume an Array like this:</p><pre><code>[ [1, 'Bill', 'Gardener'], [2, 'Ben', 'Horticulturalist'] ] </code></pre> <p>This class serves as a typed config object for constructor of class ArrayReader.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.ArrayReader
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='ArrayStore_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:Store_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='ArrayStore' type='ed:ArrayStore_TYPE' substitutionGroup='ed:Store'>
    <xs:annotation>
      <xs:documentation>
        Formerly known as "SimpleStore". <p>Small helper class to make creating <a href="Ext.data.Store.html">Ext.data.Store</a>s from Array data easier. An ArrayStore will be automatically configured with a <a href="Ext.data.ArrayReader.html">Ext.data.ArrayReader</a>.</p><p>A store configuration would be something like:</p><pre><code>var store = new Ext.data.ArrayStore({ // store configs autoDestroy: true, storeId: 'myStore', // reader configs idIndex: 0, fields: [ 'company', {name: 'price', type: 'float'}, {name: 'change', type: 'float'}, {name: 'pctChange', type: 'float'}, {name: 'lastChange', type: 'date', dateFormat: 'n/j h:ia'} ] }); </code></pre><br/><br/> <p>This store is configured to consume a returned object of the form:</p><pre><code>var myData = [ ['3m Co',71.72,0.02,0.03,'9/1 12:00am'], ['Alcoa Inc',29.01,0.42,1.47,'9/1 12:00am'], ['Boeing Co.',75.43,0.53,0.71,'9/1 12:00am'], ['Hewlett-Packard Co.',36.53,-0.03,-0.08,'9/1 12:00am'], ['Wal-Mart Stores, Inc.',45.45,0.73,1.63,'9/1 12:00am'] ]; </code></pre>An object literal of this form could also be used as the <a href="output/Ext.data.ArrayStore.html#Ext.data.ArrayStore-data">data</a> config option.<br/><br/> <p><b>&#42;Note:</b> Although not listed here, this class accepts all of the configuration options of <b><a href="Ext.data.ArrayReader.html">ArrayReader</a></b>.</p> <p>This class serves as a typed config object for constructor of class ArrayStore.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.ArrayStore
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='Connection_TYPE'>
    <xs:complexContent>
      <xs:extension base='eu:Observable_TYPE'>
        <xs:sequence>
            <xs:element name='defaultHeaders' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  An object containing request headers which are added to each request made by this object. (defaults to undefined)
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='extraParams' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  An object containing properties which are used as extra parameters to each request made by this object. (defaults to undefined)
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:Boolean' name='autoAbort'>
          <xs:annotation>
            <xs:documentation>
              Whether this request should abort any pending requests. (defaults to false)
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='defaultHeaders'>
          <xs:annotation>
            <xs:documentation>
              An object containing request headers which are added to each request made by this object. (defaults to undefined)
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='disableCaching'>
          <xs:annotation>
            <xs:documentation>
              True to add a unique cache-buster param to GET requests. (defaults to true)
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='disableCachingParam'>
          <xs:annotation>
            <xs:documentation>
              Change the parameter which is sent went disabling caching through a cache buster. Defaults to '_dc'
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='extraParams'>
          <xs:annotation>
            <xs:documentation>
              An object containing properties which are used as extra parameters to each request made by this object. (defaults to undefined)
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='method'>
          <xs:annotation>
            <xs:documentation>
              The default HTTP method to be used for requests. (defaults to undefined; if not set, but <a href="output/Ext.data.Connection.html#Ext.data.Connection-request">request</a> params are present, POST will be used; otherwise, GET will be used.)
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Number' name='timeout'>
          <xs:annotation>
            <xs:documentation>
              The timeout in milliseconds to be used for requests. (defaults to 30000)
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='url'>
          <xs:annotation>
            <xs:documentation>
              The default URL to be used for requests to the server. Defaults to undefined. <p>The <code>url</code> config may be a function which <i>returns</i> the URL to use for the Ajax request. The scope (<code><b>this</b></code> reference) of the function is the <code>scope</code> option passed to the <a href="output/Ext.data.Connection.html#Ext.data.Connection-request">request</a> method.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='Connection' type='ed:Connection_TYPE' substitutionGroup='eu:Observable'>
    <xs:annotation>
      <xs:documentation>
        The class encapsulates a connection to the page's originating domain, allowing requests to be made either to a configured URL, or to a URL specified at request time. <p>Requests made by this class are asynchronous, and will return immediately. No data from the server will be available to the statement immediately following the <a href="output/Ext.data.Connection.html#Ext.data.Connection-request">request</a> call. To process returned data, use a <a href="#request-option-success">success callback</a> in the request options object, or an <a href="output/Ext.data.Connection.html#Ext.data.Connection-requestcomplete">event listener</a>.</p><h3>File Uploads</h3><a href="#request-option-isUpload">File uploads</a> are not performed using normal "Ajax" techniques, that is they are <b>not</b> performed using XMLHttpRequests. Instead the form is submitted in the standard manner with the DOM <tt>&lt;form&gt;</tt> element temporarily modified to have its <a href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-target">target</a> set to refer to a dynamically generated, hidden <tt>&lt;iframe&gt;</tt> which is inserted into the document but removed after the return data has been gathered.<br/><br/> <p>The server response is parsed by the browser to create the document for the IFRAME. If the server is using JSON to send the return object, then the <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.17">Content-Type</a> header must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.</p><p>Characters which are significant to an HTML parser must be sent as HTML entities, so encode "&lt;" as "&amp;lt;", "&amp;" as "&amp;amp;" etc.</p><p>The response text is retrieved from the document, and a fake XMLHttpRequest object is created containing a <tt>responseText</tt> property in order to conform to the requirements of event handlers and callbacks.</p><p>Be aware that file upload packets are sent with the content type <a href="http://www.faqs.org/rfcs/rfc2388.html">multipart/form</a> and some server technologies (notably JEE) may require some custom processing in order to retrieve parameter names and parameter values from the packet content.</p><p>Also note that it's not possible to check the response code of the hidden iframe, so the success handler will ALWAYS fire.</p> <p>This class serves as a typed config object for constructor of class Connection.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.Connection
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='DataProxy_TYPE'>
    <xs:complexContent>
      <xs:extension base='eu:Observable_TYPE'>
        <xs:sequence>
            <xs:element name='api' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Specific urls to call on CRUD action methods "read", "create", "update" and "destroy". Defaults to:<pre><code>api: { read : undefined, create : undefined, update : undefined, destroy : undefined } </code></pre><p>The url is built based upon the action being executed <tt>[load|create|save|destroy]</tt> using the commensurate <tt><a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-api">api</a></tt> property, or if undefined default to the configured <a href="Ext.data.Store.html">Ext.data.Store</a>.<a href="output/Ext.data.Store.html#Ext.data.Store-url">url</a>.</p><br/><p>For example:</p><pre><code>api: { load : '/controller/load', create : '/controller/new', // Server MUST return idProperty of new record save : '/controller/update', destroy : '/controller/destroy_action' } // Alternatively, one can use the object-form to specify each API-action api: { load: {url: 'read.php', method: 'GET'}, create: 'create.php', destroy: 'destroy.php', save: 'update.php' } </code></pre><p>If the specific URL for a given CRUD action is undefined, the CRUD action request will be directed to the configured <tt><a href="output/Ext.data.Connection.html#Ext.data.Connection-url">url</a></tt>.</p><br/><p><b>Note</b>: To modify the URL for an action dynamically the appropriate API property should be modified before the action is requested using the corresponding before action event. For example to modify the URL associated with the load action:</p><pre><code>// modify the url for the action myStore.on({ beforeload: { fn: function (store, options) { // use <tt><a href="output/Ext.data.HttpProxy.html#Ext.data.HttpProxy-setUrl">setUrl</a></tt> to change the URL for &#42;just&#42; this request. store.proxy.setUrl('changed1.php'); // set optional second parameter to true to make this URL change // permanent, applying this URL for all subsequent requests. store.proxy.setUrl('changed1.php', true); // Altering the proxy API should be done using the public // method <tt><a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-setApi">setApi</a></tt>. store.proxy.setApi('read', 'changed2.php'); // Or set the entire API with a config-object. // When using the config-object option, you must redefine the <b>entire</b> // API -- not just a specific action of it. store.proxy.setApi({ read : 'changed_read.php', create : 'changed_create.php', update : 'changed_update.php', destroy : 'changed_destroy.php' }); } } }); </code></pre><br/><br/>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='doRequest' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Abstract method that should be implemented in all subclasses. <b>Note:</b> Should only be used by custom-proxy developers. (e.g.: <a href="output/Ext.data.HttpProxy.html#Ext.data.HttpProxy-doRequest">HttpProxy.doRequest</a>, <a href="output/Ext.data.DirectProxy.html#Ext.data.DirectProxy-doRequest">DirectProxy.doRequest</a>).
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='onRead' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Abstract method that should be implemented in all subclasses. <b>Note:</b> Should only be used by custom-proxy developers. Callback for read <a href="output/Ext.data.Api.html#Ext.data.Api-actions">action</a>.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='onWrite' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Abstract method that should be implemented in all subclasses. <b>Note:</b> Should only be used by custom-proxy developers. Callback for <i>create, update and destroy</i> <a href="output/Ext.data.Api.html#Ext.data.Api-actions">actions</a>.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:String' name='api'>
          <xs:annotation>
            <xs:documentation>
              Specific urls to call on CRUD action methods "read", "create", "update" and "destroy". Defaults to:<pre><code>api: { read : undefined, create : undefined, update : undefined, destroy : undefined } </code></pre><p>The url is built based upon the action being executed <tt>[load|create|save|destroy]</tt> using the commensurate <tt><a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-api">api</a></tt> property, or if undefined default to the configured <a href="Ext.data.Store.html">Ext.data.Store</a>.<a href="output/Ext.data.Store.html#Ext.data.Store-url">url</a>.</p><br/><p>For example:</p><pre><code>api: { load : '/controller/load', create : '/controller/new', // Server MUST return idProperty of new record save : '/controller/update', destroy : '/controller/destroy_action' } // Alternatively, one can use the object-form to specify each API-action api: { load: {url: 'read.php', method: 'GET'}, create: 'create.php', destroy: 'destroy.php', save: 'update.php' } </code></pre><p>If the specific URL for a given CRUD action is undefined, the CRUD action request will be directed to the configured <tt><a href="output/Ext.data.Connection.html#Ext.data.Connection-url">url</a></tt>.</p><br/><p><b>Note</b>: To modify the URL for an action dynamically the appropriate API property should be modified before the action is requested using the corresponding before action event. For example to modify the URL associated with the load action:</p><pre><code>// modify the url for the action myStore.on({ beforeload: { fn: function (store, options) { // use <tt><a href="output/Ext.data.HttpProxy.html#Ext.data.HttpProxy-setUrl">setUrl</a></tt> to change the URL for &#42;just&#42; this request. store.proxy.setUrl('changed1.php'); // set optional second parameter to true to make this URL change // permanent, applying this URL for all subsequent requests. store.proxy.setUrl('changed1.php', true); // Altering the proxy API should be done using the public // method <tt><a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-setApi">setApi</a></tt>. store.proxy.setApi('read', 'changed2.php'); // Or set the entire API with a config-object. // When using the config-object option, you must redefine the <b>entire</b> // API -- not just a specific action of it. store.proxy.setApi({ read : 'changed_read.php', create : 'changed_create.php', update : 'changed_update.php', destroy : 'changed_destroy.php' }); } } }); </code></pre><br/><br/>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='doRequest'>
          <xs:annotation>
            <xs:documentation>
              Abstract method that should be implemented in all subclasses. <b>Note:</b> Should only be used by custom-proxy developers. (e.g.: <a href="output/Ext.data.HttpProxy.html#Ext.data.HttpProxy-doRequest">HttpProxy.doRequest</a>, <a href="output/Ext.data.DirectProxy.html#Ext.data.DirectProxy-doRequest">DirectProxy.doRequest</a>).
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='onRead'>
          <xs:annotation>
            <xs:documentation>
              Abstract method that should be implemented in all subclasses. <b>Note:</b> Should only be used by custom-proxy developers. Callback for read <a href="output/Ext.data.Api.html#Ext.data.Api-actions">action</a>.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='onWrite'>
          <xs:annotation>
            <xs:documentation>
              Abstract method that should be implemented in all subclasses. <b>Note:</b> Should only be used by custom-proxy developers. Callback for <i>create, update and destroy</i> <a href="output/Ext.data.Api.html#Ext.data.Api-actions">actions</a>.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='restful'>
          <xs:annotation>
            <xs:documentation>
              Defaults to <tt>false</tt>. Set to <tt>true</tt> to operate in a RESTful manner. <br/><p>Note: this parameter will automatically be set to <tt>true</tt> if the <a href="Ext.data.Store.html">Ext.data.Store</a> it is plugged into is set to <code>restful: true</code>. If the Store is RESTful, there is no need to set this option on the proxy.</p><br/><p>RESTful implementations enable the serverside framework to automatically route actions sent to one url based upon the HTTP method, for example:</p><pre><code>store: new Ext.data.Store({ restful: true, proxy: new Ext.data.HttpProxy({url:'/users'}); // all requests sent to /users ... )} </code></pre>If there is no <code><a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-api">api</a></code> specified in the configuration of the proxy, all requests will be marshalled to a single RESTful url (/users) so the serverside framework can inspect the HTTP Method and act accordingly: <pre><u>Method</u> <u>url</u> <u>action</u> POST /users create GET /users read PUT /users/23 update DESTROY /users/23 delete </pre><br/><br/> <p>If set to <tt>true</tt>, a <a href="output/Ext.data.Record.html#Ext.data.Record-phantom">non-phantom</a> record's <a href="output/Ext.data.Record.html#Ext.data.Record-id">id</a> will be appended to the url. Some MVC (e.g., Ruby on Rails, Merb and Django) support segment based urls where the segments in the URL follow the Model-View-Controller approach:</p><pre><code>someSite.com/controller/action/id </code></pre>Where the segments in the url are typically:<div class="mdetail-params"><ul><li>The first segment : represents the controller class that should be invoked.</li><li>The second segment : represents the class function, or method, that should be called.</li><li>The third segment : represents the ID (a variable typically passed to the method).</li></ul></div><br/><br/> <br/><p>Refer to <code><a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-api">Ext.data.DataProxy.api</a></code> for additional information.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='DataProxy' type='ed:DataProxy_TYPE' substitutionGroup='eu:Observable'>
    <xs:annotation>
      <xs:documentation>
        Abstract base class for implementations which provide retrieval of unformatted data objects. This class is intended to be extended and should not be created directly. For existing implementations, see <a href="Ext.data.DirectProxy.html">Ext.data.DirectProxy</a>, <a href="Ext.data.HttpProxy.html">Ext.data.HttpProxy</a>, <a href="Ext.data.ScriptTagProxy.html">Ext.data.ScriptTagProxy</a> and <a href="Ext.data.MemoryProxy.html">Ext.data.MemoryProxy</a>. <p>DataProxy implementations are usually used in conjunction with an implementation of <a href="Ext.data.DataReader.html">Ext.data.DataReader</a> (of the appropriate type which knows how to parse the data object) to provide a block of <a href="Ext.data.Records.html">Ext.data.Records</a> to an <a href="Ext.data.Store.html">Ext.data.Store</a>.</p><p>The parameter to a DataProxy constructor may be an <a href="Ext.data.Connection.html">Ext.data.Connection</a> or can also be the config object to an <a href="Ext.data.Connection.html">Ext.data.Connection</a>.</p><p>Custom implementations must implement either the <code><b>doRequest</b></code> method (preferred) or the <code>load</code> method (deprecated). See <a href="Ext.data.HttpProxy.html">Ext.data.HttpProxy</a>.<a href="output/Ext.data.HttpProxy.html#Ext.data.HttpProxy-doRequest">doRequest</a> or <a href="Ext.data.HttpProxy.html">Ext.data.HttpProxy</a>.<a href="output/Ext.data.HttpProxy.html#Ext.data.HttpProxy-load">load</a> for additional details.</p><p style="font-weight: bold"><u>Example 1</u></p><pre><code>proxy: new Ext.data.ScriptTagProxy({ <a href="output/Ext.data.Connection.html#Ext.data.Connection-url">url</a>: 'http://extjs.com/forum/topics-remote.php' }), </code></pre><p style="font-weight: bold"><u>Example 2</u></p><pre><code>proxy : new Ext.data.HttpProxy({ <a href="output/Ext.data.Connection.html#Ext.data.Connection-method">method</a>: 'GET', <a href="output/Ext.data.HttpProxy.html#Ext.data.HttpProxy-prettyUrls">prettyUrls</a>: false, <a href="output/Ext.data.Connection.html#Ext.data.Connection-url">url</a>: 'local/default.php', // see options parameter for <a href="output/Ext.Ajax.html#Ext.Ajax-request">Ext.Ajax.request</a> <a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-api">api</a>: { // all actions except the following will use above url create : 'local/new.php', update : 'local/update.php' } }), </code></pre><p>And <b>new in Ext version 3</b>, attach centralized event-listeners upon the DataProxy class itself! This is a great place to implement a <i>messaging system</i> to centralize your application's user-feedback and error-handling.</p><pre><code>// Listen to all "beforewrite" event fired by all proxies. Ext.data.DataProxy.on('beforewrite', function(proxy, action) { console.log('beforewrite: ', action); }); // Listen to "write" event fired by all proxies Ext.data.DataProxy.on('write', function(proxy, action, data, res, rs) { console.info('write: ', action); }); // Listen to "exception" event fired by all proxies Ext.data.DataProxy.on('exception', function(proxy, type, action, exception) { console.error(type + action + ' exception); }); </code></pre><b>Note:</b> These three events are all fired with the signature of the corresponding <i>DataProxy instance</i> event <a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-beforewrite">beforewrite</a>, <a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-write">write</a> and <a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-exception">exception</a>. <p>This class serves as a typed config object for constructor of class DataProxy.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.DataProxy
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='DataReader_TYPE'>
        <xs:sequence>
            <xs:element name='fields' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Either an Array of <a href="Ext.data.Field.html">Field</a> definition objects (which will be passed to <a href="output/Ext.data.Record.html#Ext.data.Record-create">Ext.data.Record.create</a>), or a <a href="Ext.data.Record.html">Record</a> constructor created from <a href="output/Ext.data.Record.html#Ext.data.Record-create">Ext.data.Record.create</a>.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:String' name='fields'>
          <xs:annotation>
            <xs:documentation>
              Either an Array of <a href="Ext.data.Field.html">Field</a> definition objects (which will be passed to <a href="output/Ext.data.Record.html#Ext.data.Record-create">Ext.data.Record.create</a>), or a <a href="Ext.data.Record.html">Record</a> constructor created from <a href="output/Ext.data.Record.html#Ext.data.Record-create">Ext.data.Record.create</a>.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='messageProperty'>
          <xs:annotation>
            <xs:documentation>
              [undefined] Optional name of a property within a server-response that represents a user-feedback message.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
  </xs:complexType>
  <xs:element name='DataReader' type='ed:DataReader_TYPE'>
    <xs:annotation>
      <xs:documentation>
        Abstract base class for reading structured data from a data source and converting it into an object containing <a href="Ext.data.Record.html">Ext.data.Record</a> objects and metadata for use by an <a href="Ext.data.Store.html">Ext.data.Store</a>. This class is intended to be extended and should not be created directly. For existing implementations, see <a href="Ext.data.ArrayReader.html">Ext.data.ArrayReader</a>, <a href="Ext.data.JsonReader.html">Ext.data.JsonReader</a> and <a href="Ext.data.XmlReader.html">Ext.data.XmlReader</a>. <p>This class serves as a typed config object for constructor of class DataReader.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.DataReader
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='DataWriter_TYPE'>
        <xs:sequence>
            <xs:element name='createRecord' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Abstract method that should be implemented in all subclasses (e.g.: <a href="output/Ext.data.JsonWriter.html#Ext.data.JsonWriter-createRecord">JsonWriter.createRecord</a>)
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='destroyRecord' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Abstract method that should be implemented in all subclasses (e.g.: <a href="output/Ext.data.JsonWriter.html#Ext.data.JsonWriter-destroyRecord">JsonWriter.destroyRecord</a>)
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='updateRecord' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Abstract method that should be implemented in all subclasses (e.g.: <a href="output/Ext.data.JsonWriter.html#Ext.data.JsonWriter-updateRecord">JsonWriter.updateRecord</a>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:String' name='createRecord'>
          <xs:annotation>
            <xs:documentation>
              Abstract method that should be implemented in all subclasses (e.g.: <a href="output/Ext.data.JsonWriter.html#Ext.data.JsonWriter-createRecord">JsonWriter.createRecord</a>)
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='destroyRecord'>
          <xs:annotation>
            <xs:documentation>
              Abstract method that should be implemented in all subclasses (e.g.: <a href="output/Ext.data.JsonWriter.html#Ext.data.JsonWriter-destroyRecord">JsonWriter.destroyRecord</a>)
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='listful'>
          <xs:annotation>
            <xs:documentation>
              <tt>false</tt> by default. Set <tt>true</tt> to have the DataWriter <b>always</b> write HTTP params as a list, even when acting upon a single record.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='updateRecord'>
          <xs:annotation>
            <xs:documentation>
              Abstract method that should be implemented in all subclasses (e.g.: <a href="output/Ext.data.JsonWriter.html#Ext.data.JsonWriter-updateRecord">JsonWriter.updateRecord</a>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='writeAllFields'>
          <xs:annotation>
            <xs:documentation>
              <tt>false</tt> by default. Set <tt>true</tt> to have DataWriter return ALL fields of a modified record -- not just those that changed. <tt>false</tt> to have DataWriter only request modified fields from a record.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
  </xs:complexType>
  <xs:element name='DataWriter' type='ed:DataWriter_TYPE'>
    <xs:annotation>
      <xs:documentation>
        Ext.data.DataWriter facilitates create, update, and destroy actions between an Ext.data.Store and a server-side framework. A Writer enabled Store will automatically manage the Ajax requests to perform CRUD actions on a Store. <p>Ext.data.DataWriter is an abstract base class which is intended to be extended and should not be created directly. For existing implementations, see <a href="Ext.data.JsonWriter.html">Ext.data.JsonWriter</a>.</p><p>Creating a writer is simple:</p><pre><code>var writer = new Ext.data.JsonWriter({ encode: false // &lt;--- false causes data to be printed to jsonData config-property of Ext.Ajax#reqeust }); </code></pre><p>Same old JsonReader as Ext-2.x:</p><pre><code>var reader = new Ext.data.JsonReader({idProperty: 'id'}, [{name: 'first'}, {name: 'last'}, {name: 'email'}]); </code></pre><p>The proxy for a writer enabled store can be configured with a simple <code>url</code>:</p><pre><code>// Create a standard HttpProxy instance. var proxy = new Ext.data.HttpProxy({ url: 'app.php/users' // &lt;--- Supports "provides"-type urls, such as '/users.json', '/products.xml' (Hello Rails/Merb) }); </code></pre><p>For finer grained control, the proxy may also be configured with an <code>API</code>:</p><pre><code>// Maximum flexibility with the API-configuration var proxy = new Ext.data.HttpProxy({ api: { read : 'app.php/users/read', create : 'app.php/users/create', update : 'app.php/users/update', destroy : { // &lt;--- Supports object-syntax as well url: 'app.php/users/destroy', method: "DELETE" } } }); </code></pre><p>Pulling it all together into a Writer-enabled Store:</p><pre><code>var store = new Ext.data.Store({ proxy: proxy, reader: reader, writer: writer, autoLoad: true, autoSave: true // -- Cell-level updates. }); </code></pre><p>Initiating write-actions <b>automatically</b>, using the existing Ext2.0 Store/Record API:</p><pre><code>var rec = store.getAt(0); rec.set('email', 'foo&#64;bar.com'); // &lt;--- Immediately initiates an UPDATE action through configured proxy. store.remove(rec); // &lt;---- Immediately initiates a DESTROY action through configured proxy. </code></pre><p>For <b>record/batch</b> updates, use the Store-configuration <a href="output/Ext.data.Store.html#Ext.data.Store-autoSave">autoSave:false</a></p><pre><code>var store = new Ext.data.Store({ proxy: proxy, reader: reader, writer: writer, autoLoad: true, autoSave: false // -- disable cell-updates }); var urec = store.getAt(0); urec.set('email', 'foo&#64;bar.com'); var drec = store.getAt(1); store.remove(drec); // Push the button! store.save(); </code></pre> <p>This class serves as a typed config object for constructor of class DataWriter.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.DataWriter
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='DirectProxy_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:DataProxy_TYPE'>
        <xs:sequence>
            <xs:element name='directFn' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Function to call when executing a request. directFn is a simple alternative to defining the api configuration-parameter for Store's which will not implement a full CRUD api.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='paramOrder' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Defaults to <tt>undefined</tt>. A list of params to be executed server side. Specify the params in the order in which they must be executed on the server-side as either (1) an Array of String values, or (2) a String of params delimited by either whitespace, comma, or pipe. For example, any of the following would be acceptable:<pre><code>paramOrder: ['param1','param2','param3'] paramOrder: 'param1 param2 param3' paramOrder: 'param1,param2,param3' paramOrder: 'param1|param2|param' </code></pre>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:String' name='directFn'>
          <xs:annotation>
            <xs:documentation>
              Function to call when executing a request. directFn is a simple alternative to defining the api configuration-parameter for Store's which will not implement a full CRUD api.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='paramOrder'>
          <xs:annotation>
            <xs:documentation>
              Defaults to <tt>undefined</tt>. A list of params to be executed server side. Specify the params in the order in which they must be executed on the server-side as either (1) an Array of String values, or (2) a String of params delimited by either whitespace, comma, or pipe. For example, any of the following would be acceptable:<pre><code>paramOrder: ['param1','param2','param3'] paramOrder: 'param1 param2 param3' paramOrder: 'param1,param2,param3' paramOrder: 'param1|param2|param' </code></pre>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='paramsAsHash'>
          <xs:annotation>
            <xs:documentation>
              Send parameters as a collection of named arguments (defaults to <tt>true</tt>). Providing a <tt><a href="output/Ext.data.DirectProxy.html#Ext.data.DirectProxy-paramOrder">paramOrder</a></tt> nullifies this configuration.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='DirectProxy' type='ed:DirectProxy_TYPE' substitutionGroup='ed:DataProxy'>
    <xs:annotation>
      <xs:documentation>
        <p>This class serves as a typed config object for constructor of class DirectProxy.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.DirectProxy
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='DirectStore_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:Store_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='DirectStore' type='ed:DirectStore_TYPE' substitutionGroup='ed:Store'>
    <xs:annotation>
      <xs:documentation>
        Small helper class to create an <a href="Ext.data.Store.html">Ext.data.Store</a> configured with an <a href="Ext.data.DirectProxy.html">Ext.data.DirectProxy</a> and <a href="Ext.data.JsonReader.html">Ext.data.JsonReader</a> to make interacting with an <a href="Ext.Direct.html">Ext.Direct</a> Server-side <a href="Ext.direct.Provider.html">Provider</a> easier. To create a different proxy/reader combination create a basic <a href="Ext.data.Store.html">Ext.data.Store</a> configured as needed. <p><b>&#42;Note:</b> Although they are not listed, this class inherits all of the config options of:</p><div><ul class="mdetail-params"><li><b><a href="Ext.data.Store.html">Store</a></b></li><li><b><a href="Ext.data.JsonReader.html">JsonReader</a></b></li><li style="list-style: none"><div class="sub-desc"><ul class="mdetail-params"><li><tt><b><a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-root">root</a></b></tt></li><li><tt><b><a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-idProperty">idProperty</a></b></tt></li><li><tt><b><a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-totalProperty">totalProperty</a></b></tt></li></ul></div></li><li><b><a href="Ext.data.DirectProxy.html">DirectProxy</a></b></li><li style="list-style: none"><div class="sub-desc"><ul class="mdetail-params"><li><tt><b><a href="output/Ext.data.DirectProxy.html#Ext.data.DirectProxy-directFn">directFn</a></b></tt></li><li><tt><b><a href="output/Ext.data.DirectProxy.html#Ext.data.DirectProxy-paramOrder">paramOrder</a></b></tt></li><li><tt><b><a href="output/Ext.data.DirectProxy.html#Ext.data.DirectProxy-paramsAsHash">paramsAsHash</a></b></tt></li></ul></div></li></ul></div> <p>This class serves as a typed config object for constructor of class DirectStore.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.DirectStore
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='Field_TYPE'>
        <xs:sequence>
            <xs:element name='convert' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  A function which converts the value provided by the Reader into an object that will be stored in the Record. It is passed the following parameters:<div class="mdetail-params"><ul><li><b>v</b> : Mixed<div class="sub-desc">The data value as read by the Reader, if undefined will use the configured <code><a href="output/Ext.data.Field.html#Ext.data.Field-defaultValue">defaultValue</a></code>.</div></li><li><b>rec</b> : Mixed<div class="sub-desc">The data object containing the row as read by the Reader. Depending on the Reader type, this could be an Array (<a href="Ext.data.ArrayReader.html">ArrayReader</a>), an object (<a href="Ext.data.JsonReader.html">JsonReader</a>), or an XML element (<a href="Ext.data.XMLReader.html">XMLReader</a>).</div></li></ul></div><pre><code>// example of convert function function fullName(v, record){ return record.name.last + ', ' + record.name.first; } function location(v, record){ return !record.city ? '' : (record.city + ', ' + record.state); } var Dude = Ext.data.Record.create([ {name: 'fullname', convert: fullName}, {name: 'firstname', mapping: 'name.first'}, {name: 'lastname', mapping: 'name.last'}, {name: 'city', defaultValue: 'homeless'}, 'state', {name: 'location', convert: location} ]); // create the data store var store = new Ext.data.Store({ reader: new Ext.data.JsonReader( { idProperty: 'key', root: 'daRoot', totalProperty: 'total' }, Dude // recordType ) }); var myData = [ { key: 1, name: { first: 'Fat', last: 'Albert' } // notice no city, state provided in data object }, { key: 2, name: { first: 'Barney', last: 'Rubble' }, city: 'Bedrock', state: 'Stoneridge' }, { key: 3, name: { first: 'Cliff', last: 'Claven' }, city: 'Boston', state: 'MA' } ]; </code></pre>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='defaultValue' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The default value used <b>when a Record is being created by a <a href="Ext.data.Reader.html">Reader</a></b> when the item referenced by the <code><a href="output/Ext.data.Field.html#Ext.data.Field-mapping">mapping</a></code> does not exist in the data object (i.e. undefined). (defaults to "")
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='mapping' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  (Optional) A path expression for use by the <a href="Ext.data.DataReader.html">Ext.data.DataReader</a> implementation that is creating the <a href="Ext.data.Record.html">Record</a> to extract the Field value from the data object. If the path expression is the same as the field name, the mapping may be omitted. <p>The form of the mapping expression depends on the Reader being used.</p><div class="mdetail-params"><ul><li><a href="Ext.data.JsonReader.html">Ext.data.JsonReader</a><div class="sub-desc">The mapping is a string containing the javascript expression to reference the data from an element of the data item's <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-root">root</a> Array. Defaults to the field name.</div></li><li><a href="Ext.data.XmlReader.html">Ext.data.XmlReader</a><div class="sub-desc">The mapping is an <a href="Ext.DomQuery.html">Ext.DomQuery</a> path to the data item relative to the DOM element that represents the <a href="output/Ext.data.XmlReader.html#Ext.data.XmlReader-record">record</a>. Defaults to the field name.</div></li><li><a href="Ext.data.ArrayReader.html">Ext.data.ArrayReader</a><div class="sub-desc">The mapping is a number indicating the Array index of the field's value. Defaults to the field specification's Array position.</div></li></ul></div><p>If a more complex value extraction strategy is required, then configure the Field with a <a href="output/Ext.data.Field.html#Ext.data.Field-convert">convert</a> function. This is passed the whole row object, and may interrogate it in whatever way is necessary in order to return the desired data.</p>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='sortType' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  A function which converts a Field's value to a comparable value in order to ensure correct sort ordering. Predefined functions are provided in <a href="Ext.data.SortTypes.html">Ext.data.SortTypes</a>. A custom sort example:<pre><code>// current sort after sort we want // +-+------+ +-+------+ // |1|First | |1|First | // |2|Last | |3|Second| // |3|Second| |2|Last | // +-+------+ +-+------+ sortType: function(value) { switch (value.toLowerCase()) // native toLowerCase(): { case 'first': return 1; case 'second': return 2; default: return 3; } } </code></pre>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='type' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The data type for automatic conversion from received data to the <i>stored</i> value if <code><a href="output/Ext.data.Field.html#Ext.data.Field-convert">convert</a></code> has not been specified. This may be specified as a string value. Possible values are <div class="mdetail-params"><ul><li>auto (Default, implies no conversion)</li><li>string</li><li>int</li><li>float</li><li>boolean</li><li>date</li></ul></div><p>This may also be specified by referencing a member of the <a href="Ext.data.Types.html">Ext.data.Types</a> class.</p><p>Developers may create their own application-specific data types by defining new members of the <a href="Ext.data.Types.html">Ext.data.Types</a> class.</p>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:Boolean' name='allowBlank'>
          <xs:annotation>
            <xs:documentation>
              Used for validating a <a href="Ext.data.Record.html">record</a>, defaults to <code>true</code>. An empty value here will cause <a href="Ext.data.Record.html">Ext.data.Record</a>.<a href="output/Ext.data.Record.html#Ext.data.Record-isValid">isValid</a> to evaluate to <code>false</code>.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='convert'>
          <xs:annotation>
            <xs:documentation>
              A function which converts the value provided by the Reader into an object that will be stored in the Record. It is passed the following parameters:<div class="mdetail-params"><ul><li><b>v</b> : Mixed<div class="sub-desc">The data value as read by the Reader, if undefined will use the configured <code><a href="output/Ext.data.Field.html#Ext.data.Field-defaultValue">defaultValue</a></code>.</div></li><li><b>rec</b> : Mixed<div class="sub-desc">The data object containing the row as read by the Reader. Depending on the Reader type, this could be an Array (<a href="Ext.data.ArrayReader.html">ArrayReader</a>), an object (<a href="Ext.data.JsonReader.html">JsonReader</a>), or an XML element (<a href="Ext.data.XMLReader.html">XMLReader</a>).</div></li></ul></div><pre><code>// example of convert function function fullName(v, record){ return record.name.last + ', ' + record.name.first; } function location(v, record){ return !record.city ? '' : (record.city + ', ' + record.state); } var Dude = Ext.data.Record.create([ {name: 'fullname', convert: fullName}, {name: 'firstname', mapping: 'name.first'}, {name: 'lastname', mapping: 'name.last'}, {name: 'city', defaultValue: 'homeless'}, 'state', {name: 'location', convert: location} ]); // create the data store var store = new Ext.data.Store({ reader: new Ext.data.JsonReader( { idProperty: 'key', root: 'daRoot', totalProperty: 'total' }, Dude // recordType ) }); var myData = [ { key: 1, name: { first: 'Fat', last: 'Albert' } // notice no city, state provided in data object }, { key: 2, name: { first: 'Barney', last: 'Rubble' }, city: 'Bedrock', state: 'Stoneridge' }, { key: 3, name: { first: 'Cliff', last: 'Claven' }, city: 'Boston', state: 'MA' } ]; </code></pre>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='dateFormat'>
          <xs:annotation>
            <xs:documentation>
              (Optional) Used when converting received data into a Date when the <a href="output/Ext.data.Field.html#Ext.data.Field-type">type</a> is specified as <code>"date"</code>. <p>A format string for the <a href="output/Date.html#Date-parseDate">Date.parseDate</a> function, or "timestamp" if the value provided by the Reader is a UNIX timestamp, or "time" if the value provided by the Reader is a javascript millisecond timestamp. See <a href="Date.html">Date</a></p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='defaultValue'>
          <xs:annotation>
            <xs:documentation>
              The default value used <b>when a Record is being created by a <a href="Ext.data.Reader.html">Reader</a></b> when the item referenced by the <code><a href="output/Ext.data.Field.html#Ext.data.Field-mapping">mapping</a></code> does not exist in the data object (i.e. undefined). (defaults to "")
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='mapping'>
          <xs:annotation>
            <xs:documentation>
              (Optional) A path expression for use by the <a href="Ext.data.DataReader.html">Ext.data.DataReader</a> implementation that is creating the <a href="Ext.data.Record.html">Record</a> to extract the Field value from the data object. If the path expression is the same as the field name, the mapping may be omitted. <p>The form of the mapping expression depends on the Reader being used.</p><div class="mdetail-params"><ul><li><a href="Ext.data.JsonReader.html">Ext.data.JsonReader</a><div class="sub-desc">The mapping is a string containing the javascript expression to reference the data from an element of the data item's <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-root">root</a> Array. Defaults to the field name.</div></li><li><a href="Ext.data.XmlReader.html">Ext.data.XmlReader</a><div class="sub-desc">The mapping is an <a href="Ext.DomQuery.html">Ext.DomQuery</a> path to the data item relative to the DOM element that represents the <a href="output/Ext.data.XmlReader.html#Ext.data.XmlReader-record">record</a>. Defaults to the field name.</div></li><li><a href="Ext.data.ArrayReader.html">Ext.data.ArrayReader</a><div class="sub-desc">The mapping is a number indicating the Array index of the field's value. Defaults to the field specification's Array position.</div></li></ul></div><p>If a more complex value extraction strategy is required, then configure the Field with a <a href="output/Ext.data.Field.html#Ext.data.Field-convert">convert</a> function. This is passed the whole row object, and may interrogate it in whatever way is necessary in order to return the desired data.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='name'>
          <xs:annotation>
            <xs:documentation>
              The name by which the field is referenced within the Record. This is referenced by, for example, the <code>dataIndex</code> property in column definition objects passed to <a href="Ext.grid.ColumnModel.html">Ext.grid.ColumnModel</a>. <p>Note: In the simplest case, if no properties other than <code>name</code> are required, a field definition may consist of just a String for the field name.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='sortDir'>
          <xs:annotation>
            <xs:documentation>
              Initial direction to sort (<code>"ASC"</code> or <code>"DESC"</code>). Defaults to <code>"ASC"</code>.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='sortType'>
          <xs:annotation>
            <xs:documentation>
              A function which converts a Field's value to a comparable value in order to ensure correct sort ordering. Predefined functions are provided in <a href="Ext.data.SortTypes.html">Ext.data.SortTypes</a>. A custom sort example:<pre><code>// current sort after sort we want // +-+------+ +-+------+ // |1|First | |1|First | // |2|Last | |3|Second| // |3|Second| |2|Last | // +-+------+ +-+------+ sortType: function(value) { switch (value.toLowerCase()) // native toLowerCase(): { case 'first': return 1; case 'second': return 2; default: return 3; } } </code></pre>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='type'>
          <xs:annotation>
            <xs:documentation>
              The data type for automatic conversion from received data to the <i>stored</i> value if <code><a href="output/Ext.data.Field.html#Ext.data.Field-convert">convert</a></code> has not been specified. This may be specified as a string value. Possible values are <div class="mdetail-params"><ul><li>auto (Default, implies no conversion)</li><li>string</li><li>int</li><li>float</li><li>boolean</li><li>date</li></ul></div><p>This may also be specified by referencing a member of the <a href="Ext.data.Types.html">Ext.data.Types</a> class.</p><p>Developers may create their own application-specific data types by defining new members of the <a href="Ext.data.Types.html">Ext.data.Types</a> class.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='useNull'>
          <xs:annotation>
            <xs:documentation>
              (Optional) Use when converting received data into a Number type (either int or float). If the value cannot be parsed, null will be used if useNull is true, otherwise the value will be 0. Defaults to <tt>false</tt>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
  </xs:complexType>
  <xs:element name='Field' type='ed:Field_TYPE'>
    <xs:annotation>
      <xs:documentation>
        This class encapsulates the field definition information specified in the field definition objects passed to <a href="output/Ext.data.Record.html#Ext.data.Record-create">Ext.data.Record.create</a>. <p>Developers do not need to instantiate this class. Instances are created by <a href="Ext.data.Record.create.html">Ext.data.Record.create</a> and cached in the <a href="output/Ext.data.Record.html#Ext.data.Record-fields">fields</a> property of the created Record constructor's <b>prototype.</b></p> <p>This class represents the xtype 'datafield' and serves as a typed config object for constructor of class Field.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.Field
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='GroupingStore_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:Store_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:attribute type='exml:String' name='groupDir'>
          <xs:annotation>
            <xs:documentation>
              The direction to sort the groups. Defaults to <tt>'ASC'</tt>.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='groupField'>
          <xs:annotation>
            <xs:documentation>
              The field name by which to sort the store's data (defaults to '').
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='groupOnSort'>
          <xs:annotation>
            <xs:documentation>
              True to sort the data on the grouping field when a grouping operation occurs, false to sort based on the existing sort info (defaults to false).
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='remoteGroup'>
          <xs:annotation>
            <xs:documentation>
              True if the grouping should apply on the server side, false if it is local only (defaults to false). If the grouping is local, it can be applied immediately to the data. If it is remote, then it will simply act as a helper, automatically sending the grouping field name as the 'groupBy' param with each XHR call.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='GroupingStore' type='ed:GroupingStore_TYPE' substitutionGroup='ed:Store'>
    <xs:annotation>
      <xs:documentation>
        A specialized store implementation that provides for grouping records by one of the available fields. This is usually used in conjunction with an <a href="Ext.grid.GroupingView.html">Ext.grid.GroupingView</a> to provide the data model for a grouped GridPanel. Internally, GroupingStore is simply a normal Store with multi sorting enabled from the start. The grouping field and direction are always injected as the first sorter pair. GroupingView picks up on the configured groupField and builds grid rows appropriately. <p>This class serves as a typed config object for constructor of class GroupingStore.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.GroupingStore
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='HttpProxy_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:DataProxy_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='HttpProxy' type='ed:HttpProxy_TYPE' substitutionGroup='ed:DataProxy'>
    <xs:annotation>
      <xs:documentation>
        An implementation of <a href="Ext.data.DataProxy.html">Ext.data.DataProxy</a> that processes data requests within the same domain of the originating page. <p><b>Note</b>: this class cannot be used to retrieve data from a domain other than the domain from which the running page was served. For cross-domain requests, use a <a href="Ext.data.ScriptTagProxy.html">ScriptTagProxy</a>.</p><p>Be aware that to enable the browser to parse an XML document, the server must set the Content-Type header in the HTTP response to "<tt>text/xml</tt>".</p> <p>This class serves as a typed config object for constructor of class HttpProxy.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.HttpProxy
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='JsonReader_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:DataReader_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:attribute type='exml:String' name='idProperty'>
          <xs:annotation>
            <xs:documentation>
              [id] Name of the property within a row object that contains a record identifier value. Defaults to <tt>id</tt>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='root'>
          <xs:annotation>
            <xs:documentation>
              [undefined] <b>Required</b>. The name of the property which contains the Array of row objects. Defaults to <tt>undefined</tt>. An exception will be thrown if the root property is undefined. The data packet value for this property should be an empty array to clear the data or show no data.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='successProperty'>
          <xs:annotation>
            <xs:documentation>
              [success] Name of the property from which to retrieve the success attribute. Defaults to <tt>success</tt>. See <a href="Ext.data.DataProxy.html">Ext.data.DataProxy</a>.<a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-exception">exception</a> for additional information.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='totalProperty'>
          <xs:annotation>
            <xs:documentation>
              [total] Name of the property from which to retrieve the total number of records in the dataset. This is only needed if the whole dataset is not passed in one go, but is being paged from the remote server. Defaults to <tt>total</tt>.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='JsonReader' type='ed:JsonReader_TYPE' substitutionGroup='ed:DataReader'>
    <xs:annotation>
      <xs:documentation>
        Data reader class to create an Array of <a href="Ext.data.Record.html">Ext.data.Record</a> objects from a JSON packet based on mappings in a provided <a href="Ext.data.Record.html">Ext.data.Record</a> constructor. <p>Example code:</p><pre><code>var myReader = new Ext.data.JsonReader({ // metadata configuration options: <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-idProperty">idProperty</a>: 'id' <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-root">root</a>: 'rows', <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-totalProperty">totalProperty</a>: 'results', <a href="output/Ext.data.DataReader.html#Ext.data.DataReader-messageProperty">Ext.data.DataReader.messageProperty</a>: "msg" // The element within the response that provides a user-feedback message (optional) // the fields config option will internally create an <a href="Ext.data.Record.html">Ext.data.Record</a> // constructor that provides mapping for reading the record data objects <a href="output/Ext.data.DataReader.html#Ext.data.DataReader-fields">fields</a>: [ // map Record's 'firstname' field to data object's key of same name {name: 'name', mapping: 'firstname'}, // map Record's 'job' field to data object's 'occupation' key {name: 'job', mapping: 'occupation'} ] }); </code></pre><p>This would consume a JSON data object of the form:</p><pre><code>{ results: 2000, // Reader's configured <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-totalProperty">totalProperty</a> rows: [ // Reader's configured <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-root">root</a> // record data objects: { <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-idProperty">id</a>: 1, firstname: 'Bill', occupation: 'Gardener' }, { <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-idProperty">id</a>: 2, firstname: 'Ben' , occupation: 'Horticulturalist' }, ... ] } </code></pre><p style="font-weight: bold"><u>Automatic configuration using metaData</u></p><p>It is possible to change a JsonReader's metadata at any time by including a <b><tt>metaData</tt></b> property in the JSON data object. If the JSON data object has a <b><tt>metaData</tt></b> property, a <a href="Ext.data.Store.html">Store</a> object using this Reader will reconfigure itself to use the newly provided field definition and fire its <a href="output/Ext.data.Store.html#Ext.data.Store-metachange">metachange</a> event. The metachange event handler may interrogate the <b><tt>metaData</tt></b> property to perform any configuration required.</p><p>Note that reconfiguring a Store potentially invalidates objects which may refer to Fields or Records which no longer exist.</p><p>To use this facility you would create the JsonReader like this:</p><pre><code>var myReader = new Ext.data.JsonReader(); </code></pre><p>The first data packet from the server would configure the reader by containing a <b><tt>metaData</tt></b> property <b>and</b> the data. For example, the JSON data object might take the form:</p><pre><code>{ metaData: { "<a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-idProperty">idProperty</a>": "id", "<a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-root">root</a>": "rows", "<a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-totalProperty">totalProperty</a>": "results" "<a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-successProperty">successProperty</a>": "success", "<a href="output/Ext.data.DataReader.html#Ext.data.DataReader-fields">fields</a>": [ {"name": "name"}, {"name": "job", "mapping": "occupation"} ], // used by store to set its sortInfo "sortInfo":{ "field": "name", "direction": "ASC" }, // <a href="Ext.PagingToolbar.html">paging data</a> (if applicable) "start": 0, "limit": 2, // custom property "foo": "bar" }, // Reader's configured <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-successProperty">successProperty</a> "success": true, // Reader's configured <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-totalProperty">totalProperty</a> "results": 2000, // Reader's configured <a href="output/Ext.data.JsonReader.html#Ext.data.JsonReader-root">root</a> // (this data simulates 2 results <a href="Ext.PagingToolbar.html">per page</a>) "rows": [ // <b>&#42;Note:</b> this must be an Array { "id": 1, "name": "Bill", "occupation": "Gardener" }, { "id": 2, "name": "Ben", "occupation": "Horticulturalist" } ] } </code></pre><p>The <b><tt>metaData</tt></b> property in the JSON data object should contain:</p><div class="mdetail-params"><ul><li>any of the configuration options for this class</li><li>a <b><tt><a href="output/Ext.data.Record.html#Ext.data.Record-fields">fields</a></tt></b> property which the JsonReader will use as an argument to the <a href="output/Ext.data.Record.html#Ext.data.Record-create">data Record create method</a> in order to configure the layout of the Records it will produce.</li><li>a <b><tt><a href="output/Ext.data.Store.html#Ext.data.Store-sortInfo">sortInfo</a></tt></b> property which the JsonReader will use to set the <a href="Ext.data.Store.html">Ext.data.Store</a>'s <a href="output/Ext.data.Store.html#Ext.data.Store-sortInfo">sortInfo</a> property</li><li>any custom properties needed</li></ul></div> <p>This class serves as a typed config object for constructor of class JsonReader.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.JsonReader
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='JsonStore_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:Store_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='JsonStore' type='ed:JsonStore_TYPE' substitutionGroup='ed:Store'>
    <xs:annotation>
      <xs:documentation>
        Small helper class to make creating <a href="Ext.data.Store.html">Ext.data.Store</a>s from JSON data easier. A JsonStore will be automatically configured with a <a href="Ext.data.JsonReader.html">Ext.data.JsonReader</a>. <p>A store configuration would be something like:</p><pre><code>var store = new Ext.data.JsonStore({ // store configs autoDestroy: true, url: 'get-images.php', storeId: 'myStore', // reader configs root: 'images', idProperty: 'name', fields: ['name', 'url', {name:'size', type: 'float'}, {name:'lastmod', type:'date'}] }); </code></pre><br/><br/> <p>This store is configured to consume a returned object of the form:</p><pre><code>{ images: [ {name: 'Image one', url:'/GetImage.php?id=1', size:46.5, lastmod: new Date(2007, 10, 29)}, {name: 'Image Two', url:'/GetImage.php?id=2', size:43.2, lastmod: new Date(2007, 10, 30)} ] } </code></pre>An object literal of this form could also be used as the <a href="output/Ext.data.JsonStore.html#Ext.data.JsonStore-data">data</a> config option.<br/><br/> <p><b>&#42;Note:</b> Although not listed here, this class accepts all of the configuration options of <b><a href="Ext.data.JsonReader.html">JsonReader</a></b>.</p> <p>This class serves as a typed config object for constructor of class JsonStore.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.JsonStore
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='JsonWriter_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:DataWriter_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:attribute type='exml:Boolean' name='encode'>
          <xs:annotation>
            <xs:documentation>
              <tt>true</tt> to <a href="output/Ext.util.JSON.html#Ext.util.JSON-encode">JSON encode</a> the <a href="output/Ext.data.DataWriter.html#Ext.data.DataWriter-toHash">hashed data</a> into a standard HTTP parameter named after this Reader's <code>meta.root</code> property which, by default is imported from the associated Reader. Defaults to <tt>true</tt>. <p>If set to <code>false</code>, the hashed data is <a href="output/Ext.util.JSON.html#Ext.util.JSON-encode">JSON encoded</a>, along with the associated <a href="Ext.data.Store.html">Ext.data.Store</a>'s <a href="output/Ext.data.Store.html#Ext.data.Store-baseParams">baseParams</a>, into the POST body.</p><p>When using <a href="Ext.data.DirectProxy.html">Ext.data.DirectProxy</a>, set this to <tt>false</tt> since Ext.Direct.JsonProvider will perform its own json-encoding. In addition, if you're using <a href="Ext.data.HttpProxy.html">Ext.data.HttpProxy</a>, setting to <tt>false</tt> will cause HttpProxy to transmit data using the <b>jsonData</b> configuration-params of <a href="output/Ext.Ajax.html#Ext.Ajax-request">Ext.Ajax.request</a> instead of <b>params</b>.</p><p>When using a <a href="output/Ext.data.Store.html#Ext.data.Store-restful">Ext.data.Store.restful</a> Store, some serverside frameworks are tuned to expect data through the jsonData mechanism. In those cases, one will want to set <b>encode: <tt>false</tt></b>, as in let the lower-level connection object (eg: Ext.Ajax) do the encoding.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='encodeDelete'>
          <xs:annotation>
            <xs:documentation>
              False to send only the id to the server on delete, true to encode it in an object literal, eg: <pre><code>{id: 1} </code></pre>Defaults to <tt>false</tt>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='JsonWriter' type='ed:JsonWriter_TYPE' substitutionGroup='ed:DataWriter'>
    <xs:annotation>
      <xs:documentation>
        DataWriter extension for writing an array or single <a href="Ext.data.Record.html">Ext.data.Record</a> object(s) in preparation for executing a remote CRUD action. <p>This class serves as a typed config object for constructor of class JsonWriter.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.JsonWriter
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='Node_TYPE'>
    <xs:complexContent>
      <xs:extension base='eu:Observable_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:attribute type='exml:String' name='id'>
          <xs:annotation>
            <xs:documentation>
              The id for this node. If one is not specified, one is generated.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='leaf'>
          <xs:annotation>
            <xs:documentation>
              true if this node is a leaf and does not have children
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='Node' type='ed:Node_TYPE' substitutionGroup='eu:Observable'>
    <xs:annotation>
      <xs:documentation>
        <p>This class serves as a typed config object for constructor of class Node.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.Node
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='Request_TYPE'>
        <xs:sequence>
            <xs:element name='callback' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The function to call when request is complete
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='params' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  HTTP request params
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='reader' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The DataReader instance which will parse the received response
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='rs' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The Store recordset associated with the request.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='scope' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The scope of the callback function.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:String' name='action'>
          <xs:annotation>
            <xs:documentation>
              
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='callback'>
          <xs:annotation>
            <xs:documentation>
              The function to call when request is complete
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='params'>
          <xs:annotation>
            <xs:documentation>
              HTTP request params
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='reader'>
          <xs:annotation>
            <xs:documentation>
              The DataReader instance which will parse the received response
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='rs'>
          <xs:annotation>
            <xs:documentation>
              The Store recordset associated with the request.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='scope'>
          <xs:annotation>
            <xs:documentation>
              The scope of the callback function.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
  </xs:complexType>
  <xs:element name='Request' type='ed:Request_TYPE'>
    <xs:annotation>
      <xs:documentation>
        A simple Request class used internally to the data package to provide more generalized remote-requests to a DataProxy. TODO Not yet implemented. Implement in Ext.data.Store#execute <p>This class serves as a typed config object for constructor of class Request.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.Request
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='Response_TYPE'>
        <xs:sequence>
            <xs:element name='data' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='raw' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The raw response returned from server-code
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='records' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  related to the Request action
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:String' name='action'>
          <xs:annotation>
            <xs:documentation>
              <a href="output/Ext.data.Api.html#Ext.data.Api-actions">Ext.data.Api.actions</a>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='data'>
          <xs:annotation>
            <xs:documentation>
              
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='message'>
          <xs:annotation>
            <xs:documentation>
              
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='raw'>
          <xs:annotation>
            <xs:documentation>
              The raw response returned from server-code
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='records'>
          <xs:annotation>
            <xs:documentation>
              related to the Request action
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='success'>
          <xs:annotation>
            <xs:documentation>
              
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
  </xs:complexType>
  <xs:element name='Response' type='ed:Response_TYPE'>
    <xs:annotation>
      <xs:documentation>
        A generic response class to normalize response-handling internally to the framework. <p>This class serves as a typed config object for constructor of class Response.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.Response
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='ScriptTagProxy_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:DataProxy_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:attribute type='exml:String' name='callbackParam'>
          <xs:annotation>
            <xs:documentation>
              The name of the parameter to pass to the server which tells the server the name of the callback function set up by the load call to process the returned data object. Defaults to "callback".<p>The server-side processing must read this parameter value, and generate javascript output which calls this named function passing the data object as its only parameter.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='nocache'>
          <xs:annotation>
            <xs:documentation>
              Defaults to true. Disable caching by adding a unique parameter name to the request.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Number' name='timeout'>
          <xs:annotation>
            <xs:documentation>
              The number of milliseconds to wait for a response. Defaults to 30 seconds.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='url'>
          <xs:annotation>
            <xs:documentation>
              The URL from which to request the data object.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='ScriptTagProxy' type='ed:ScriptTagProxy_TYPE' substitutionGroup='ed:DataProxy'>
    <xs:annotation>
      <xs:documentation>
        An implementation of Ext.data.DataProxy that reads a data object from a URL which may be in a domain other than the originating domain of the running page. <p><b>Note that if you are retrieving data from a page that is in a domain that is NOT the same as the originating domain of the running page, you must use this class, rather than HttpProxy.</b><br/></p><p>The content passed back from a server resource requested by a ScriptTagProxy <b>must</b> be executable JavaScript source code because it is used as the source inside a &lt;script&gt; tag.<br/></p><p>In order for the browser to process the returned data, the server must wrap the data object with a call to a callback function, the name of which is passed as a parameter by the ScriptTagProxy. Below is a Java example for a servlet which returns data for either a ScriptTagProxy, or an HttpProxy depending on whether the callback name was passed:</p><pre><code>boolean scriptTag = false; String cb = request.getParameter("callback"); if (cb != null) { scriptTag = true; response.setContentType("text/javascript"); } else { response.setContentType("application/x-json"); } Writer out = response.getWriter(); if (scriptTag) { out.write(cb + "("); } out.print(dataBlock.toJsonString()); if (scriptTag) { out.write(");"); } </code></pre><p>Below is a PHP example to do the same thing:</p><pre><code>$callback = $_REQUEST['callback']; // Create the output object. $output = array('a' =&gt; 'Apple', 'b' =&gt; 'Banana'); //start output if ($callback) { header('Content-Type: text/javascript'); echo $callback . '(' . json_encode($output) . ');'; } else { header('Content-Type: application/x-json'); echo json_encode($output); } </code></pre><p>Below is the ASP.Net code to do the same thing:</p><pre><code>String jsonString = "{success: true}"; String cb = Request.Params.Get("callback"); String responseString = ""; if (!String.IsNullOrEmpty(cb)) { responseString = cb + "(" + jsonString + ")"; } else { responseString = jsonString; } Response.Write(responseString); </code></pre> <p>This class serves as a typed config object for constructor of class ScriptTagProxy.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.ScriptTagProxy
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='Store_TYPE'>
    <xs:complexContent>
      <xs:extension base='eu:Observable_TYPE'>
        <xs:sequence>
            <xs:element name='autoLoad' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  If <tt><a href="output/Ext.data.Store.html#Ext.data.Store-data">data</a></tt> is not specified, and if <tt>autoLoad</tt> is <tt>true</tt> or an <tt>Object</tt>, this store's <a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a> method is automatically called after creation. If the value of <tt>autoLoad</tt> is an <tt>Object</tt>, this <tt>Object</tt> will be passed to the store's <a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a> method.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='baseParams' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  An object containing properties which are to be sent as parameters for <i>every</i> HTTP request. <p>Parameters are encoded as standard HTTP parameters using <a href="output/Ext.html#Ext-urlEncode">Ext.urlEncode</a>.</p><p><b>Note</b>: <code>baseParams</code> may be superseded by any <code>params</code> specified in a <code><a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a></code> request, see <code><a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a></code> for more details.</p>This property may be modified after creation using the <code><a href="output/Ext.data.Store.html#Ext.data.Store-setBaseParam">setBaseParam</a></code> method.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='data' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  An inline data object readable by the <code><a href="output/Ext.data.Store.html#Ext.data.Store-reader">reader</a></code>. Typically this option, or the <code><a href="output/Ext.data.Store.html#Ext.data.Store-url">url</a></code> option will be specified.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
                <xs:attribute name="mode" type="exml:configMode"/>
              </xs:complexType>
            </xs:element>
            <xs:element name='defaultParamNames' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  Provides the default values for the <a href="output/Ext.data.Store.html#Ext.data.Store-paramNames">paramNames</a> property. To globally modify the parameters for all stores, this object should be changed on the store prototype.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='paramNames' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  An object containing properties which specify the names of the paging and sorting parameters passed to remote servers when loading blocks of data. By default, this object takes the following form: <pre><code>{ start : 'start', // The parameter name which specifies the start row limit : 'limit', // The parameter name which specifies number of rows to return sort : 'sort', // The parameter name which specifies the column to sort on dir : 'dir' // The parameter name which specifies the sort direction } </code></pre><p>The server must produce the requested data block upon receipt of these parameter names. If different parameter names are required, this property can be overridden using a configuration property.</p><p>A <a href="Ext.PagingToolbar.html">PagingToolbar</a> bound to this Store uses this property to determine the parameter names to use in its <a href="output/Ext.data.Store.html#Ext.data.Store-load">requests</a>.</p>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='proxy' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The <a href="Ext.data.DataProxy.html">DataProxy</a> object which provides access to a data object. See <code><a href="output/Ext.data.Store.html#Ext.data.Store-url">url</a></code>.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='reader' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The <a href="Ext.data.DataReader.html">Reader</a> object which processes the data object and returns an Array of <a href="Ext.data.Record.html">Ext.data.Record</a> objects which are cached keyed by their <b><tt><a href="output/Ext.data.Record.html#Ext.data.Record-id">id</a></tt></b> property.
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='sortInfo' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  A config object to specify the sort order in the request of a Store's <a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a> operation. Note that for local sorting, the <tt>direction</tt> property is case-sensitive. See also <a href="output/Ext.data.Store.html#Ext.data.Store-remoteSort">remoteSort</a> and <a href="output/Ext.data.Store.html#Ext.data.Store-paramNames">paramNames</a>. For example:<pre><code>sortInfo: { field: 'fieldName', direction: 'ASC' // or 'DESC' (case sensitive for local sorting) } </code></pre>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='writer' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The <a href="Ext.data.DataWriter.html">Writer</a> object which processes a record object for being written to the server-side database. <br/><p>When a writer is installed into a Store the <a href="output/Ext.data.Store.html#Ext.data.Store-add">add</a>, <a href="output/Ext.data.Store.html#Ext.data.Store-remove">remove</a>, and <a href="output/Ext.data.Store.html#Ext.data.Store-update">update</a> events on the store are monitored in order to remotely <a href="output/Ext.data.Store.html#Ext.data.Store-createRecords">create records</a>, <a href="output/Ext.data.Store.html#Ext.data.Store-destroyRecord">destroy records</a>, or <a href="output/Ext.data.Store.html#Ext.data.Store-updateRecord">update records</a>.</p><br/><p>The proxy for this store will relay any <a href="output/Ext.data.Store.html#Ext.data.Store-writexception">writexception</a> events to this store.</p><br/><p>Sample implementation:</p><pre><code>var writer = new <a href="Ext.data.JsonWriter.html">Ext.data.JsonWriter</a>({ encode: true, writeAllFields: true // write all fields, not just those that changed }); // Typical Store collecting the Proxy, Reader and Writer together. var store = new Ext.data.Store({ storeId: 'user', root: 'records', proxy: proxy, reader: reader, writer: writer, // &lt;-- plug a DataWriter into the store just as you would a Reader paramsAsHash: true, autoSave: false // &lt;-- false to delay executing create, update, destroy requests // until specifically told to do so. }); </code></pre><br/><br/>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:element name='fields' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  An Array defining the datafields for the Records stored in this Store. @see ext.config.datafield @see ext.data.Record
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
                <xs:attribute name="mode" type="exml:configMode"/>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:Boolean' name='autoDestroy'>
          <xs:annotation>
            <xs:documentation>
              <tt>true</tt> to destroy the store when the component the store is bound to is destroyed (defaults to <tt>false</tt>). <p><b>Note</b>: this should be set to true when using stores that are bound to only 1 component.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='autoLoad'>
          <xs:annotation>
            <xs:documentation>
              If <tt><a href="output/Ext.data.Store.html#Ext.data.Store-data">data</a></tt> is not specified, and if <tt>autoLoad</tt> is <tt>true</tt> or an <tt>Object</tt>, this store's <a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a> method is automatically called after creation. If the value of <tt>autoLoad</tt> is an <tt>Object</tt>, this <tt>Object</tt> will be passed to the store's <a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a> method.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='autoSave'>
          <xs:annotation>
            <xs:documentation>
              Defaults to <tt>true</tt> causing the store to automatically <a href="output/Ext.data.Store.html#Ext.data.Store-save">save</a> records to the server when a record is modified (ie: becomes 'dirty'). Specify <tt>false</tt> to manually call <a href="output/Ext.data.Store.html#Ext.data.Store-save">save</a> to send all modifiedRecords to the server. <br/><p><b>Note</b>: each CRUD action will be sent as a separate request.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='baseParams'>
          <xs:annotation>
            <xs:documentation>
              An object containing properties which are to be sent as parameters for <i>every</i> HTTP request. <p>Parameters are encoded as standard HTTP parameters using <a href="output/Ext.html#Ext-urlEncode">Ext.urlEncode</a>.</p><p><b>Note</b>: <code>baseParams</code> may be superseded by any <code>params</code> specified in a <code><a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a></code> request, see <code><a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a></code> for more details.</p>This property may be modified after creation using the <code><a href="output/Ext.data.Store.html#Ext.data.Store-setBaseParam">setBaseParam</a></code> method.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='batch'>
          <xs:annotation>
            <xs:documentation>
              Defaults to <tt>true</tt> (unless <code><a href="output/Ext.data.Store.html#Ext.data.Store-restful">restful</a>:true</code>). Multiple requests for each CRUD action (CREATE, READ, UPDATE and DESTROY) will be combined and sent as one transaction. Only applies when <code><a href="output/Ext.data.Store.html#Ext.data.Store-autoSave">autoSave</a></code> is set to <tt>false</tt>. <br/><p>If Store is RESTful, the DataProxy is also RESTful, and a unique transaction is generated for each record.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='data'>
          <xs:annotation>
            <xs:documentation>
              An inline data object readable by the <code><a href="output/Ext.data.Store.html#Ext.data.Store-reader">reader</a></code>. Typically this option, or the <code><a href="output/Ext.data.Store.html#Ext.data.Store-url">url</a></code> option will be specified.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='defaultParamNames'>
          <xs:annotation>
            <xs:documentation>
              Provides the default values for the <a href="output/Ext.data.Store.html#Ext.data.Store-paramNames">paramNames</a> property. To globally modify the parameters for all stores, this object should be changed on the store prototype.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='paramNames'>
          <xs:annotation>
            <xs:documentation>
              An object containing properties which specify the names of the paging and sorting parameters passed to remote servers when loading blocks of data. By default, this object takes the following form: <pre><code>{ start : 'start', // The parameter name which specifies the start row limit : 'limit', // The parameter name which specifies number of rows to return sort : 'sort', // The parameter name which specifies the column to sort on dir : 'dir' // The parameter name which specifies the sort direction } </code></pre><p>The server must produce the requested data block upon receipt of these parameter names. If different parameter names are required, this property can be overridden using a configuration property.</p><p>A <a href="Ext.PagingToolbar.html">PagingToolbar</a> bound to this Store uses this property to determine the parameter names to use in its <a href="output/Ext.data.Store.html#Ext.data.Store-load">requests</a>.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='proxy'>
          <xs:annotation>
            <xs:documentation>
              The <a href="Ext.data.DataProxy.html">DataProxy</a> object which provides access to a data object. See <code><a href="output/Ext.data.Store.html#Ext.data.Store-url">url</a></code>.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='pruneModifiedRecords'>
          <xs:annotation>
            <xs:documentation>
              <tt>true</tt> to clear all modified record information each time the store is loaded or when a record is removed (defaults to <tt>false</tt>). See <a href="output/Ext.data.Store.html#Ext.data.Store-getModifiedRecords">getModifiedRecords</a> for the accessor method to retrieve the modified records.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='reader'>
          <xs:annotation>
            <xs:documentation>
              The <a href="Ext.data.DataReader.html">Reader</a> object which processes the data object and returns an Array of <a href="Ext.data.Record.html">Ext.data.Record</a> objects which are cached keyed by their <b><tt><a href="output/Ext.data.Record.html#Ext.data.Record-id">id</a></tt></b> property.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='remoteSort'>
          <xs:annotation>
            <xs:documentation>
              <tt>true</tt> if sorting is to be handled by requesting the <tt><a href="output/Ext.data.Store.html#Ext.data.Store-proxy">Proxy</a></tt> to provide a refreshed version of the data object in sorted order, as opposed to sorting the Record cache in place (defaults to <tt>false</tt>). <p>If <tt>remoteSort</tt> is <tt>true</tt>, then clicking on a <a href="Ext.grid.Column.html">Grid Column</a>'s <a href="output/Ext.grid.Column.html#Ext.grid.Column-header">header</a> causes the current page to be requested from the server appending the following two parameters to the <b><tt><a href="output/Ext.data.Store.html#Ext.data.Store-load">params</a></tt></b>:</p><div class="mdetail-params"><ul><li><b><tt>sort</tt></b> : String<p class="sub-desc">The <tt>name</tt> (as specified in the Record's <a href="Ext.data.Field.html">Field definition</a>) of the field to sort on.</p></li><li><b><tt>dir</tt></b> : String<p class="sub-desc">The direction of the sort, 'ASC' or 'DESC' (case-sensitive).</p></li></ul></div><br/><br/>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='restful'>
          <xs:annotation>
            <xs:documentation>
              Defaults to <tt>false</tt>. Set to <tt>true</tt> to have the Store and the set Proxy operate in a RESTful manner. The store will automatically generate GET, POST, PUT and DELETE requests to the server. The HTTP method used for any given CRUD action is described in <a href="output/Ext.data.Api.html#Ext.data.Api-restActions">Ext.data.Api.restActions</a>. For additional information see <a href="output/Ext.data.DataProxy.html#Ext.data.DataProxy-restful">Ext.data.DataProxy.restful</a>. <p><b>Note</b>: if <code><a href="output/Ext.data.Store.html#Ext.data.Store-restful">restful</a>:true</code> <code>batch</code> will internally be set to <tt>false</tt>.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='sortInfo'>
          <xs:annotation>
            <xs:documentation>
              A config object to specify the sort order in the request of a Store's <a href="output/Ext.data.Store.html#Ext.data.Store-load">load</a> operation. Note that for local sorting, the <tt>direction</tt> property is case-sensitive. See also <a href="output/Ext.data.Store.html#Ext.data.Store-remoteSort">remoteSort</a> and <a href="output/Ext.data.Store.html#Ext.data.Store-paramNames">paramNames</a>. For example:<pre><code>sortInfo: { field: 'fieldName', direction: 'ASC' // or 'DESC' (case sensitive for local sorting) } </code></pre>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='storeId'>
          <xs:annotation>
            <xs:documentation>
              If passed, the id to use to register with the <b><a href="Ext.StoreMgr.html">StoreMgr</a></b>. <p><b>Note</b>: if a (deprecated) <tt><a href="output/Ext.data.Store.html#Ext.data.Store-id">id</a></tt> is specified it will supersede the <tt>storeId</tt> assignment.</p>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='url'>
          <xs:annotation>
            <xs:documentation>
              If a <tt><a href="output/Ext.data.Store.html#Ext.data.Store-proxy">proxy</a></tt> is not specified the <tt>url</tt> will be used to implicitly configure a <a href="Ext.data.HttpProxy.html">HttpProxy</a> if an <tt>url</tt> is specified. Typically this option, or the <code><a href="output/Ext.data.Store.html#Ext.data.Store-data">data</a></code> option will be specified.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='writer'>
          <xs:annotation>
            <xs:documentation>
              The <a href="Ext.data.DataWriter.html">Writer</a> object which processes a record object for being written to the server-side database. <br/><p>When a writer is installed into a Store the <a href="output/Ext.data.Store.html#Ext.data.Store-add">add</a>, <a href="output/Ext.data.Store.html#Ext.data.Store-remove">remove</a>, and <a href="output/Ext.data.Store.html#Ext.data.Store-update">update</a> events on the store are monitored in order to remotely <a href="output/Ext.data.Store.html#Ext.data.Store-createRecords">create records</a>, <a href="output/Ext.data.Store.html#Ext.data.Store-destroyRecord">destroy records</a>, or <a href="output/Ext.data.Store.html#Ext.data.Store-updateRecord">update records</a>.</p><br/><p>The proxy for this store will relay any <a href="output/Ext.data.Store.html#Ext.data.Store-writexception">writexception</a> events to this store.</p><br/><p>Sample implementation:</p><pre><code>var writer = new <a href="Ext.data.JsonWriter.html">Ext.data.JsonWriter</a>({ encode: true, writeAllFields: true // write all fields, not just those that changed }); // Typical Store collecting the Proxy, Reader and Writer together. var store = new Ext.data.Store({ storeId: 'user', root: 'records', proxy: proxy, reader: reader, writer: writer, // &lt;-- plug a DataWriter into the store just as you would a Reader paramsAsHash: true, autoSave: false // &lt;-- false to delay executing create, update, destroy requests // until specifically told to do so. }); </code></pre><br/><br/>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='fields'>
          <xs:annotation>
            <xs:documentation>
              An Array defining the datafields for the Records stored in this Store. @see ext.config.datafield @see ext.data.Record
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='Store' type='ed:Store_TYPE' substitutionGroup='eu:Observable'>
    <xs:annotation>
      <xs:documentation>
        The Store class encapsulates a client side cache of <a href="Ext.data.Record.html">Record</a> objects which provide input data for Components such as the <a href="Ext.grid.GridPanel.html">GridPanel</a>, the <a href="Ext.form.ComboBox.html">ComboBox</a>, or the <a href="Ext.DataView.html">DataView</a>. <p><u>Retrieving Data</u></p><p>A Store object may access a data object using:</p><div class="mdetail-params"><ul><li><a href="output/Ext.data.Store.html#Ext.data.Store-proxy">configured implementation</a> of <a href="Ext.data.DataProxy.html">DataProxy</a></li><li><a href="output/Ext.data.Store.html#Ext.data.Store-data">data</a> to automatically pass in data</li><li><a href="output/Ext.data.Store.html#Ext.data.Store-loadData">loadData</a> to manually pass in data</li></ul></div><br/><br/> <p><u>Reading Data</u></p><p>A Store object has no inherent knowledge of the format of the data object (it could be an Array, XML, or JSON). A Store object uses an appropriate <a href="output/Ext.data.Store.html#Ext.data.Store-reader">configured implementation</a> of a <a href="Ext.data.DataReader.html">DataReader</a> to create <a href="Ext.data.Record.html">Record</a> instances from the data object.</p><p><u>Store Types</u></p><p>There are several implementations of Store available which are customized for use with a specific DataReader implementation. Here is an example using an ArrayStore which implicitly creates a reader commensurate to an Array data object.</p><pre><code>var myStore = new Ext.data.ArrayStore({ fields: ['fullname', 'first'], idIndex: 0 // id for each record will be the first element }); </code></pre><p>For custom implementations create a basic <a href="Ext.data.Store.html">Ext.data.Store</a> configured as needed:</p><pre><code>// create a <a href="Ext.data.Record.html">Record</a> constructor: var rt = Ext.data.Record.create([ {name: 'fullname'}, {name: 'first'} ]); var myStore = new Ext.data.Store({ // explicitly create reader reader: new Ext.data.ArrayReader( { idIndex: 0 // id for each record will be the first element }, rt // recordType ) }); </code></pre><p>Load some data into store (note the data object is an array which corresponds to the reader):</p><pre><code>var myData = [ [1, 'Fred Flintstone', 'Fred'], // note that id for the record is the first element [2, 'Barney Rubble', 'Barney'] ]; myStore.loadData(myData); </code></pre><p>Records are cached and made available through accessor functions. An example of adding a record to the store:</p><pre><code>var defaultData = { fullname: 'Full Name', first: 'First Name' }; var recId = 100; // provide unique id for the record var r = new myStore.recordType(defaultData, ++recId); // create new record myStore.<a href="output/Ext.data.Store.html#Ext.data.Store-insert">insert</a>(0, r); // insert a new record into the store (also see <a href="output/Ext.data.Store.html#Ext.data.Store-add">add</a>) </code></pre><p><u>Writing Data</u></p><p>And <b>new in Ext version 3</b>, use the new <a href="Ext.data.DataWriter.html">DataWriter</a> to create an automated, <a href="http://extjs.com/deploy/dev/examples/writer/writer.html">Writable Store</a> along with <a href="http://extjs.com/deploy/dev/examples/restful/restful.html">RESTful features.</a></p> <p>This class serves as a typed config object for constructor of class Store.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.Store
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='Tree_TYPE'>
    <xs:complexContent>
      <xs:extension base='eu:Observable_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:attribute type='exml:String' name='pathSeparator'>
          <xs:annotation>
            <xs:documentation>
              The token used to separate paths in node ids (defaults to '/').
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='Tree' type='ed:Tree_TYPE' substitutionGroup='eu:Observable'>
    <xs:annotation>
      <xs:documentation>
        Represents a tree data structure and bubbles all the events for its nodes. The nodes in the tree have most standard DOM functionality. <p>This class serves as a typed config object for constructor of class Tree.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.Tree
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='XmlReader_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:DataReader_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:attribute type='exml:String' name='idPath'>
          <xs:annotation>
            <xs:documentation>
              The DomQuery path relative from the record element to the element that contains a record identifier value.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='record'>
          <xs:annotation>
            <xs:documentation>
              The DomQuery path to the repeated element which contains record information.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='successProperty'>
          <xs:annotation>
            <xs:documentation>
              The DomQuery path to the success attribute used by forms.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='totalProperty'>
          <xs:annotation>
            <xs:documentation>
              The DomQuery path from which to retrieve the total number of records in the dataset. This is only needed if the whole dataset is not passed in one go, but is being paged from the remote server.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='XmlReader' type='ed:XmlReader_TYPE' substitutionGroup='ed:DataReader'>
    <xs:annotation>
      <xs:documentation>
        Data reader class to create an Array of <a href="Ext.data.Record.html">Ext.data.Record</a> objects from an XML document based on mappings in a provided <a href="Ext.data.Record.html">Ext.data.Record</a> constructor. <p><b>Note</b>: that in order for the browser to parse a returned XML document, the Content-Type header in the HTTP response must be set to "text/xml" or "application/xml".</p><p>Example code:</p><pre><code>var Employee = Ext.data.Record.create([ {name: 'name', mapping: 'name'}, // "mapping" property not needed if it is the same as "name" {name: 'occupation'} // This field will use "occupation" as the mapping. ]); var myReader = new Ext.data.XmlReader({ totalProperty: "results", // The element which contains the total dataset size (optional) record: "row", // The repeated element which contains row information idProperty: "id" // The element within the row that provides an ID for the record (optional) messageProperty: "msg" // The element within the response that provides a user-feedback message (optional) }, Employee); </code></pre><p>This would consume an XML file like this:</p><pre><code>&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;dataset&gt; &lt;results&gt;2&lt;/results&gt; &lt;row&gt; &lt;id&gt;1&lt;/id&gt; &lt;name&gt;Bill&lt;/name&gt; &lt;occupation&gt;Gardener&lt;/occupation&gt; &lt;/row&gt; &lt;row&gt; &lt;id&gt;2&lt;/id&gt; &lt;name&gt;Ben&lt;/name&gt; &lt;occupation&gt;Horticulturalist&lt;/occupation&gt; &lt;/row&gt; &lt;/dataset&gt; </code></pre> <p>This class serves as a typed config object for constructor of class XmlReader.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.XmlReader
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='XmlStore_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:Store_TYPE'>
        <xs:sequence>
        </xs:sequence>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='XmlStore' type='ed:XmlStore_TYPE' substitutionGroup='ed:Store'>
    <xs:annotation>
      <xs:documentation>
        Small helper class to make creating <a href="Ext.data.Store.html">Ext.data.Store</a>s from XML data easier. A XmlStore will be automatically configured with a <a href="Ext.data.XmlReader.html">Ext.data.XmlReader</a>. <p>A store configuration would be something like:</p><pre><code>var store = new Ext.data.XmlStore({ // store configs autoDestroy: true, storeId: 'myStore', url: 'sheldon.xml', // automatically configures a HttpProxy // reader configs record: 'Item', // records will have an "Item" tag idPath: 'ASIN', totalRecords: '&#64;TotalResults' fields: [ // set up the fields mapping into the xml doc // The first needs mapping, the others are very basic {name: 'Author', mapping: 'ItemAttributes &gt; Author'}, 'Title', 'Manufacturer', 'ProductGroup' ] }); </code></pre><br/><br/> <p>This store is configured to consume a returned object of the form:</p><pre><code>&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;ItemSearchResponse xmlns="http://webservices.amazon.com/AWSECommerceService/2009-05-15"&gt; &lt;Items&gt; &lt;Request&gt; &lt;IsValid&gt;True&lt;/IsValid&gt; &lt;ItemSearchRequest&gt; &lt;Author&gt;Sidney Sheldon&lt;/Author&gt; &lt;SearchIndex&gt;Books&lt;/SearchIndex&gt; &lt;/ItemSearchRequest&gt; &lt;/Request&gt; &lt;TotalResults&gt;203&lt;/TotalResults&gt; &lt;TotalPages&gt;21&lt;/TotalPages&gt; &lt;Item&gt; &lt;ASIN&gt;0446355453&lt;/ASIN&gt; &lt;DetailPageURL&gt; http://www.amazon.com/ &lt;/DetailPageURL&gt; &lt;ItemAttributes&gt; &lt;Author&gt;Sidney Sheldon&lt;/Author&gt; &lt;Manufacturer&gt;Warner Books&lt;/Manufacturer&gt; &lt;ProductGroup&gt;Book&lt;/ProductGroup&gt; &lt;Title&gt;Master of the Game&lt;/Title&gt; &lt;/ItemAttributes&gt; &lt;/Item&gt; &lt;/Items&gt; &lt;/ItemSearchResponse&gt; </code></pre>An object literal of this form could also be used as the <a href="output/Ext.data.XmlStore.html#Ext.data.XmlStore-data">data</a> config option.<br/><br/> <p><b>Note:</b> Although not listed here, this class accepts all of the configuration options of <b><a href="Ext.data.XmlReader.html">XmlReader</a></b>.</p> <p>This class represents serves as a typed config object for constructor of class XmlStore.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.XmlStore
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:complexType name='XmlWriter_TYPE'>
    <xs:complexContent>
      <xs:extension base='ed:DataWriter_TYPE'>
        <xs:sequence>
            <xs:element name='tpl' minOccurs="0" maxOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  The XML template used to render <a href="output/Ext.data.Api.html#Ext.data.Api-actions">write-actions</a> to your server. <p>One can easily provide his/her own custom <a href="output/Ext.XTemplate.html#Ext.XTemplate-constructor">template-definition</a> if the default does not suffice.</p><p>Defaults to:</p><pre><code>&lt;?xml version="{version}" encoding="{encoding}"?&gt; &lt;tpl if="documentRoot"&gt;&lt;{documentRoot}&gt; &lt;tpl for="baseParams"&gt; &lt;tpl for="."&gt; &lt;{name}&gt;{value}&lt;/{name}&gt; &lt;/tpl&gt; &lt;/tpl&gt; &lt;tpl if="records.length &gt; 1"&gt;&lt;{root}&gt;', &lt;tpl for="records"&gt; &lt;{parent.record}&gt; &lt;tpl for="."&gt; &lt;{name}&gt;{value}&lt;/{name}&gt; &lt;/tpl&gt; &lt;/{parent.record}&gt; &lt;/tpl&gt; &lt;tpl if="records.length &gt; 1"&gt;&lt;/{root}&gt;&lt;/tpl&gt; &lt;tpl if="documentRoot"&gt;&lt;/{documentRoot}&gt;&lt;/tpl&gt; </code></pre><p>Templates will be called with the following API</p><ul><li>{String} version [1.0] The xml version.</li><li>{String} encoding [ISO-8859-15] The xml encoding.</li><li>{String/false} documentRoot The XML document root-node name or <tt>false</tt> if not required. See <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-documentRoot">documentRoot</a> and <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-forceDocumentRoot">forceDocumentRoot</a>.</li><li>{String} record The meta-data parameter defined on your <a href="output/Ext.data.XmlReader.html#Ext.data.XmlReader-record">Ext.data.XmlReader.record</a> configuration represents the name of the xml-tag containing each record.</li><li>{String} root The meta-data parameter defined by <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-root">Ext.data.XmlWriter.root</a> configuration-parameter. Represents the name of the xml root-tag when sending <b>multiple</b> records to the server.</li><li>{Array} records The records being sent to the server, ie: the subject of the write-action being performed. The records parameter will be always be an array, even when only a single record is being acted upon. Each item within the records array will contain an array of field objects having the following properties: <ul><li>{String} name The field-name of the record as defined by your <a href="output/Ext.data.Record.html#Ext.data.Record-create">Ext.data.Record definition</a>. The "mapping" property will be used, otherwise it will match the "name" property. Use this parameter to define the XML tag-name of the property.</li><li>{Mixed} value The record value of the field enclosed within XML tags specified by name property above.</li></ul></li><li>{Array} baseParams. The baseParams as defined upon <a href="output/Ext.data.Store.html#Ext.data.Store-baseParams">Ext.data.Store.baseParams</a>. Note that the baseParams have been converted into an array of [{name : "foo", value: "bar"}, ...] pairs in the same manner as the <b>records</b> parameter above. See <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-documentRoot">documentRoot</a> and <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-forceDocumentRoot">forceDocumentRoot</a>.</li></ul>
                </xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute type='exml:String' name='documentRoot'>
          <xs:annotation>
            <xs:documentation>
              [xrequest] (Optional) The name of the XML document root-node. <b>Note:</b> this parameter is required only when sending extra <a href="output/Ext.data.Store.html#Ext.data.Store-baseParams">baseParams</a> to the server during a write-request -- if no baseParams are set, the <a href="output/Ext.data.XmlReader.html#Ext.data.XmlReader-record">Ext.data.XmlReader.record</a> meta-property can suffice as the XML document root-node for write-actions involving just a <b>single record</b>. For requests involving <b>multiple</b> records and <b>NO</b> baseParams, the <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-root">Ext.data.XmlWriter.root</a> property can act as the XML document root.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:Boolean' name='forceDocumentRoot'>
          <xs:annotation>
            <xs:documentation>
              [false] Set to <tt>true</tt> to force XML documents having a root-node as defined by <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-documentRoot">documentRoot</a>, even with no baseParams defined.
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='root'>
          <xs:annotation>
            <xs:documentation>
              [records] The name of the containing element which will contain the nodes of an write-action involving <b>multiple</b> records. Each xml-record written to the server will be wrapped in an element named after <a href="output/Ext.data.XmlReader.html#Ext.data.XmlReader-record">Ext.data.XmlReader.record</a> property. eg: <pre><code>&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;user&gt;&lt;first&gt;Barney&lt;/first&gt;&lt;/user&gt; </code></pre>However, when <b>multiple</b> records are written in a batch-operation, these records must be wrapped in a containing Element. eg: <pre><code>&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;records&gt; &lt;first&gt;Barney&lt;/first&gt;&lt;/user&gt; &lt;records&gt;&lt;first&gt;Barney&lt;/first&gt;&lt;/user&gt; &lt;/records&gt; </code></pre>Defaults to <tt>records</tt>. Do not confuse the nature of this property with that of <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-documentRoot">documentRoot</a>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='tpl'>
          <xs:annotation>
            <xs:documentation>
              The XML template used to render <a href="output/Ext.data.Api.html#Ext.data.Api-actions">write-actions</a> to your server. <p>One can easily provide his/her own custom <a href="output/Ext.XTemplate.html#Ext.XTemplate-constructor">template-definition</a> if the default does not suffice.</p><p>Defaults to:</p><pre><code>&lt;?xml version="{version}" encoding="{encoding}"?&gt; &lt;tpl if="documentRoot"&gt;&lt;{documentRoot}&gt; &lt;tpl for="baseParams"&gt; &lt;tpl for="."&gt; &lt;{name}&gt;{value}&lt;/{name}&gt; &lt;/tpl&gt; &lt;/tpl&gt; &lt;tpl if="records.length &gt; 1"&gt;&lt;{root}&gt;', &lt;tpl for="records"&gt; &lt;{parent.record}&gt; &lt;tpl for="."&gt; &lt;{name}&gt;{value}&lt;/{name}&gt; &lt;/tpl&gt; &lt;/{parent.record}&gt; &lt;/tpl&gt; &lt;tpl if="records.length &gt; 1"&gt;&lt;/{root}&gt;&lt;/tpl&gt; &lt;tpl if="documentRoot"&gt;&lt;/{documentRoot}&gt;&lt;/tpl&gt; </code></pre><p>Templates will be called with the following API</p><ul><li>{String} version [1.0] The xml version.</li><li>{String} encoding [ISO-8859-15] The xml encoding.</li><li>{String/false} documentRoot The XML document root-node name or <tt>false</tt> if not required. See <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-documentRoot">documentRoot</a> and <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-forceDocumentRoot">forceDocumentRoot</a>.</li><li>{String} record The meta-data parameter defined on your <a href="output/Ext.data.XmlReader.html#Ext.data.XmlReader-record">Ext.data.XmlReader.record</a> configuration represents the name of the xml-tag containing each record.</li><li>{String} root The meta-data parameter defined by <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-root">Ext.data.XmlWriter.root</a> configuration-parameter. Represents the name of the xml root-tag when sending <b>multiple</b> records to the server.</li><li>{Array} records The records being sent to the server, ie: the subject of the write-action being performed. The records parameter will be always be an array, even when only a single record is being acted upon. Each item within the records array will contain an array of field objects having the following properties: <ul><li>{String} name The field-name of the record as defined by your <a href="output/Ext.data.Record.html#Ext.data.Record-create">Ext.data.Record definition</a>. The "mapping" property will be used, otherwise it will match the "name" property. Use this parameter to define the XML tag-name of the property.</li><li>{Mixed} value The record value of the field enclosed within XML tags specified by name property above.</li></ul></li><li>{Array} baseParams. The baseParams as defined upon <a href="output/Ext.data.Store.html#Ext.data.Store-baseParams">Ext.data.Store.baseParams</a>. Note that the baseParams have been converted into an array of [{name : "foo", value: "bar"}, ...] pairs in the same manner as the <b>records</b> parameter above. See <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-documentRoot">documentRoot</a> and <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-forceDocumentRoot">forceDocumentRoot</a>.</li></ul>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='xmlEncoding'>
          <xs:annotation>
            <xs:documentation>
              [ISO-8859-15] The <tt>encoding</tt> written to header of xml documents. <pre><code>&lt;?xml version="1.0" encoding="ISO-8859-15"?&gt;</code></pre>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute type='exml:String' name='xmlVersion'>
          <xs:annotation>
            <xs:documentation>
              [1.0] The <tt>version</tt> written to header of xml documents. <pre><code>&lt;?xml version="1.0" encoding="ISO-8859-15"?&gt;</code></pre>
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:anyAttribute namespace="http://www.jangaroo.net/exml/0.8 exml:untyped" processContents="skip"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name='XmlWriter' type='ed:XmlWriter_TYPE' substitutionGroup='ed:DataWriter'>
    <xs:annotation>
      <xs:documentation>
        DataWriter extension for writing an array or single <a href="Ext.data.Record.html">Ext.data.Record</a> object(s) in preparation for executing a remote CRUD action via XML. XmlWriter uses an instance of <a href="Ext.XTemplate.html">Ext.XTemplate</a> for maximum flexibility in defining your own custom XML schema if the default schema is not appropriate for your needs. See the <a href="output/Ext.data.XmlWriter.html#Ext.data.XmlWriter-tpl">tpl</a> configuration-property. <p>This class serves as a typed config object for constructor of class XmlWriter.</p> <p>Copyright &#169; 2011 Sencha Inc.</p> @see ext.data.XmlWriter
      </xs:documentation>
    </xs:annotation>
  </xs:element>
</xs:schema>
New to GrepCode? Check out our FAQ X