git.ithinksw.org / extjs.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Upgrade to ExtJS 4.0.7 - Released 10/19/2011
[extjs.git] / docs / source / Types.html
diff --git a/docs/source/Types.html b/docs/source/Types.html
index c022061..3c8b1a4 100644 (file)
--- a/docs/source/Types.html
+++ b/docs/source/Types.html
@@ -1,41 +1,44 @@
+<!DOCTYPE html>
 <html>
 <head>
 <html>
 <head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />    
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   <title>The source code</title>
   <title>The source code</title>
-    <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
-    <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
+  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
+  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
+  <style type="text/css">
+    .highlight { display: block; background-color: #ddd; }
+  </style>
+  <script type="text/javascript">
+    function highlight() {
+      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
+    }
+  </script>
 </head>
 </head>
-<body  onload="prettyPrint();">
-    <pre class="prettyprint lang-js">/*!
- * Ext JS Library 3.2.0
- * Copyright(c) 2006-2010 Ext JS, Inc.
- * licensing@extjs.com
- * http://www.extjs.com/license
- */
-<div id="cls-Ext.data.Types"></div>/**
- * @class Ext.data.Types
- * <p>This is s static class containing the system-supplied data types which may be given to a {@link Ext.data.Field Field}.<p/>
- * <p>The properties in this class are used as type indicators in the {@link Ext.data.Field Field} class, so to
+<body onload="prettyPrint(); highlight();">
+  <pre class="prettyprint lang-js"><span id='Ext-data-Types'>/**
+</span> * @class Ext.data.Types
+ * &lt;p&gt;This is a static class containing the system-supplied data types which may be given to a {@link Ext.data.Field Field}.&lt;p/&gt;
+ * &lt;p&gt;The properties in this class are used as type indicators in the {@link Ext.data.Field Field} class, so to
  * test whether a Field is of a certain type, compare the {@link Ext.data.Field#type type} property against properties
  * test whether a Field is of a certain type, compare the {@link Ext.data.Field#type type} property against properties
- * of this class.</p>
- * <p>Developers may add their own application-specific data types to this class. Definition names must be UPPERCASE.
- * each type definition must contain three properties:</p>
- * <div class="mdetail-params"><ul>
- * <li><code>convert</code> : <i>Function</i><div class="sub-desc">A function to convert raw data values from a data block into the data
+ * of this class.&lt;/p&gt;
+ * &lt;p&gt;Developers may add their own application-specific data types to this class. Definition names must be UPPERCASE.
+ * each type definition must contain three properties:&lt;/p&gt;
+ * &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
+ * &lt;li&gt;&lt;code&gt;convert&lt;/code&gt; : &lt;i&gt;Function&lt;/i&gt;&lt;div class=&quot;sub-desc&quot;&gt;A function to convert raw data values from a data block into the data
  * to be stored in the Field. The function is passed the collowing parameters:
  * to be stored in the Field. The function is passed the collowing 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 <tt>{@link Ext.data.Field#defaultValue defaultValue}</tt>.</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 ({@link Ext.data.ArrayReader ArrayReader}), an object
- * ({@link Ext.data.JsonReader JsonReader}), or an XML element ({@link Ext.data.XMLReader XMLReader}).</div></li>
- * </ul></div></div></li>
- * <li><code>sortType</code> : <i>Function</i> <div class="sub-desc">A function to convert the stored data into comparable form, as defined by {@link Ext.data.SortTypes}.</div></li>
- * <li><code>type</code> : <i>String</i> <div class="sub-desc">A textual data type name.</div></li>
- * </ul></div>
- * <p>For example, to create a VELatLong field (See the Microsoft Bing Mapping API) containing the latitude/longitude value of a datapoint on a map from a JsonReader data block
- * which contained the properties <code>lat</code> and <code>long</code>, you would define a new data type like this:</p>
- *<pre><code>
+ * &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
+ * &lt;li&gt;&lt;b&gt;v&lt;/b&gt; : Mixed&lt;div class=&quot;sub-desc&quot;&gt;The data value as read by the Reader, if undefined will use
+ * the configured &lt;tt&gt;{@link Ext.data.Field#defaultValue defaultValue}&lt;/tt&gt;.&lt;/div&gt;&lt;/li&gt;
+ * &lt;li&gt;&lt;b&gt;rec&lt;/b&gt; : Mixed&lt;div class=&quot;sub-desc&quot;&gt;The data object containing the row as read by the Reader.
+ * Depending on the Reader type, this could be an Array ({@link Ext.data.reader.Array ArrayReader}), an object
+ * ({@link Ext.data.reader.Json JsonReader}), or an XML element.&lt;/div&gt;&lt;/li&gt;
+ * &lt;/ul&gt;&lt;/div&gt;&lt;/div&gt;&lt;/li&gt;
+ * &lt;li&gt;&lt;code&gt;sortType&lt;/code&gt; : &lt;i&gt;Function&lt;/i&gt; &lt;div class=&quot;sub-desc&quot;&gt;A function to convert the stored data into comparable form, as defined by {@link Ext.data.SortTypes}.&lt;/div&gt;&lt;/li&gt;
+ * &lt;li&gt;&lt;code&gt;type&lt;/code&gt; : &lt;i&gt;String&lt;/i&gt; &lt;div class=&quot;sub-desc&quot;&gt;A textual data type name.&lt;/div&gt;&lt;/li&gt;
+ * &lt;/ul&gt;&lt;/div&gt;
+ * &lt;p&gt;For example, to create a VELatLong field (See the Microsoft Bing Mapping API) containing the latitude/longitude value of a datapoint on a map from a JsonReader data block
+ * which contained the properties &lt;code&gt;lat&lt;/code&gt; and &lt;code&gt;long&lt;/code&gt;, you would define a new data type like this:&lt;/p&gt;
+ *&lt;pre&gt;&lt;code&gt;
 // Add a new Field data type which stores a VELatLong object in the Record.
 Ext.data.Types.VELATLONG = {
     convert: function(v, data) {
 // Add a new Field data type which stores a VELatLong object in the Record.
 Ext.data.Types.VELATLONG = {
     convert: function(v, data) {
@@ -46,152 +49,165 @@ Ext.data.Types.VELATLONG = {
     },
     type: 'VELatLong'
 };
     },
     type: 'VELatLong'
 };
-</code></pre>
- * <p>Then, when declaring a Record, use <pre><code>
+&lt;/code&gt;&lt;/pre&gt;
+ * &lt;p&gt;Then, when declaring a Model, use: &lt;pre&gt;&lt;code&gt;
 var types = Ext.data.Types; // allow shorthand type access
 var types = Ext.data.Types; // allow shorthand type access
-UnitRecord = Ext.data.Record.create([
-    { name: 'unitName', mapping: 'UnitName' },
-    { name: 'curSpeed', mapping: 'CurSpeed', type: types.INT },
-    { name: 'latitude', mapping: 'lat', type: types.FLOAT },
-    { name: 'latitude', mapping: 'lat', type: types.FLOAT },
-    { name: 'position', type: types.VELATLONG }
-]);
-</code></pre>
+Ext.define('Unit',
+    extend: 'Ext.data.Model',
+    fields: [
+        { name: 'unitName', mapping: 'UnitName' },
+        { name: 'curSpeed', mapping: 'CurSpeed', type: types.INT },
+        { name: 'latitude', mapping: 'lat', type: types.FLOAT },
+        { name: 'longitude', mapping: 'long', type: types.FLOAT },
+        { name: 'position', type: types.VELATLONG }
+    ]
+});
+&lt;/code&gt;&lt;/pre&gt;
  * @singleton
  */
  * @singleton
  */
-Ext.data.Types = new function(){
+Ext.define('Ext.data.Types', {
+    singleton: true,
+    requires: ['Ext.data.SortTypes']
+}, function() {
     var st = Ext.data.SortTypes;
     var st = Ext.data.SortTypes;
-    Ext.apply(this, {
-        <div id="prop-Ext.data.Types-stripRe"></div>/**
-         * @type Regexp
-         * @property stripRe
-         * A regular expression for stripping non-numeric characters from a numeric value. Defaults to <tt>/[\$,%]/g</tt>.
+
+    Ext.apply(Ext.data.Types, {
+<span id='Ext-data-Types-property-stripRe'>        /**
+</span>         * @property {RegExp} stripRe
+         * A regular expression for stripping non-numeric characters from a numeric value. Defaults to &lt;tt&gt;/[\$,%]/g&lt;/tt&gt;.
          * This should be overridden for localization.
          */
         stripRe: /[\$,%]/g,
          * This should be overridden for localization.
          */
         stripRe: /[\$,%]/g,
-        
-        <div id="prop-Ext.data.Types-AUTO"></div>/**
-         * @type Object.
-         * @property AUTO
+
+<span id='Ext-data-Types-property-AUTO'>        /**
+</span>         * @property {Object} AUTO
          * This data type means that no conversion is applied to the raw data before it is placed into a Record.
          */
         AUTO: {
          * This data type means that no conversion is applied to the raw data before it is placed into a Record.
          */
         AUTO: {
-            convert: function(v){ return v; },
+            convert: function(v) {
+                return v;
+            },
             sortType: st.none,
             type: 'auto'
         },
 
             sortType: st.none,
             type: 'auto'
         },
 
-        <div id="prop-Ext.data.Types-STRING"></div>/**
-         * @type Object.
-         * @property STRING
+<span id='Ext-data-Types-property-STRING'>        /**
+</span>         * @property {Object} STRING
          * This data type means that the raw data is converted into a String before it is placed into a Record.
          */
         STRING: {
          * This data type means that the raw data is converted into a String before it is placed into a Record.
          */
         STRING: {
-            convert: function(v){ return (v === undefined || v === null) ? '' : String(v); },
+            convert: function(v) {
+                var defaultValue = this.useNull ? null : '';
+                return (v === undefined || v === null) ? defaultValue : String(v);
+            },
             sortType: st.asUCString,
             type: 'string'
         },
 
             sortType: st.asUCString,
             type: 'string'
         },
 
-        <div id="prop-Ext.data.Types-INT"></div>/**
-         * @type Object.
-         * @property INT
+<span id='Ext-data-Types-property-INT'>        /**
+</span>         * @property {Object} INT
          * This data type means that the raw data is converted into an integer before it is placed into a Record.
          * This data type means that the raw data is converted into an integer before it is placed into a Record.
-         * <p>The synonym <code>INTEGER</code> is equivalent.</p>
+         * &lt;p&gt;The synonym &lt;code&gt;INTEGER&lt;/code&gt; is equivalent.&lt;/p&gt;
          */
         INT: {
          */
         INT: {
-            convert: function(v){
-                return v !== undefined && v !== null && v !== '' ?
-                    parseInt(String(v).replace(Ext.data.Types.stripRe, ''), 10) : 0;
+            convert: function(v) {
+                return v !== undefined &amp;&amp; v !== null &amp;&amp; v !== '' ?
+                    parseInt(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
             },
             sortType: st.none,
             type: 'int'
         },
             },
             sortType: st.none,
             type: 'int'
         },
-        
-        <div id="prop-Ext.data.Types-FLOAT"></div>/**
-         * @type Object.
-         * @property FLOAT
+
+<span id='Ext-data-Types-property-FLOAT'>        /**
+</span>         * @property {Object} FLOAT
          * This data type means that the raw data is converted into a number before it is placed into a Record.
          * This data type means that the raw data is converted into a number before it is placed into a Record.
-         * <p>The synonym <code>NUMBER</code> is equivalent.</p>
+         * &lt;p&gt;The synonym &lt;code&gt;NUMBER&lt;/code&gt; is equivalent.&lt;/p&gt;
          */
         FLOAT: {
          */
         FLOAT: {
-            convert: function(v){
-                return v !== undefined && v !== null && v !== '' ?
-                    parseFloat(String(v).replace(Ext.data.Types.stripRe, ''), 10) : 0;
+            convert: function(v) {
+                return v !== undefined &amp;&amp; v !== null &amp;&amp; v !== '' ?
+                    parseFloat(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
             },
             sortType: st.none,
             type: 'float'
         },
             },
             sortType: st.none,
             type: 'float'
         },
-        
-        <div id="prop-Ext.data.Types-BOOL"></div>/**
-         * @type Object.
-         * @property BOOL
-         * <p>This data type means that the raw data is converted into a boolean before it is placed into
-         * a Record. The string "true" and the number 1 are converted to boolean <code>true</code>.</p>
-         * <p>The synonym <code>BOOLEAN</code> is equivalent.</p>
+
+<span id='Ext-data-Types-property-BOOL'>        /**
+</span>         * @property {Object} BOOL
+         * &lt;p&gt;This data type means that the raw data is converted into a boolean before it is placed into
+         * a Record. The string &quot;true&quot; and the number 1 are converted to boolean &lt;code&gt;true&lt;/code&gt;.&lt;/p&gt;
+         * &lt;p&gt;The synonym &lt;code&gt;BOOLEAN&lt;/code&gt; is equivalent.&lt;/p&gt;
          */
         BOOL: {
          */
         BOOL: {
-            convert: function(v){ return v === true || v === 'true' || v == 1; },
+            convert: function(v) {
+                if (this.useNull &amp;&amp; (v === undefined || v === null || v === '')) {
+                    return null;
+                }
+                return v === true || v === 'true' || v == 1;
+            },
             sortType: st.none,
             type: 'bool'
         },
             sortType: st.none,
             type: 'bool'
         },
-        
-        <div id="prop-Ext.data.Types-DATE"></div>/**
-         * @type Object.
-         * @property DATE
+
+<span id='Ext-data-Types-property-DATE'>        /**
+</span>         * @property {Object} DATE
          * This data type means that the raw data is converted into a Date before it is placed into a Record.
          * The date format is specified in the constructor of the {@link Ext.data.Field} to which this type is
          * being applied.
          */
         DATE: {
          * This data type means that the raw data is converted into a Date before it is placed into a Record.
          * The date format is specified in the constructor of the {@link Ext.data.Field} to which this type is
          * being applied.
          */
         DATE: {
-            convert: function(v){
-                var df = this.dateFormat;
-                if(!v){
+            convert: function(v) {
+                var df = this.dateFormat,
+                    parsed;
+
+                if (!v) {
                     return null;
                 }
                     return null;
                 }
-                if(Ext.isDate(v)){
+                if (Ext.isDate(v)) {
                     return v;
                 }
                     return v;
                 }
-                if(df){
-                    if(df == 'timestamp'){
+                if (df) {
+                    if (df == 'timestamp') {
                         return new Date(v*1000);
                     }
                         return new Date(v*1000);
                     }
-                    if(df == 'time'){
+                    if (df == 'time') {
                         return new Date(parseInt(v, 10));
                     }
                         return new Date(parseInt(v, 10));
                     }
-                    return Date.parseDate(v, df);
+                    return Ext.Date.parse(v, df);
                 }
                 }
-                var parsed = Date.parse(v);
+
+                parsed = Date.parse(v);
                 return parsed ? new Date(parsed) : null;
             },
             sortType: st.asDate,
             type: 'date'
         }
     });
                 return parsed ? new Date(parsed) : null;
             },
             sortType: st.asDate,
             type: 'date'
         }
     });
-    
-    Ext.apply(this, {
-        <div id="prop-Ext.data.Types-BOOLEAN"></div>/**
-         * @type Object.
-         * @property BOOLEAN
-         * <p>This data type means that the raw data is converted into a boolean before it is placed into
-         * a Record. The string "true" and the number 1 are converted to boolean <code>true</code>.</p>
-         * <p>The synonym <code>BOOL</code> is equivalent.</p>
+
+    Ext.apply(Ext.data.Types, {
+<span id='Ext-data-Types-property-BOOLEAN'>        /**
+</span>         * @property {Object} BOOLEAN
+         * &lt;p&gt;This data type means that the raw data is converted into a boolean before it is placed into
+         * a Record. The string &quot;true&quot; and the number 1 are converted to boolean &lt;code&gt;true&lt;/code&gt;.&lt;/p&gt;
+         * &lt;p&gt;The synonym &lt;code&gt;BOOL&lt;/code&gt; is equivalent.&lt;/p&gt;
          */
         BOOLEAN: this.BOOL,
          */
         BOOLEAN: this.BOOL,
-        <div id="prop-Ext.data.Types-INTEGER"></div>/**
-         * @type Object.
-         * @property INTEGER
+
+<span id='Ext-data-Types-property-INTEGER'>        /**
+</span>         * @property {Object} INTEGER
          * This data type means that the raw data is converted into an integer before it is placed into a Record.
          * This data type means that the raw data is converted into an integer before it is placed into a Record.
-         * <p>The synonym <code>INT</code> is equivalent.</p>
+         * &lt;p&gt;The synonym &lt;code&gt;INT&lt;/code&gt; is equivalent.&lt;/p&gt;
          */
         INTEGER: this.INT,
          */
         INTEGER: this.INT,
-        <div id="prop-Ext.data.Types-NUMBER"></div>/**
-         * @type Object.
-         * @property NUMBER
+
+<span id='Ext-data-Types-property-NUMBER'>        /**
+</span>         * @property {Object} NUMBER
          * This data type means that the raw data is converted into a number before it is placed into a Record.
          * This data type means that the raw data is converted into a number before it is placed into a Record.
-         * <p>The synonym <code>FLOAT</code> is equivalent.</p>
+         * &lt;p&gt;The synonym &lt;code&gt;FLOAT&lt;/code&gt; is equivalent.&lt;/p&gt;
          */
          */
-        NUMBER: this.FLOAT    
+        NUMBER: this.FLOAT
     });
     });
-};</pre>    
+});
+</pre>
 </body>
 </body>
-</html>
\ No newline at end of file
+</html>
Mirror of ExtJS by Sencha Inc. <http://www.sencha.com/>.