wisemapping-frontend/packages/mindplot/lib/components/layout/LayoutManager.js
2021-10-04 17:05:34 -07:00

284 lines
8.4 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(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);
const 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(id, size) {
$assert($defined(id), 'id can not be null');
const 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(id, value) {
$assert($defined(id), 'id can not be null');
$assert($defined(value), 'value can not be null');
const node = this._treeSet.find(id);
node.setShrunken(value);
return this;
},
/**
* @param id
* @return {@link RootedTreeSet}.find(id)
*/
find(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(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');
const 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(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(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(id, size, position) {
$assert($defined(id), 'id can not be null');
const 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(id) {
$assert($defined(id), 'id can not be null');
const 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(parentId, nodeId, position, free) {
$assert($defined(parentId), 'parentId can not be null');
const parent = this._treeSet.find(parentId);
const node = nodeId ? this._treeSet.find(nodeId) : null;
const sorter = parent.getSorter();
const result = sorter.predict(this._treeSet, parent, node, position, free);
return { order: result[0], position: result[1] };
},
/**
* logs dump to console
*/
dump() {
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(containerId, size) {
$assert(containerId, 'containerId cannot be null');
size = size || { width: 200, height: 200 };
const squaresize = 10;
const 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(fireEvents) {
// File repositioning ...
this._layout.layout();
// Collect changes ...
this._collectChanges();
if ($(fireEvents).length > 0 || fireEvents) {
this._flushEvents();
}
return this;
},
_flushEvents() {
_.each(
this._events,
function (event) {
this.fireEvent('change', event);
},
this,
);
this._events = [];
},
_collectChanges(nodes) {
if (!nodes) nodes = this._treeSet.getTreeRoots();
_.each(
nodes,
function (node) {
if (node.hasOrderChanged() || node.hasPositionChanged()) {
// Find or create a event ...
const id = node.getId();
let event = this._events.some((event) => 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;