Upgrade to ExtJS 4.0.2 - Released 06/09/2011
[extjs.git] / docs / source / Memento.html
1 <!DOCTYPE html>
2 <html>
3 <head>
4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
5   <title>The source code</title>
6   <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
7   <script type="text/javascript" src="../prettify/prettify.js"></script>
8   <style type="text/css">
9     .highlight { display: block; background-color: #ddd; }
10   </style>
11   <script type="text/javascript">
12     function highlight() {
13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
14     }
15   </script>
16 </head>
17 <body onload="prettyPrint(); highlight();">
18   <pre class="prettyprint lang-js"><span id='Ext-util-Memento'>/**
19 </span> * @class Ext.util.Memento
20  * This class manages a set of captured properties from an object. These captured properties
21  * can later be restored to an object.
22  */
23 Ext.define('Ext.util.Memento', function () {
24
25     function captureOne (src, target, prop) {
26         src[prop] = target[prop];
27     }
28
29     function removeOne (src, target, prop) {
30         delete src[prop];
31     }
32
33     function restoreOne (src, target, prop) {
34         var value = src[prop];
35         if (value || src.hasOwnProperty(prop)) {
36             restoreValue(target, prop, value);
37         }
38     }
39
40     function restoreValue (target, prop, value) {
41         if (Ext.isDefined(value)) {
42             target[prop] = value;
43         } else {
44             delete target[prop];
45         }
46     }
47
48     function doMany (doOne, src, target, props) {
49         if (src) {
50             if (Ext.isArray(props)) {
51                 Ext.each(props, function (prop) {
52                     doOne(src, target, prop);
53                 });
54             } else {
55                 doOne(src, target, props);
56             }
57         }
58     }
59
60     return {
61 <span id='Ext-util-Memento-property-data'>        /**
62 </span>         * @property data
63          * The collection of captured properties.
64          * @private
65          */
66         data: null,
67
68 <span id='Ext-util-Memento-property-target'>        /**
69 </span>         * @property target
70          * The default target object for capture/restore (passed to the constructor).
71          */
72         target: null,
73
74 <span id='Ext-util-Memento-method-constructor'>        /**
75 </span>         * Creates a new memento and optionally captures properties from the target object.
76          * @param {Object} target The target from which to capture properties. If specified in the
77          * constructor, this target becomes the default target for all other operations.
78          * @param {String|Array} props The property or array of properties to capture.
79          */
80         constructor: function (target, props) {
81             if (target) {
82                 this.target = target;
83                 if (props) {
84                     this.capture(props);
85                 }
86             }
87         },
88
89 <span id='Ext-util-Memento-method-capture'>        /**
90 </span>         * Captures the specified properties from the target object in this memento.
91          * @param {String|Array} props The property or array of properties to capture.
92          * @param {Object} target The object from which to capture properties.
93          */
94         capture: function (props, target) {
95             doMany(captureOne, this.data || (this.data = {}), target || this.target, props);
96         },
97
98 <span id='Ext-util-Memento-method-remove'>        /**
99 </span>         * Removes the specified properties from this memento. These properties will not be
100          * restored later without re-capturing their values.
101          * @param {String|Array} props The property or array of properties to remove.
102          */
103         remove: function (props) {
104             doMany(removeOne, this.data, null, props);
105         },
106
107 <span id='Ext-util-Memento-method-restore'>        /**
108 </span>         * Restores the specified properties from this memento to the target object.
109          * @param {String|Array} props The property or array of properties to restore.
110          * @param {Boolean} clear True to remove the restored properties from this memento or
111          * false to keep them (default is true).
112          * @param {Object} target The object to which to restore properties.
113          */
114         restore: function (props, clear, target) {
115             doMany(restoreOne, this.data, target || this.target, props);
116             if (clear !== false) {
117                 this.remove(props);
118             }
119         },
120
121 <span id='Ext-util-Memento-method-restoreAll'>        /**
122 </span>         * Restores all captured properties in this memento to the target object.
123          * @param {Boolean} clear True to remove the restored properties from this memento or
124          * false to keep them (default is true).
125          * @param {Object} target The object to which to restore properties.
126          */
127         restoreAll: function (clear, target) {
128             var me = this,
129                 t = target || this.target;
130
131             Ext.Object.each(me.data, function (prop, value) {
132                 restoreValue(t, prop, value);
133             });
134
135             if (clear !== false) {
136                 delete me.data;
137             }
138         }
139     };
140 }());
141 </pre>
142 </body>
143 </html>