mirror of
https://bitbucket.org/wisemapping/wisemapping-frontend.git
synced 2024-11-11 01:43:23 +01:00
297 lines
10 KiB
JavaScript
297 lines
10 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 Node = require('./Node').default;
|
|
const SymmetricSorter = require('./SymmetricSorter').default;
|
|
const BalancedSorter = require('./BalancedSorter').default;
|
|
|
|
const OriginalLayout = new Class(
|
|
/** @lends OriginalLayout */ {
|
|
/**
|
|
* @constructs
|
|
* @param treeSet
|
|
*/
|
|
initialize: function (treeSet) {
|
|
this._treeSet = treeSet;
|
|
},
|
|
|
|
/** */
|
|
createNode: function (id, size, position, type) {
|
|
$assert($defined(id), 'id can not be null');
|
|
$assert(size, 'size can not be null');
|
|
$assert(position, 'position can not be null');
|
|
$assert(type, 'type can not be null');
|
|
|
|
var strategy =
|
|
type === 'root' ? OriginalLayout.BALANCED_SORTER : OriginalLayout.SYMMETRIC_SORTER;
|
|
return new Node(id, size, position, strategy);
|
|
},
|
|
|
|
/** */
|
|
connectNode: function (parentId, childId, order) {
|
|
var parent = this._treeSet.find(parentId);
|
|
var child = this._treeSet.find(childId);
|
|
|
|
// Insert the new node ...
|
|
var sorter = parent.getSorter();
|
|
sorter.insert(this._treeSet, parent, child, order);
|
|
|
|
// Connect the new node ...
|
|
this._treeSet.connect(parentId, childId);
|
|
|
|
// Fire a basic validation ...
|
|
sorter.verify(this._treeSet, parent);
|
|
},
|
|
|
|
/** */
|
|
disconnectNode: function (nodeId) {
|
|
var node = this._treeSet.find(nodeId);
|
|
var parent = this._treeSet.getParent(node);
|
|
$assert(parent, 'Node already disconnected');
|
|
|
|
// Make it fixed
|
|
node.setFree(false);
|
|
node.resetFreeDisplacement();
|
|
|
|
// Remove from children list.
|
|
var sorter = parent.getSorter();
|
|
sorter.detach(this._treeSet, node);
|
|
|
|
// Disconnect the new node ...
|
|
this._treeSet.disconnect(nodeId);
|
|
|
|
// Fire a basic validation ...
|
|
parent.getSorter().verify(this._treeSet, parent);
|
|
},
|
|
|
|
/** */
|
|
layout: function () {
|
|
var roots = this._treeSet.getTreeRoots();
|
|
_.each(
|
|
roots,
|
|
function (node) {
|
|
// Calculate all node heights ...
|
|
var sorter = node.getSorter();
|
|
|
|
var heightById = sorter.computeChildrenIdByHeights(this._treeSet, node);
|
|
|
|
this._layoutChildren(node, heightById);
|
|
|
|
this._fixOverlapping(node, heightById);
|
|
},
|
|
this
|
|
);
|
|
},
|
|
|
|
_layoutChildren: function (node, heightById) {
|
|
var nodeId = node.getId();
|
|
var children = this._treeSet.getChildren(node);
|
|
var parent = this._treeSet.getParent(node);
|
|
var childrenOrderMoved = children.some(function (child) {
|
|
return child.hasOrderChanged();
|
|
});
|
|
var childrenSizeChanged = children.some(function (child) {
|
|
return child.hasSizeChanged();
|
|
});
|
|
|
|
// If ether any of the nodes has been changed of position or the height of the children is not
|
|
// the same, children nodes must be repositioned ....
|
|
var newBranchHeight = heightById[nodeId];
|
|
|
|
var parentHeightChanged = $defined(parent) ? parent._heightChanged : false;
|
|
var heightChanged = node._branchHeight != newBranchHeight;
|
|
node._heightChanged = heightChanged || parentHeightChanged;
|
|
|
|
if (childrenOrderMoved || childrenSizeChanged || heightChanged || parentHeightChanged) {
|
|
var sorter = node.getSorter();
|
|
var offsetById = sorter.computeOffsets(this._treeSet, node);
|
|
var parentPosition = node.getPosition();
|
|
var me = this;
|
|
_.each(children, function (child) {
|
|
var offset = offsetById[child.getId()];
|
|
|
|
var childFreeDisplacement = child.getFreeDisplacement();
|
|
var direction = node.getSorter().getChildDirection(me._treeSet, child);
|
|
|
|
if (
|
|
(direction > 0 && childFreeDisplacement.x < 0) ||
|
|
(direction < 0 && childFreeDisplacement.x > 0)
|
|
) {
|
|
child.resetFreeDisplacement();
|
|
child.setFreeDisplacement({
|
|
x: -childFreeDisplacement.x,
|
|
y: childFreeDisplacement.y,
|
|
});
|
|
}
|
|
|
|
offset.x += child.getFreeDisplacement().x;
|
|
offset.y += child.getFreeDisplacement().y;
|
|
|
|
var parentX = parentPosition.x;
|
|
var parentY = parentPosition.y;
|
|
|
|
var newPos = {
|
|
x: parentX + offset.x,
|
|
y: parentY + offset.y + me._calculateAlignOffset(node, child, heightById),
|
|
};
|
|
me._treeSet.updateBranchPosition(child, newPos);
|
|
});
|
|
|
|
node._branchHeight = newBranchHeight;
|
|
}
|
|
|
|
// Continue reordering the children nodes ...
|
|
_.each(
|
|
children,
|
|
function (child) {
|
|
this._layoutChildren(child, heightById);
|
|
},
|
|
this
|
|
);
|
|
},
|
|
|
|
_calculateAlignOffset: function (node, child, heightById) {
|
|
if (child.isFree()) {
|
|
return 0;
|
|
}
|
|
|
|
var offset = 0;
|
|
|
|
var nodeHeight = node.getSize().height;
|
|
var childHeight = child.getSize().height;
|
|
|
|
if (
|
|
this._treeSet.isStartOfSubBranch(child) &&
|
|
this._branchIsTaller(child, heightById)
|
|
) {
|
|
if (this._treeSet.hasSinglePathToSingleLeaf(child)) {
|
|
offset =
|
|
heightById[child.getId()] / 2 -
|
|
(childHeight + child.getSorter()._getVerticalPadding() * 2) / 2;
|
|
} else {
|
|
offset = this._treeSet.isLeaf(child) ? 0 : -(childHeight - nodeHeight) / 2;
|
|
}
|
|
} else if (nodeHeight > childHeight) {
|
|
if (this._treeSet.getSiblings(child).length > 0) {
|
|
offset = 0;
|
|
} else {
|
|
offset = nodeHeight / 2 - childHeight / 2;
|
|
}
|
|
} else if (childHeight > nodeHeight) {
|
|
if (this._treeSet.getSiblings(child).length > 0) {
|
|
offset = 0;
|
|
} else {
|
|
offset = -(childHeight / 2 - nodeHeight / 2);
|
|
}
|
|
}
|
|
|
|
return offset;
|
|
},
|
|
|
|
_branchIsTaller: function (node, heightById) {
|
|
return (
|
|
heightById[node.getId()] >
|
|
node.getSize().height + node.getSorter()._getVerticalPadding() * 2
|
|
);
|
|
},
|
|
|
|
_fixOverlapping: function (node, heightById) {
|
|
var children = this._treeSet.getChildren(node);
|
|
|
|
if (node.isFree()) {
|
|
this._shiftBranches(node, heightById);
|
|
}
|
|
|
|
_.each(
|
|
children,
|
|
function (child) {
|
|
this._fixOverlapping(child, heightById);
|
|
},
|
|
this
|
|
);
|
|
},
|
|
|
|
_shiftBranches: function (node, heightById) {
|
|
var shiftedBranches = [node];
|
|
|
|
var siblingsToShift = this._treeSet.getSiblingsInVerticalDirection(
|
|
node,
|
|
node.getFreeDisplacement().y
|
|
);
|
|
var last = node;
|
|
_.each(
|
|
siblingsToShift,
|
|
function (sibling) {
|
|
var overlappingOccurs = shiftedBranches.some(function (shiftedBranch) {
|
|
return this._branchesOverlap(shiftedBranch, sibling, heightById);
|
|
}, this);
|
|
|
|
if (!sibling.isFree() || overlappingOccurs) {
|
|
var sAmount = node.getFreeDisplacement().y;
|
|
this._treeSet.shiftBranchPosition(sibling, 0, sAmount);
|
|
shiftedBranches.push(sibling);
|
|
}
|
|
},
|
|
this
|
|
);
|
|
|
|
var branchesToShift = this._treeSet
|
|
.getBranchesInVerticalDirection(node, node.getFreeDisplacement().y)
|
|
.filter(function (branch) {
|
|
return !shiftedBranches.contains(branch);
|
|
});
|
|
|
|
_.each(
|
|
branchesToShift,
|
|
function (branch) {
|
|
var bAmount = node.getFreeDisplacement().y;
|
|
this._treeSet.shiftBranchPosition(branch, 0, bAmount);
|
|
shiftedBranches.push(branch);
|
|
last = branch;
|
|
},
|
|
this
|
|
);
|
|
},
|
|
|
|
_branchesOverlap: function (branchA, branchB, heightById) {
|
|
// a branch doesn't really overlap with itself
|
|
if (branchA == branchB) {
|
|
return false;
|
|
}
|
|
|
|
var topA = branchA.getPosition().y - heightById[branchA.getId()] / 2;
|
|
var bottomA = branchA.getPosition().y + heightById[branchA.getId()] / 2;
|
|
var topB = branchB.getPosition().y - heightById[branchB.getId()] / 2;
|
|
var bottomB = branchB.getPosition().y + heightById[branchB.getId()] / 2;
|
|
|
|
return !(topA >= bottomB || bottomA <= topB);
|
|
},
|
|
}
|
|
);
|
|
|
|
/**
|
|
* @type {mindplot.layout.SymmetricSorter}
|
|
*/
|
|
OriginalLayout.SYMMETRIC_SORTER = new SymmetricSorter();
|
|
/**
|
|
* @type {mindplot.layout.BalancedSorter}
|
|
*/
|
|
OriginalLayout.BALANCED_SORTER = new BalancedSorter();
|
|
|
|
export default OriginalLayout;
|