lib/yuilib/3.13.0/tree-openable/tree-openable-debug.js

   1 /*
   2 YUI 3.13.0 (build 508226d)
   3 Copyright 2013 Yahoo! Inc. All rights reserved.
   4 Licensed under the BSD License.
   5 http://yuilibrary.com/license/
   6 */
   7
   8 YUI.add('tree-openable', function (Y, NAME) {
   9
  10 /*jshint expr:true, onevar:false */
  11
  12 /**
  13 Extension for `Tree` that adds the concept of open/closed state for nodes.
  14
  15 @module tree
  16 @submodule tree-openable
  17 @main tree-openable
  18 **/
  19
  20 /**
  21 Extension for `Tree` that adds the concept of open/closed state for nodes.
  22
  23 @class Tree.Openable
  24 @constructor
  25 @extensionfor Tree
  26 **/
  27
  28 /**
  29 Fired when a node is closed.
  30
  31 @event close
  32 @param {Tree.Node} node Node being closed.
  33 @param {String} src Source of the event.
  34 @preventable _defCloseFn
  35 **/
  36 var EVT_CLOSE = 'close';
  37
  38 /**
  39 Fired when a node is opened.
  40
  41 @event open
  42 @param {Tree.Node} node Node being opened.
  43 @param {String} src Source of the event.
  44 @preventable _defOpenFn
  45 **/
  46 var EVT_OPEN = 'open';
  47
  48 function Openable() {}
  49
  50 Openable.prototype = {
  51     // -- Lifecycle ------------------------------------------------------------
  52     initializer: function () {
  53         this.nodeExtensions = this.nodeExtensions.concat(Y.Tree.Node.Openable);
  54     },
  55
  56     // -- Public Methods -------------------------------------------------------
  57
  58     /**
  59     Closes the specified node if it isn't already closed.
  60
  61     @method closeNode
  62     @param {Tree.Node} node Node to close.
  63     @param {Object} [options] Options.
  64         @param {Boolean} [options.silent=false] If `true`, the `close` event
  65             will be suppressed.
  66         @param {String} [options.src] Source of the change, to be passed along
  67             to the event facade of the resulting event. This can be used to
  68             distinguish between changes triggered by a user and changes
  69             triggered programmatically, for example.
  70     @chainable
  71     **/
  72     closeNode: function (node, options) {
  73         if (node.canHaveChildren && node.isOpen()) {
  74             this._fireTreeEvent(EVT_CLOSE, {
  75                 node: node,
  76                 src : options && options.src
  77             }, {
  78                 defaultFn: this._defCloseFn,
  79                 silent   : options && options.silent
  80             });
  81         }
  82
  83         return this;
  84     },
  85
  86     /**
  87     Opens the specified node if it isn't already open.
  88
  89     @method openNode
  90     @param {Tree.Node} node Node to open.
  91     @param {Object} [options] Options.
  92         @param {Boolean} [options.silent=false] If `true`, the `open` event
  93             will be suppressed.
  94         @param {String} [options.src] Source of the change, to be passed along
  95             to the event facade of the resulting event. This can be used to
  96             distinguish between changes triggered by a user and changes
  97             triggered programmatically, for example.
  98     @chainable
  99     **/
 100     openNode: function (node, options) {
 101         if (node.canHaveChildren && !node.isOpen()) {
 102             this._fireTreeEvent(EVT_OPEN, {
 103                 node: node,
 104                 src : options && options.src
 105             }, {
 106                 defaultFn: this._defOpenFn,
 107                 silent   : options && options.silent
 108             });
 109         }
 110
 111         return this;
 112     },
 113
 114     /**
 115     Toggles the open/closed state of the specified node, closing it if it's
 116     currently open or opening it if it's currently closed.
 117
 118     @method toggleOpenNode
 119     @param {Tree.Node} node Node to toggle.
 120     @param {Object} [options] Options.
 121         @param {Boolean} [options.silent=false] If `true`, events will be
 122             suppressed.
 123         @param {String} [options.src] Source of the change, to be passed along
 124             to the event facade of the resulting event. This can be used to
 125             distinguish between changes triggered by a user and changes
 126             triggered programmatically, for example.
 127     @chainable
 128     **/
 129     toggleOpenNode: function (node, options) {
 130         return node.isOpen() ? this.closeNode(node, options) :
 131             this.openNode(node, options);
 132     },
 133
 134     // -- Default Event Handlers -----------------------------------------------
 135
 136     /**
 137     Default handler for the `close` event.
 138
 139     @method _defCloseFn
 140     @param {EventFacade} e
 141     @protected
 142     **/
 143     _defCloseFn: function (e) {
 144         delete e.node.state.open;
 145     },
 146
 147     /**
 148     Default handler for the `open` event.
 149
 150     @method _defOpenFn
 151     @param {EventFacade} e
 152     @protected
 153     **/
 154     _defOpenFn: function (e) {
 155         e.node.state.open = true;
 156     }
 157 };
 158
 159 Y.Tree.Openable = Openable;
 160 /**
 161 @module tree
 162 @submodule tree-openable
 163 **/
 164
 165 /**
 166 `Tree.Node` extension that adds methods useful for nodes in trees that use the
 167 `Tree.Openable` extension.
 168
 169 @class Tree.Node.Openable
 170 @constructor
 171 @extensionfor Tree.Node
 172 **/
 173
 174 function NodeOpenable() {}
 175
 176 NodeOpenable.prototype = {
 177     /**
 178     Closes this node if it's currently open.
 179
 180     @method close
 181     @param {Object} [options] Options.
 182         @param {Boolean} [options.silent=false] If `true`, the `close` event
 183             will be suppressed.
 184         @param {String} [options.src] Source of the change, to be passed along
 185             to the event facade of the resulting event. This can be used to
 186             distinguish between changes triggered by a user and changes
 187             triggered programmatically, for example.
 188     @chainable
 189     **/
 190     close: function (options) {
 191         this.tree.closeNode(this, options);
 192         return this;
 193     },
 194
 195     /**
 196     Returns `true` if this node is currently open.
 197
 198     Note: the root node of a tree is always considered to be open.
 199
 200     @method isOpen
 201     @return {Boolean} `true` if this node is currently open, `false` otherwise.
 202     **/
 203     isOpen: function () {
 204         return !!this.state.open || this.isRoot();
 205     },
 206
 207     /**
 208     Opens this node if it's currently closed.
 209
 210     @method open
 211     @param {Object} [options] Options.
 212         @param {Boolean} [options.silent=false] If `true`, the `open` event
 213             will be suppressed.
 214         @param {String} [options.src] Source of the change, to be passed along
 215             to the event facade of the resulting event. This can be used to
 216             distinguish between changes triggered by a user and changes
 217             triggered programmatically, for example.
 218     @chainable
 219     **/
 220     open: function (options) {
 221         this.tree.openNode(this, options);
 222         return this;
 223     },
 224
 225     /**
 226     Toggles the open/closed state of this node, closing it if it's currently
 227     open or opening it if it's currently closed.
 228
 229     @method toggleOpen
 230     @param {Object} [options] Options.
 231         @param {Boolean} [options.silent=false] If `true`, events will be
 232             suppressed.
 233         @param {String} [options.src] Source of the change, to be passed along
 234             to the event facade of the resulting event. This can be used to
 235             distinguish between changes triggered by a user and changes
 236             triggered programmatically, for example.
 237     @chainable
 238     **/
 239     toggleOpen: function (options) {
 240         this.tree.toggleOpenNode(this, options);
 241         return this;
 242     }
 243 };
 244
 245 Y.Tree.Node.Openable = NodeOpenable;
 246
 247
 248 }, '3.13.0', {"requires": ["tree"]});