Subversion Repositories Applications.papyrus

/*
        Copyright (c) 2004-2006, The Dojo Foundation
        All Rights Reserved.

        Licensed under the Academic Free License version 2.1 or above OR the
        modified BSD license. For more information on Dojo licensing, see:

                http://dojotoolkit.org/community/licensing.shtml
*/



dojo.provide("dojo.widget.TreeBasicControllerV3");
dojo.require("dojo.event.*");
dojo.require("dojo.json");
dojo.require("dojo.io.*");
dojo.require("dojo.widget.TreeCommon");
dojo.require("dojo.widget.TreeNodeV3");
dojo.require("dojo.widget.TreeV3");
dojo.widget.defineWidget("dojo.widget.TreeBasicControllerV3", [dojo.widget.HtmlWidget, dojo.widget.TreeCommon], function () {
        this.listenedTrees = {};
}, {listenTreeEvents:["afterSetFolder", "afterTreeCreate", "beforeTreeDestroy"], listenNodeFilter:function (elem) {
        return elem instanceof dojo.widget.Widget;
}, editor:null, initialize:function (args) {
        if (args.editor) {
                this.editor = dojo.widget.byId(args.editor);
                this.editor.controller = this;
        }
}, getInfo:function (elem) {
        return elem.getInfo();
}, onBeforeTreeDestroy:function (message) {
        this.unlistenTree(message.source);
}, onAfterSetFolder:function (message) {
        if (message.source.expandLevel > 0) {
                this.expandToLevel(message.source, message.source.expandLevel);
        }
        if (message.source.loadLevel > 0) {
                this.loadToLevel(message.source, message.source.loadLevel);
        }
}, _focusNextVisible:function (nodeWidget) {
        if (nodeWidget.isFolder && nodeWidget.isExpanded && nodeWidget.children.length > 0) {
                returnWidget = nodeWidget.children[0];
        } else {
                while (nodeWidget.isTreeNode && nodeWidget.isLastChild()) {
                        nodeWidget = nodeWidget.parent;
                }
                if (nodeWidget.isTreeNode) {
                        var returnWidget = nodeWidget.parent.children[nodeWidget.getParentIndex() + 1];
                }
        }
        if (returnWidget && returnWidget.isTreeNode) {
                this._focusLabel(returnWidget);
                return returnWidget;
        }
}, _focusPreviousVisible:function (nodeWidget) {
        var returnWidget = nodeWidget;
        if (!nodeWidget.isFirstChild()) {
                var previousSibling = nodeWidget.parent.children[nodeWidget.getParentIndex() - 1];
                nodeWidget = previousSibling;
                while (nodeWidget.isFolder && nodeWidget.isExpanded && nodeWidget.children.length > 0) {
                        returnWidget = nodeWidget;
                        nodeWidget = nodeWidget.children[nodeWidget.children.length - 1];
                }
        } else {
                nodeWidget = nodeWidget.parent;
        }
        if (nodeWidget && nodeWidget.isTreeNode) {
                returnWidget = nodeWidget;
        }
        if (returnWidget && returnWidget.isTreeNode) {
                this._focusLabel(returnWidget);
                return returnWidget;
        }
}, _focusZoomIn:function (nodeWidget) {
        var returnWidget = nodeWidget;
        if (nodeWidget.isFolder && !nodeWidget.isExpanded) {
                this.expand(nodeWidget);
        } else {
                if (nodeWidget.children.length > 0) {
                        nodeWidget = nodeWidget.children[0];
                }
        }
        if (nodeWidget && nodeWidget.isTreeNode) {
                returnWidget = nodeWidget;
        }
        if (returnWidget && returnWidget.isTreeNode) {
                this._focusLabel(returnWidget);
                return returnWidget;
        }
}, _focusZoomOut:function (node) {
        var returnWidget = node;
        if (node.isFolder && node.isExpanded) {
                this.collapse(node);
        } else {
                node = node.parent;
        }
        if (node && node.isTreeNode) {
                returnWidget = node;
        }
        if (returnWidget && returnWidget.isTreeNode) {
                this._focusLabel(returnWidget);
                return returnWidget;
        }
}, onFocusNode:function (e) {
        var node = this.domElement2TreeNode(e.target);
        if (node) {
                node.viewFocus();
                dojo.event.browser.stopEvent(e);
        }
}, onBlurNode:function (e) {
        var node = this.domElement2TreeNode(e.target);
        if (!node) {
                return;
        }
        var labelNode = node.labelNode;
        labelNode.setAttribute("tabIndex", "-1");
        node.viewUnfocus();
        dojo.event.browser.stopEvent(e);
        node.tree.domNode.setAttribute("tabIndex", "0");
}, _focusLabel:function (node) {
        var lastFocused = node.tree.lastFocused;
        var labelNode;
        if (lastFocused && lastFocused.labelNode) {
                labelNode = lastFocused.labelNode;
                dojo.event.disconnect(labelNode, "onblur", this, "onBlurNode");
                labelNode.setAttribute("tabIndex", "-1");
                dojo.html.removeClass(labelNode, "TreeLabelFocused");
        }
        labelNode = node.labelNode;
        labelNode.setAttribute("tabIndex", "0");
        node.tree.lastFocused = node;
        dojo.html.addClass(labelNode, "TreeLabelFocused");
        dojo.event.connectOnce(labelNode, "onblur", this, "onBlurNode");
        dojo.event.connectOnce(labelNode, "onfocus", this, "onFocusNode");
        labelNode.focus();
}, onKey:function (e) {
        if (!e.key || e.ctrkKey || e.altKey) {
                return;
        }
        var nodeWidget = this.domElement2TreeNode(e.target);
        if (!nodeWidget) {
                return;
        }
        var treeWidget = nodeWidget.tree;
        if (treeWidget.lastFocused && treeWidget.lastFocused.labelNode) {
                nodeWidget = treeWidget.lastFocused;
        }
        switch (e.key) {
          case e.KEY_TAB:
                if (e.shiftKey) {
                        treeWidget.domNode.setAttribute("tabIndex", "-1");
                }
                break;
          case e.KEY_RIGHT_ARROW:
                this._focusZoomIn(nodeWidget);
                dojo.event.browser.stopEvent(e);
                break;
          case e.KEY_LEFT_ARROW:
                this._focusZoomOut(nodeWidget);
                dojo.event.browser.stopEvent(e);
                break;
          case e.KEY_UP_ARROW:
                this._focusPreviousVisible(nodeWidget);
                dojo.event.browser.stopEvent(e);
                break;
          case e.KEY_DOWN_ARROW:
                this._focusNextVisible(nodeWidget);
                dojo.event.browser.stopEvent(e);
                break;
        }
}, onFocusTree:function (e) {
        if (!e.currentTarget) {
                return;
        }
        try {
                var treeWidget = this.getWidgetByNode(e.currentTarget);
                if (!treeWidget || !treeWidget.isTree) {
                        return;
                }
                var nodeWidget = this.getWidgetByNode(treeWidget.domNode.firstChild);
                if (nodeWidget && nodeWidget.isTreeNode) {
                        if (treeWidget.lastFocused && treeWidget.lastFocused.isTreeNode) {
                                nodeWidget = treeWidget.lastFocused;
                        }
                        this._focusLabel(nodeWidget);
                }
        }
        catch (e) {
        }
}, onAfterTreeCreate:function (message) {
        var tree = message.source;
        dojo.event.browser.addListener(tree.domNode, "onKey", dojo.lang.hitch(this, this.onKey));
        dojo.event.browser.addListener(tree.domNode, "onmousedown", dojo.lang.hitch(this, this.onTreeMouseDown));
        dojo.event.browser.addListener(tree.domNode, "onclick", dojo.lang.hitch(this, this.onTreeClick));
        dojo.event.browser.addListener(tree.domNode, "onfocus", dojo.lang.hitch(this, this.onFocusTree));
        tree.domNode.setAttribute("tabIndex", "0");
        if (tree.expandLevel) {
                this.expandToLevel(tree, tree.expandLevel);
        }
        if (tree.loadLevel) {
                this.loadToLevel(tree, tree.loadLevel);
        }
}, onTreeMouseDown:function (e) {
}, onTreeClick:function (e) {
        var domElement = e.target;
        var node = this.domElement2TreeNode(domElement);
        if (!node || !node.isTreeNode) {
                return;
        }
        var checkExpandClick = function (el) {
                return el === node.expandNode;
        };
        if (this.checkPathCondition(domElement, checkExpandClick)) {
                this.processExpandClick(node);
        }
        this._focusLabel(node);
}, processExpandClick:function (node) {
        if (node.isExpanded) {
                this.collapse(node);
        } else {
                this.expand(node);
        }
}, batchExpandTimeout:20, expandAll:function (nodeOrTree) {
        return this.expandToLevel(nodeOrTree, Number.POSITIVE_INFINITY);
}, collapseAll:function (nodeOrTree) {
        var _this = this;
        var filter = function (elem) {
                return (elem instanceof dojo.widget.Widget) && elem.isFolder && elem.isExpanded;
        };
        if (nodeOrTree.isTreeNode) {
                this.processDescendants(nodeOrTree, filter, this.collapse);
        } else {
                if (nodeOrTree.isTree) {
                        dojo.lang.forEach(nodeOrTree.children, function (c) {
                                _this.processDescendants(c, filter, _this.collapse);
                        });
                }
        }
}, expandToNode:function (node, withSelected) {
        n = withSelected ? node : node.parent;
        s = [];
        while (!n.isExpanded) {
                s.push(n);
                n = n.parent;
        }
        dojo.lang.forEach(s, function (n) {
                n.expand();
        });
}, expandToLevel:function (nodeOrTree, level) {
        dojo.require("dojo.widget.TreeTimeoutIterator");
        var _this = this;
        var filterFunc = function (elem) {
                var res = elem.isFolder || elem.children && elem.children.length;
                return res;
        };
        var callFunc = function (node, iterator) {
                _this.expand(node, true);
                iterator.forward();
        };
        var iterator = new dojo.widget.TreeTimeoutIterator(nodeOrTree, callFunc, this);
        iterator.setFilter(filterFunc);
        iterator.timeout = this.batchExpandTimeout;
        iterator.setMaxLevel(nodeOrTree.isTreeNode ? level - 1 : level);
        return iterator.start(nodeOrTree.isTreeNode);
}, getWidgetByNode:function (node) {
        var widgetId;
        var newNode = node;
        while (!(widgetId = newNode.widgetId)) {
                newNode = newNode.parentNode;
                if (newNode == null) {
                        break;
                }
        }
        if (widgetId) {
                return dojo.widget.byId(widgetId);
        } else {
                if (node == null) {
                        return null;
                } else {
                        return dojo.widget.manager.byNode(node);
                }
        }
}, expand:function (node) {
        if (node.isFolder) {
                node.expand();
        }
}, collapse:function (node) {
        if (node.isFolder) {
                node.collapse();
        }
}, canEditLabel:function (node) {
        if (node.actionIsDisabledNow(node.actions.EDIT)) {
                return false;
        }
        return true;
}, editLabelStart:function (node) {
        if (!this.canEditLabel(node)) {
                return false;
        }
        if (!this.editor.isClosed()) {
                this.editLabelFinish(this.editor.saveOnBlur);
        }
        this.doEditLabelStart(node);
}, editLabelFinish:function (save) {
        this.doEditLabelFinish(save);
}, doEditLabelStart:function (node) {
        if (!this.editor) {
                dojo.raise(this.widgetType + ": no editor specified");
        }
        this.editor.open(node);
}, doEditLabelFinish:function (save, server_data) {
        if (!this.editor) {
                dojo.raise(this.widgetType + ": no editor specified");
        }
        var node = this.editor.node;
        var editorTitle = this.editor.getContents();
        this.editor.close(save);
        if (save) {
                var data = {title:editorTitle};
                if (server_data) {
                        dojo.lang.mixin(data, server_data);
                }
                if (node.isPhantom) {
                        var parent = node.parent;
                        var index = node.getParentIndex();
                        node.destroy();
                        dojo.widget.TreeBasicControllerV3.prototype.doCreateChild.call(this, parent, index, data);
                } else {
                        var title = server_data && server_data.title ? server_data.title : editorTitle;
                        node.setTitle(title);
                }
        } else {
                if (node.isPhantom) {
                        node.destroy();
                }
        }
}, makeDefaultNode:function (parent, index) {
        var data = {title:parent.tree.defaultChildTitle};
        return dojo.widget.TreeBasicControllerV3.prototype.doCreateChild.call(this, parent, index, data);
}, runStages:function (check, prepare, make, finalize, expose, args) {
        if (check && !check.apply(this, args)) {
                return false;
        }
        if (prepare && !prepare.apply(this, args)) {
                return false;
        }
        var result = make.apply(this, args);
        if (finalize) {
                finalize.apply(this, args);
        }
        if (!result) {
                return result;
        }
        if (expose) {
                expose.apply(this, args);
        }
        return result;
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {createAndEdit:function (parent, index) {
        var data = {title:parent.tree.defaultChildTitle};
        if (!this.canCreateChild(parent, index, data)) {
                return false;
        }
        var child = this.doCreateChild(parent, index, data);
        if (!child) {
                return false;
        }
        this.exposeCreateChild(parent, index, data);
        child.isPhantom = true;
        if (!this.editor.isClosed()) {
                this.editLabelFinish(this.editor.saveOnBlur);
        }
        this.doEditLabelStart(child);
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canClone:function (child, newParent, index, deep) {
        return true;
}, clone:function (child, newParent, index, deep) {
        return this.runStages(this.canClone, this.prepareClone, this.doClone, this.finalizeClone, this.exposeClone, arguments);
}, exposeClone:function (child, newParent) {
        if (newParent.isTreeNode) {
                this.expand(newParent);
        }
}, doClone:function (child, newParent, index, deep) {
        var cloned = child.clone(deep);
        newParent.addChild(cloned, index);
        return cloned;
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canDetach:function (child) {
        if (child.actionIsDisabledNow(child.actions.DETACH)) {
                return false;
        }
        return true;
}, detach:function (node) {
        return this.runStages(this.canDetach, this.prepareDetach, this.doDetach, this.finalizeDetach, this.exposeDetach, arguments);
}, doDetach:function (node, callObj, callFunc) {
        node.detach();
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canDestroyChild:function (child) {
        if (child.parent && !this.canDetach(child)) {
                return false;
        }
        return true;
}, destroyChild:function (node) {
        return this.runStages(this.canDestroyChild, this.prepareDestroyChild, this.doDestroyChild, this.finalizeDestroyChild, this.exposeDestroyChild, arguments);
}, doDestroyChild:function (node) {
        node.destroy();
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canMoveNotANode:function (child, parent) {
        if (child.treeCanMove) {
                return child.treeCanMove(parent);
        }
        return true;
}, canMove:function (child, newParent) {
        if (!child.isTreeNode) {
                return this.canMoveNotANode(child, newParent);
        }
        if (child.actionIsDisabledNow(child.actions.MOVE)) {
                return false;
        }
        if (child.parent !== newParent && newParent.actionIsDisabledNow(newParent.actions.ADDCHILD)) {
                return false;
        }
        var node = newParent;
        while (node.isTreeNode) {
                if (node === child) {
                        return false;
                }
                node = node.parent;
        }
        return true;
}, move:function (child, newParent, index) {
        return this.runStages(this.canMove, this.prepareMove, this.doMove, this.finalizeMove, this.exposeMove, arguments);
}, doMove:function (child, newParent, index) {
        child.tree.move(child, newParent, index);
        return true;
}, exposeMove:function (child, newParent) {
        if (newParent.isTreeNode) {
                this.expand(newParent);
        }
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canCreateChild:function (parent, index, data) {
        if (parent.actionIsDisabledNow(parent.actions.ADDCHILD)) {
                return false;
        }
        return true;
}, createChild:function (parent, index, data) {
        if (!data) {
                data = {title:parent.tree.defaultChildTitle};
        }
        return this.runStages(this.canCreateChild, this.prepareCreateChild, this.doCreateChild, this.finalizeCreateChild, this.exposeCreateChild, [parent, index, data]);
}, prepareCreateChild:function () {
        return true;
}, finalizeCreateChild:function () {
}, doCreateChild:function (parent, index, data) {
        var newChild = parent.tree.createNode(data);
        parent.addChild(newChild, index);
        return newChild;
}, exposeCreateChild:function (parent) {
        return this.expand(parent);
}});