--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui3-3.15.0/build/tree-openable/tree-openable-debug.js Mon Mar 10 15:19:48 2014 +0100
@@ -0,0 +1,241 @@
+YUI.add('tree-openable', function (Y, NAME) {
+
+/*jshint expr:true, onevar:false */
+
+/**
+Extension for `Tree` that adds the concept of open/closed state for nodes.
+
+@module tree
+@submodule tree-openable
+@main tree-openable
+**/
+
+/**
+Extension for `Tree` that adds the concept of open/closed state for nodes.
+
+@class Tree.Openable
+@constructor
+@extensionfor Tree
+**/
+
+/**
+Fired when a node is closed.
+
+@event close
+@param {Tree.Node} node Node being closed.
+@param {String} src Source of the event.
+@preventable _defCloseFn
+**/
+var EVT_CLOSE = 'close';
+
+/**
+Fired when a node is opened.
+
+@event open
+@param {Tree.Node} node Node being opened.
+@param {String} src Source of the event.
+@preventable _defOpenFn
+**/
+var EVT_OPEN = 'open';
+
+function Openable() {}
+
+Openable.prototype = {
+ // -- Lifecycle ------------------------------------------------------------
+ initializer: function () {
+ this.nodeExtensions = this.nodeExtensions.concat(Y.Tree.Node.Openable);
+ },
+
+ // -- Public Methods -------------------------------------------------------
+
+ /**
+ Closes the specified node if it isn't already closed.
+
+ @method closeNode
+ @param {Tree.Node} node Node to close.
+ @param {Object} [options] Options.
+ @param {Boolean} [options.silent=false] If `true`, the `close` event
+ will be suppressed.
+ @param {String} [options.src] Source of the change, to be passed along
+ to the event facade of the resulting event. This can be used to
+ distinguish between changes triggered by a user and changes
+ triggered programmatically, for example.
+ @chainable
+ **/
+ closeNode: function (node, options) {
+ if (node.canHaveChildren && node.isOpen()) {
+ this._fireTreeEvent(EVT_CLOSE, {
+ node: node,
+ src : options && options.src
+ }, {
+ defaultFn: this._defCloseFn,
+ silent : options && options.silent
+ });
+ }
+
+ return this;
+ },
+
+ /**
+ Opens the specified node if it isn't already open.
+
+ @method openNode
+ @param {Tree.Node} node Node to open.
+ @param {Object} [options] Options.
+ @param {Boolean} [options.silent=false] If `true`, the `open` event
+ will be suppressed.
+ @param {String} [options.src] Source of the change, to be passed along
+ to the event facade of the resulting event. This can be used to
+ distinguish between changes triggered by a user and changes
+ triggered programmatically, for example.
+ @chainable
+ **/
+ openNode: function (node, options) {
+ if (node.canHaveChildren && !node.isOpen()) {
+ this._fireTreeEvent(EVT_OPEN, {
+ node: node,
+ src : options && options.src
+ }, {
+ defaultFn: this._defOpenFn,
+ silent : options && options.silent
+ });
+ }
+
+ return this;
+ },
+
+ /**
+ Toggles the open/closed state of the specified node, closing it if it's
+ currently open or opening it if it's currently closed.
+
+ @method toggleOpenNode
+ @param {Tree.Node} node Node to toggle.
+ @param {Object} [options] Options.
+ @param {Boolean} [options.silent=false] If `true`, events will be
+ suppressed.
+ @param {String} [options.src] Source of the change, to be passed along
+ to the event facade of the resulting event. This can be used to
+ distinguish between changes triggered by a user and changes
+ triggered programmatically, for example.
+ @chainable
+ **/
+ toggleOpenNode: function (node, options) {
+ return node.isOpen() ? this.closeNode(node, options) :
+ this.openNode(node, options);
+ },
+
+ // -- Default Event Handlers -----------------------------------------------
+
+ /**
+ Default handler for the `close` event.
+
+ @method _defCloseFn
+ @param {EventFacade} e
+ @protected
+ **/
+ _defCloseFn: function (e) {
+ delete e.node.state.open;
+ },
+
+ /**
+ Default handler for the `open` event.
+
+ @method _defOpenFn
+ @param {EventFacade} e
+ @protected
+ **/
+ _defOpenFn: function (e) {
+ e.node.state.open = true;
+ }
+};
+
+Y.Tree.Openable = Openable;
+/**
+@module tree
+@submodule tree-openable
+**/
+
+/**
+`Tree.Node` extension that adds methods useful for nodes in trees that use the
+`Tree.Openable` extension.
+
+@class Tree.Node.Openable
+@constructor
+@extensionfor Tree.Node
+**/
+
+function NodeOpenable() {}
+
+NodeOpenable.prototype = {
+ /**
+ Closes this node if it's currently open.
+
+ @method close
+ @param {Object} [options] Options.
+ @param {Boolean} [options.silent=false] If `true`, the `close` event
+ will be suppressed.
+ @param {String} [options.src] Source of the change, to be passed along
+ to the event facade of the resulting event. This can be used to
+ distinguish between changes triggered by a user and changes
+ triggered programmatically, for example.
+ @chainable
+ **/
+ close: function (options) {
+ this.tree.closeNode(this, options);
+ return this;
+ },
+
+ /**
+ Returns `true` if this node is currently open.
+
+ Note: the root node of a tree is always considered to be open.
+
+ @method isOpen
+ @return {Boolean} `true` if this node is currently open, `false` otherwise.
+ **/
+ isOpen: function () {
+ return !!this.state.open || this.isRoot();
+ },
+
+ /**
+ Opens this node if it's currently closed.
+
+ @method open
+ @param {Object} [options] Options.
+ @param {Boolean} [options.silent=false] If `true`, the `open` event
+ will be suppressed.
+ @param {String} [options.src] Source of the change, to be passed along
+ to the event facade of the resulting event. This can be used to
+ distinguish between changes triggered by a user and changes
+ triggered programmatically, for example.
+ @chainable
+ **/
+ open: function (options) {
+ this.tree.openNode(this, options);
+ return this;
+ },
+
+ /**
+ Toggles the open/closed state of this node, closing it if it's currently
+ open or opening it if it's currently closed.
+
+ @method toggleOpen
+ @param {Object} [options] Options.
+ @param {Boolean} [options.silent=false] If `true`, events will be
+ suppressed.
+ @param {String} [options.src] Source of the change, to be passed along
+ to the event facade of the resulting event. This can be used to
+ distinguish between changes triggered by a user and changes
+ triggered programmatically, for example.
+ @chainable
+ **/
+ toggleOpen: function (options) {
+ this.tree.toggleOpenNode(this, options);
+ return this;
+ }
+};
+
+Y.Tree.Node.Openable = NodeOpenable;
+
+
+}, '@VERSION@', {"requires": ["tree"]});