mirror of
https://bitbucket.org/wisemapping/wisemapping-frontend.git
synced 2024-11-11 09:53:24 +01:00
272 lines
8.3 KiB
JavaScript
272 lines
8.3 KiB
JavaScript
/*
|
|
* 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;
|