mirror of
https://bitbucket.org/wisemapping/wisemapping-frontend.git
synced 2024-09-22 04:00:07 +02:00
454 lines
13 KiB
JavaScript
454 lines
13 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 RootedTreeSet = new Class(
|
|
/** @lends RootedTreeSet */ {
|
|
/** @constructs */
|
|
initialize() {
|
|
this._rootNodes = [];
|
|
},
|
|
|
|
/**
|
|
* @param root
|
|
* @throws will throw an error if root is null or undefined
|
|
*/
|
|
setRoot(root) {
|
|
$assert(root, 'root can not be null');
|
|
this._rootNodes.push(this._decodate(root));
|
|
},
|
|
|
|
/** getter */
|
|
getTreeRoots() {
|
|
return this._rootNodes;
|
|
},
|
|
|
|
_decodate(node) {
|
|
node._children = [];
|
|
return node;
|
|
},
|
|
|
|
/**
|
|
* @param {mindplot.model.NodeModel} node
|
|
* @throws will throw an error if node is null or undefined
|
|
* @throws will throw an error if node with id already exists
|
|
* @throws will throw an error if node has been added already
|
|
*/
|
|
add(node) {
|
|
$assert(node, 'node can not be null');
|
|
$assert(
|
|
!this.find(node.getId(), false),
|
|
`node already exits with this id. Id:${node.getId()}`,
|
|
);
|
|
$assert(!node._children, 'node already added');
|
|
this._rootNodes.push(this._decodate(node));
|
|
},
|
|
|
|
/**
|
|
* @param nodeId
|
|
* @throws will throw an error if nodeId is null or undefined
|
|
*/
|
|
remove(nodeId) {
|
|
$assert($defined(nodeId), 'nodeId can not be null');
|
|
const node = this.find(nodeId);
|
|
this._rootNodes.erase(node);
|
|
},
|
|
|
|
/**
|
|
* @param parentId
|
|
* @param childId
|
|
* @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 node with id childId is already a child of parent
|
|
*/
|
|
connect(parentId, childId) {
|
|
$assert($defined(parentId), 'parent can not be null');
|
|
$assert($defined(childId), 'child can not be null');
|
|
|
|
const parent = this.find(parentId);
|
|
const child = this.find(childId, true);
|
|
$assert(
|
|
!child._parent,
|
|
`node already connected. Id:${child.getId()},previous:${child._parent}`,
|
|
);
|
|
|
|
parent._children.push(child);
|
|
child._parent = parent;
|
|
this._rootNodes.erase(child);
|
|
},
|
|
|
|
/**
|
|
* @param nodeId
|
|
* @throws will throw an error if nodeId is null or undefined
|
|
* @throws will throw an error if node is not connected
|
|
*/
|
|
disconnect(nodeId) {
|
|
$assert($defined(nodeId), 'nodeId can not be null');
|
|
const node = this.find(nodeId);
|
|
$assert(node._parent, 'Node is not connected');
|
|
|
|
node._parent._children.erase(node);
|
|
this._rootNodes.push(node);
|
|
node._parent = null;
|
|
},
|
|
|
|
/**
|
|
* @param id
|
|
* @param validate
|
|
* @throws will throw an error if id is null or undefined
|
|
* @throws will throw an error if node cannot be found
|
|
* @return node
|
|
*/
|
|
find(id, validate) {
|
|
$assert($defined(id), 'id can not be null');
|
|
|
|
const graphs = this._rootNodes;
|
|
let result = null;
|
|
for (let i = 0; i < graphs.length; i++) {
|
|
const node = graphs[i];
|
|
result = this._find(id, node);
|
|
if (result) {
|
|
break;
|
|
}
|
|
}
|
|
validate = !$defined(validate) ? true : validate;
|
|
$assert(
|
|
validate ? result : true,
|
|
`node could not be found id:${id}\n,RootedTreeSet${this.dump()}`,
|
|
);
|
|
return result;
|
|
},
|
|
|
|
_find(id, parent) {
|
|
if (parent.getId() == id) {
|
|
return parent;
|
|
}
|
|
|
|
let result = null;
|
|
const children = parent._children;
|
|
for (let i = 0; i < children.length; i++) {
|
|
const child = children[i];
|
|
result = this._find(id, child);
|
|
if (result) break;
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @throws will throw an error if nodeId is null or undefined
|
|
* @return children
|
|
*/
|
|
getChildren(node) {
|
|
$assert(node, 'node cannot be null');
|
|
return node._children;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @throws will throw an error if node is null or undefined
|
|
* @return root node or the provided node, if it has no parent
|
|
*/
|
|
getRootNode(node) {
|
|
$assert(node, 'node cannot be null');
|
|
const parent = this.getParent(node);
|
|
if ($defined(parent)) {
|
|
return this.getRootNode(parent);
|
|
}
|
|
|
|
return node;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @throws will throw an error if node is null or undefined
|
|
* @return {Array} ancestors */
|
|
getAncestors(node) {
|
|
$assert(node, 'node cannot be null');
|
|
return this._getAncestors(this.getParent(node), []);
|
|
},
|
|
|
|
_getAncestors(node, ancestors) {
|
|
const result = ancestors;
|
|
if (node) {
|
|
result.push(node);
|
|
this._getAncestors(this.getParent(node), result);
|
|
}
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @throws will throw an error if node is null or undefined
|
|
* @return {Array} siblings
|
|
*/
|
|
getSiblings(node) {
|
|
$assert(node, 'node cannot be null');
|
|
if (!$defined(node._parent)) {
|
|
return [];
|
|
}
|
|
const siblings = node._parent._children.filter((child) => child != node);
|
|
return siblings;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @throws will throw an error if node is null or undefined
|
|
* @return {Boolean} whether the node has a single path to a single leaf (no branching)
|
|
*/
|
|
hasSinglePathToSingleLeaf(node) {
|
|
$assert(node, 'node cannot be null');
|
|
return this._hasSinglePathToSingleLeaf(node);
|
|
},
|
|
|
|
_hasSinglePathToSingleLeaf(node) {
|
|
const children = this.getChildren(node);
|
|
|
|
if (children.length == 1) {
|
|
return this._hasSinglePathToSingleLeaf(children[0]);
|
|
}
|
|
|
|
return children.length == 0;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @return {Boolean} whether the node is the start of a subbranch */
|
|
isStartOfSubBranch(node) {
|
|
return this.getSiblings(node).length > 0 && this.getChildren(node).length == 1;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @throws will throw an error if node is null or undefined
|
|
* @return {Boolean} whether the node is a leaf
|
|
*/
|
|
isLeaf(node) {
|
|
$assert(node, 'node cannot be null');
|
|
return this.getChildren(node).length == 0;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @throws will throw an error if node is null or undefined
|
|
* @return parent
|
|
*/
|
|
getParent(node) {
|
|
$assert(node, 'node cannot be null');
|
|
return node._parent;
|
|
},
|
|
|
|
/**
|
|
* @return result
|
|
*/
|
|
dump() {
|
|
const branches = this._rootNodes;
|
|
let result = '';
|
|
for (let i = 0; i < branches.length; i++) {
|
|
const branch = branches[i];
|
|
result += this._dump(branch, '');
|
|
}
|
|
return result;
|
|
},
|
|
|
|
_dump(node, indent) {
|
|
let result = `${indent + node}\n`;
|
|
const children = this.getChildren(node);
|
|
for (let i = 0; i < children.length; i++) {
|
|
const child = children[i];
|
|
result += this._dump(child, `${indent} `);
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* @param canvas
|
|
*/
|
|
plot(canvas) {
|
|
const branches = this._rootNodes;
|
|
for (let i = 0; i < branches.length; i++) {
|
|
const branch = branches[i];
|
|
this._plot(canvas, branch);
|
|
}
|
|
},
|
|
|
|
_plot(canvas, node, root) {
|
|
const children = this.getChildren(node);
|
|
const cx = node.getPosition().x + canvas.width / 2 - node.getSize().width / 2;
|
|
const cy = node.getPosition().y + canvas.height / 2 - node.getSize().height / 2;
|
|
const rect = canvas.rect(cx, cy, node.getSize().width, node.getSize().height);
|
|
const order = node.getOrder() == null ? 'r' : node.getOrder();
|
|
const text = canvas.text(
|
|
node.getPosition().x + canvas.width / 2,
|
|
node.getPosition().y + canvas.height / 2,
|
|
`${node.getId()}[${order}]`,
|
|
);
|
|
text.attr('fill', '#FFF');
|
|
const fillColor = this._rootNodes.contains(node)
|
|
? '#000'
|
|
: node.isFree()
|
|
? '#abc'
|
|
: '#c00';
|
|
rect.attr('fill', fillColor);
|
|
|
|
const rectPosition = {
|
|
x: rect.attr('x') - canvas.width / 2 + rect.attr('width') / 2,
|
|
y: rect.attr('y') - canvas.height / 2 + rect.attr('height') / 2,
|
|
};
|
|
const rectSize = { width: rect.attr('width'), height: rect.attr('height') };
|
|
rect.click(() => {
|
|
console.log(
|
|
`[id:${
|
|
node.getId()
|
|
}, order:${
|
|
node.getOrder()
|
|
}, position:(${
|
|
rectPosition.x
|
|
},${
|
|
rectPosition.y
|
|
}), size:${
|
|
rectSize.width
|
|
}x${
|
|
rectSize.height
|
|
}, freeDisplacement:(${
|
|
node.getFreeDisplacement().x
|
|
},${
|
|
node.getFreeDisplacement().y
|
|
})]`,
|
|
);
|
|
});
|
|
text.click(() => {
|
|
console.log(
|
|
`[id:${
|
|
node.getId()
|
|
}, order:${
|
|
node.getOrder()
|
|
}, position:(${
|
|
rectPosition.x
|
|
},${
|
|
rectPosition.y
|
|
}), size:${
|
|
rectSize.width
|
|
}x${
|
|
rectSize.height
|
|
}, freeDisplacement:(${
|
|
node.getFreeDisplacement().x
|
|
},${
|
|
node.getFreeDisplacement().y
|
|
})]`,
|
|
);
|
|
});
|
|
|
|
for (let i = 0; i < children.length; i++) {
|
|
const child = children[i];
|
|
this._plot(canvas, child);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @param position
|
|
*/
|
|
updateBranchPosition(node, position) {
|
|
const oldPos = node.getPosition();
|
|
node.setPosition(position);
|
|
|
|
const xOffset = oldPos.x - position.x;
|
|
const yOffset = oldPos.y - position.y;
|
|
|
|
const children = this.getChildren(node);
|
|
const me = this;
|
|
_.each(children, (child) => {
|
|
me.shiftBranchPosition(child, xOffset, yOffset);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @param xOffset
|
|
* @param yOffset
|
|
*/
|
|
shiftBranchPosition(node, xOffset, yOffset) {
|
|
const position = node.getPosition();
|
|
node.setPosition({ x: position.x + xOffset, y: position.y + yOffset });
|
|
|
|
const children = this.getChildren(node);
|
|
const me = this;
|
|
_.each(children, (child) => {
|
|
me.shiftBranchPosition(child, xOffset, yOffset);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @param yOffset
|
|
* @return siblings in the offset (vertical) direction, i.e. with lower or higher order, respectively
|
|
*/
|
|
getSiblingsInVerticalDirection(node, yOffset) {
|
|
// siblings with lower or higher order, depending on the direction of the offset and on the same side as their parent
|
|
const parent = this.getParent(node);
|
|
const siblings = this.getSiblings(node).filter((sibling) => {
|
|
const sameSide = node.getPosition().x > parent.getPosition().x
|
|
? sibling.getPosition().x > parent.getPosition().x
|
|
: sibling.getPosition().x < parent.getPosition().x;
|
|
const orderOK = yOffset < 0
|
|
? sibling.getOrder() < node.getOrder()
|
|
: sibling.getOrder() > node.getOrder();
|
|
return orderOK && sameSide;
|
|
});
|
|
|
|
if (yOffset < 0) {
|
|
siblings.reverse();
|
|
}
|
|
|
|
return siblings;
|
|
},
|
|
|
|
/**
|
|
* @param node
|
|
* @param yOffset
|
|
* @return branches of the root node on the same side as the given node's, in the given
|
|
* vertical direction
|
|
*/
|
|
getBranchesInVerticalDirection(node, yOffset) {
|
|
// direct descendants of the root that do not contain the node and are on the same side
|
|
// and on the direction of the offset
|
|
const rootNode = this.getRootNode(node);
|
|
const branches = this.getChildren(rootNode).filter(function (child) {
|
|
return this._find(node.getId(), child);
|
|
}, this);
|
|
|
|
const branch = branches[0];
|
|
const rootDescendants = this.getSiblings(branch).filter((sibling) => {
|
|
const sameSide = node.getPosition().x > rootNode.getPosition().x
|
|
? sibling.getPosition().x > rootNode.getPosition().x
|
|
: sibling.getPosition().x < rootNode.getPosition().x;
|
|
const sameDirection = yOffset < 0
|
|
? sibling.getOrder() < branch.getOrder()
|
|
: sibling.getOrder() > branch.getOrder();
|
|
return sameSide && sameDirection;
|
|
}, this);
|
|
|
|
return rootDescendants;
|
|
},
|
|
},
|
|
);
|
|
|
|
export default RootedTreeSet;
|