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>