wisemapping-frontend/packages/mindplot/lib/components/layout/LayoutManager.js

/*
 *    Copyright [2015] [wisemapping]
 *
 *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
 *   It is basically the Apache License, Version 2.0 (the "License") plus the
 *   "powered by wisemapping" text requirement on every single page;
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the license at
 *
 *       http://www.wisemapping.org/license
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
const Events = require('../Events').default
const RootedTreeSet = require('./RootedTreeSet').default
const OriginalLayout = require('./OriginalLayout').default
const ChangeEvent = require('./ChangeEvent').default;

const LayoutManager = new Class(/** @lends LayoutManager */{
    Extends: Events,
    /**
     * @constructs
     * @extends mindplot.Events
     * @param {} rootNodeId
     * @param {} rootSize
     * @throws will throw an error if the root node id is null or undefined
     * @throws will throw an error if the root size is null
     */
    initialize: function(rootNodeId, rootSize) {
        $assert($defined(rootNodeId), "rootNodeId can not be null");
        $assert(rootSize, "rootSize can not be null");
        var position = position || {x:0, y:0};

        this._treeSet = new RootedTreeSet();
        this._layout = new OriginalLayout(this._treeSet);

        var rootNode = this._layout.createNode(rootNodeId, rootSize, position, 'root');
        this._treeSet.setRoot(rootNode);
        this._events = [];
    },

    /**
     * @param id
     * @param size
     * @throws will throw an error if id is null or undefined
     */
    updateNodeSize: function(id, size) {
        $assert($defined(id), "id can not be null");

        var node = this._treeSet.find(id);
        node.setSize(size);
    },

    /**
     * @param id
     * @param value
     * @throws will throw an error if id is null or undefined
     * @throws will throw an error if value is null or undefined
     * @return this
     */
    updateShrinkState: function(id, value) {
        $assert($defined(id), "id can not be null");
        $assert($defined(value), "value can not be null");

        var node = this._treeSet.find(id);
        node.setShrunken(value);

        return this;
    },

    /**
     * @param id
     * @return {@link RootedTreeSet}.find(id)
     */
    find: function(id) {
        return this._treeSet.find(id);
    },

    /**
     * @param id
     * @param position
     * @throws will throw an error if id is null or undefined
     * @throws will throw an error if position is null or undefined
     * @throws will throw an error if the position's x property is null or undefined
     * @throws will throw an error if the position's y property is null or undefined
     */
    moveNode: function(id, position) {
        $assert($defined(id), "id cannot be null");
        $assert($defined(position), "position cannot be null");
        $assert($defined(position.x), "x can not be null");
        $assert($defined(position.y), "y can not be null");

        var node = this._treeSet.find(id);
        // @Todo: this should not be here. This is broking the isolated node support...
//        node.setFree(true);
//        node.setFreeDisplacement({x:position.x - node.getPosition().x, y:position.y - node.getPosition().y});
        node.setPosition(position);
    },

    /**
     * @param parentId
     * @param childId
     * @param order
     * @throws will throw an error if parentId is null or undefined
     * @throws will throw an error if childId is null or undefined
     * @throws will throw an error if order is null or undefined
     * @return this
     */
    connectNode: function(parentId, childId, order) {
        $assert($defined(parentId), "parentId cannot be null");
        $assert($defined(childId), "childId cannot be null");
        $assert($defined(order), "order cannot be null");

        this._layout.connectNode(parentId, childId, order);

        return this;
    },

    /**
     * @param id
     * @throws will throw an error if id is null or undefined
     * @return this
     */
    disconnectNode: function(id) {
        $assert($defined(id), "id can not be null");
        this._layout.disconnectNode(id);

        return this;
    },

    /**
     * @param id
     * @param size
     * @param position
     * @throws will throw an error if id is null or undefined
     * @return this
     */
    addNode:function(id, size, position) {
        $assert($defined(id), "id can not be null");
        var result = this._layout.createNode(id, size, position, 'topic');
        this._treeSet.add(result);

        return this;
    },

    /**
     * removes a node and its connection to parent if existing
     * @param id
     * @throws will throw an error if id is null or undefined
     * @return this
     */
    removeNode: function(id) {
        $assert($defined(id), "id can not be null");
        var node = this._treeSet.find(id);

        // Is It connected ?
        if (this._treeSet.getParent(node)) {
            this.disconnectNode(id);
        }

        // Remove the all the branch ...
        this._treeSet.remove(id);

        return this;
    },

    /**
     * @param {Number} parentId
     * @param {Number=} nodeId
     * @param {String=} position the position to use as mindplot.layout.Node.properties position
     * property as '(x,y)'
     * @param {Boolean=} free true specifies free node positioning
     * @throws will throw an error if parentId is null or undefined
     */
    predict: function(parentId, nodeId, position, free) {
        $assert($defined(parentId), "parentId can not be null");

        var parent = this._treeSet.find(parentId);
        var node = nodeId ? this._treeSet.find(nodeId) : null;
        var sorter = parent.getSorter();

        var result = sorter.predict(this._treeSet, parent, node, position, free);
        return {order:result[0],position:result[1]};
    },

    /**
     * logs dump to console
     */
    dump: function() {
        console.log(this._treeSet.dump());
    },

    /**
     * @param containerId
     * @param {width:Number, height:Number} size
     * @throws will throw an error if containerId is null or undefined
     * @return canvas
     */
    plot: function(containerId, size) {
        $assert(containerId, "containerId cannot be null");
        size = size || {width:200,height:200};
        var squaresize = 10;
        var canvas = Raphael(containerId, size.width, size.height);
        canvas.drawGrid(0, 0, size.width, size.height, size.width / squaresize, size.height / squaresize);
        this._treeSet.plot(canvas);

        return canvas;
    },

    /**
     * initializes the layout to be updated
     * @param fireEvents
     * @return this
     */
    layout: function(fireEvents) {
        // File repositioning ...
        this._layout.layout();

        // Collect changes ...
        this._collectChanges();

        if ($(fireEvents).length>0 || fireEvents) {
            this._flushEvents();
        }

        return this;
    },

    _flushEvents: function() {
        _.each(this._events, function(event) {
            this.fireEvent('change', event);
        }, this);
        this._events = [];
    },

    _collectChanges: function(nodes) {
        if (!nodes)
            nodes = this._treeSet.getTreeRoots();

        _.each(nodes, function(node) {
            if (node.hasOrderChanged() || node.hasPositionChanged()) {

                // Find or create a event ...
                var id = node.getId();
                var event = this._events.some(function(event) {
                    return event.id == id;
                });
                if (!event) {
                    event = new ChangeEvent(id);
                }

                // Update nodes ...
                event.setOrder(node.getOrder());
                event.setPosition(node.getPosition());

                node.resetPositionState();
                node.resetOrderState();
                node.resetFreeState();
                this._events.push(event);
            }
            this._collectChanges(this._treeSet.getChildren(node));
        }, this);
    }

});

export default LayoutManager;