vmario/wisemapping-frontend
1
0
Fork 0
mirror of https://bitbucket.org/wisemapping/wisemapping-frontend.git synced 2024-09-21 03:30:08 +02:00
Code Issues Packages Projects Releases Wiki Activity

Enable eslit for mindplot

Browse Source
This commit is contained in:
Paulo Gustavo Veiga 2021-10-04 17:05:34 -07:00
parent b25fe345ae
commit 9457ca6047
131 changed files with 29396 additions and 28482 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
packages/mindplot/.eslintrc.json Normal file
View File

@ -0,0 +1,11 @@
{
"env": {
"browser": true,
"commonjs": true
},
"extends": [
"airbnb-base"
],
"plugins": ["only-warn"],
"rules": {}
}

132
packages/mindplot/lib/components/ActionDispatcher.js
View File

@ -17,96 +17,96 @@
*/
const Events = require('./Events').default;
//noinspection JSUnusedLocalSymbols
// noinspection JSUnusedLocalSymbols
const ActionDispatcher = new Class({
Implements:[Events],
initialize: function(commandContext) {
$assert(commandContext, "commandContext can not be null");
},
Implements: [Events],
initialize(commandContext) {
$assert(commandContext, 'commandContext can not be null');
},
addRelationship: function(model, mindmap) {
throw "method must be implemented.";
},
addRelationship(model, mindmap) {
throw 'method must be implemented.';
},
addTopics: function(models, parentTopicId) {
throw "method must be implemented.";
},
addTopics(models, parentTopicId) {
throw 'method must be implemented.';
},
deleteEntities: function(topicsIds, relIds) {
throw "method must be implemented.";
},
deleteEntities(topicsIds, relIds) {
throw 'method must be implemented.';
},
dragTopic: function(topicId, position, order, parentTopic) {
throw "method must be implemented.";
},
dragTopic(topicId, position, order, parentTopic) {
throw 'method must be implemented.';
},
moveTopic: function(topicId, position) {
throw "method must be implemented.";
},
moveTopic(topicId, position) {
throw 'method must be implemented.';
},
moveControlPoint: function(ctrlPoint, point) {
throw "method must be implemented.";
},
moveControlPoint(ctrlPoint, point) {
throw 'method must be implemented.';
},
changeFontFamilyToTopic: function(topicIds, fontFamily) {
throw "method must be implemented.";
},
changeFontFamilyToTopic(topicIds, fontFamily) {
throw 'method must be implemented.';
},
changeFontStyleToTopic: function(topicsIds) {
throw "method must be implemented.";
},
changeFontStyleToTopic(topicsIds) {
throw 'method must be implemented.';
},
changeFontColorToTopic: function(topicsIds, color) {
throw "method must be implemented.";
},
changeFontColorToTopic(topicsIds, color) {
throw 'method must be implemented.';
},
changeFontSizeToTopic : function(topicsIds, size) {
throw "method must be implemented.";
},
changeFontSizeToTopic(topicsIds, size) {
throw 'method must be implemented.';
},
changeBackgroundColorToTopic: function(topicsIds, color) {
throw "method must be implemented.";
},
changeBackgroundColorToTopic(topicsIds, color) {
throw 'method must be implemented.';
},
changeBorderColorToTopic: function(topicsIds, color) {
throw "method must be implemented.";
},
changeBorderColorToTopic(topicsIds, color) {
throw 'method must be implemented.';
},
changeShapeTypeToTopic : function(topicsIds, shapeType) {
throw "method must be implemented.";
},
changeShapeTypeToTopic(topicsIds, shapeType) {
throw 'method must be implemented.';
},
changeFontWeightToTopic : function(topicsIds) {
throw "method must be implemented.";
},
changeFontWeightToTopic(topicsIds) {
throw 'method must be implemented.';
},
changeTextToTopic : function(topicsIds, text) {
throw "method must be implemented.";
},
changeTextToTopic(topicsIds, text) {
throw 'method must be implemented.';
},
shrinkBranch : function(topicsIds, collapse) {
throw "method must be implemented.";
},
shrinkBranch(topicsIds, collapse) {
throw 'method must be implemented.';
},
addFeatureToTopic : function(topicId, type, attributes) {
throw "method must be implemented.";
},
addFeatureToTopic(topicId, type, attributes) {
throw 'method must be implemented.';
},
changeFeatureToTopic : function(topicId, featureId, attributes) {
throw "method must be implemented.";
},
changeFeatureToTopic(topicId, featureId, attributes) {
throw 'method must be implemented.';
},
removeFeatureFromTopic : function(topicId, featureId) {
throw "method must be implemented.";
}
removeFeatureFromTopic(topicId, featureId) {
throw 'method must be implemented.';
},
});
ActionDispatcher.setInstance = function(dispatcher) {
ActionDispatcher._instance = dispatcher;
ActionDispatcher.setInstance = function (dispatcher) {
ActionDispatcher._instance = dispatcher;
};
ActionDispatcher.getInstance = function() {
return ActionDispatcher._instance;
ActionDispatcher.getInstance = function () {
return ActionDispatcher._instance;
};
export default ActionDispatcher;

66
packages/mindplot/lib/components/ActionIcon.js
View File

@ -18,47 +18,47 @@
const Icon = require('./Icon').default;
const ActionIcon = new Class({
Extends:Icon,
initialize: function(topic, url) {
this.parent(url);
this._node = topic;
},
getNode:function() {
return this._node;
},
Extends: Icon,
initialize(topic, url) {
this.parent(url);
this._node = topic;
},
getNode() {
return this._node;
},
setPosition:function(x, y) {
var size = this.getSize();
this.getImage().setPosition(x - size.width / 2, y - size.height / 2);
},
setPosition(x, y) {
const size = this.getSize();
this.getImage().setPosition(x - size.width / 2, y - size.height / 2);
},
addEvent:function(event, fn) {
this.getImage().addEvent(event, fn);
},
addEvent(event, fn) {
this.getImage().addEvent(event, fn);
},
addToGroup:function(group) {
group.append(this.getImage());
},
addToGroup(group) {
group.append(this.getImage());
},
setVisibility:function(visible) {
this.getImage().setVisibility(visible);
},
setVisibility(visible) {
this.getImage().setVisibility(visible);
},
isVisible:function() {
return this.getImage().isVisible();
},
isVisible() {
return this.getImage().isVisible();
},
setCursor:function(cursor) {
return this.getImage().setCursor(cursor);
},
setCursor(cursor) {
return this.getImage().setCursor(cursor);
},
moveToBack:function(cursor) {
return this.getImage().moveToBack(cursor);
},
moveToBack(cursor) {
return this.getImage().moveToBack(cursor);
},
moveToFront:function(cursor) {
return this.getImage().moveToFront(cursor);
}
moveToFront(cursor) {
return this.getImage().moveToFront(cursor);
},
});
export default ActionIcon;

85
packages/mindplot/lib/components/CentralTopic.js
View File

@ -16,66 +16,67 @@
* limitations under the License.
*/
const Core = require('@wismapping/core-js');
const core = Core();
const Topic = require('./Topic').default;
const Shape = require('./util/Shape').default;
const CentralTopic = new Class(
/** @lends CentralTopic*/ {
Extends: Topic,
/**
/** @lends CentralTopic */ {
Extends: Topic,
/**
* @extends mindplot.Topic
* @constructs
* @param model
* @param options
*/
initialize: function (model, options) {
this.parent(model, options);
},
initialize(model, options) {
this.parent(model, options);
},
_registerEvents: function () {
this.parent();
_registerEvents() {
this.parent();
// This disable the drag of the central topic. But solves the problem of deselecting the nodes when the screen is clicked.
this.addEvent('mousedown', function (event) {
event.stopPropagation();
});
},
// This disable the drag of the central topic. But solves the problem of deselecting the nodes when the screen is clicked.
this.addEvent('mousedown', (event) => {
event.stopPropagation();
});
},
/** */
workoutIncomingConnectionPoint: function () {
return this.getPosition();
},
/** */
workoutIncomingConnectionPoint() {
return this.getPosition();
},
/** */
setCursor: function (type) {
type = type == 'move' ? 'default' : type;
this.parent(type);
},
/** */
setCursor(type) {
type = type == 'move' ? 'default' : type;
this.parent(type);
},
/** */
updateTopicShape: function () {},
/** */
updateTopicShape() {},
_updatePositionOnChangeSize: function () {
// Center main topic ...
var zeroPoint = new core.Point(0, 0);
this.setPosition(zeroPoint);
},
_updatePositionOnChangeSize() {
// Center main topic ...
const zeroPoint = new core.Point(0, 0);
this.setPosition(zeroPoint);
},
/** */
getShrinkConnector: function () {
return null;
},
/** */
getShrinkConnector() {
return null;
},
/** */
workoutOutgoingConnectionPoint: function (targetPosition) {
$assert(targetPosition, 'targetPoint can not be null');
var pos = this.getPosition();
var isAtRight = Shape.isAtRight(targetPosition, pos);
var size = this.getSize();
return Shape.calculateRectConnectionPoint(pos, size, !isAtRight);
},
}
/** */
workoutOutgoingConnectionPoint(targetPosition) {
$assert(targetPosition, 'targetPoint can not be null');
const pos = this.getPosition();
const isAtRight = Shape.isAtRight(targetPosition, pos);
const size = this.getSize();
return Shape.calculateRectConnectionPoint(pos, size, !isAtRight);
},
},
);
export default CentralTopic;

52
packages/mindplot/lib/components/Command.js
View File

@ -17,51 +17,45 @@
*/
const Command = new Class(/** @lends mindplot.Command */{
/**
/**
* @classdesc The command base class for handling do/undo mindmap operations
* @constructs
*/
initialize: function()
{
this._id = Command._nextUUID();
},
initialize() {
this._id = Command._nextUUID();
},
/**
/**
* @abstract
*/
execute: function(commandContext)
{
throw "execute must be implemented.";
},
execute(commandContext) {
throw 'execute must be implemented.';
},
/**
* Triggered by the undo button - reverses the executed command
/**
* Triggered by the undo button - reverses the executed command
* @abstract
*/
undoExecute: function(commandContext)
{
throw "undo must be implemented.";
},
undoExecute(commandContext) {
throw 'undo must be implemented.';
},
/**
/**
* Returns the unique id of this command
* @returns {Number} command id
*/
getId:function()
{
return this._id;
}
getId() {
return this._id;
},
});
Command._nextUUID = function()
{
if (!$defined(Command._uuid))
{
Command._uuid = 1;
}
Command._nextUUID = function () {
if (!$defined(Command._uuid)) {
Command._uuid = 1;
}
Command._uuid = Command._uuid + 1;
return Command._uuid;
Command._uuid += 1;
return Command._uuid;
};
export default Command;

292
packages/mindplot/lib/components/ConnectionLine.js
View File

@ -16,8 +16,10 @@
* limitations under the License.
*/
const Core = require('@wismapping/core-js');
const core = Core();
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const INodeModel = require('./model/INodeModel').default;
@ -25,182 +27,184 @@ const { TopicShape } = require('./model/INodeModel');
const Topic = require('./Topic').default;
const ConnectionLine = new Class({
initialize: function (sourceNode, targetNode, lineType) {
$assert(targetNode, 'parentNode node can not be null');
$assert(sourceNode, 'childNode node can not be null');
$assert(sourceNode != targetNode, 'Circular connection');
initialize(sourceNode, targetNode, lineType) {
$assert(targetNode, 'parentNode node can not be null');
$assert(sourceNode, 'childNode node can not be null');
$assert(sourceNode != targetNode, 'Circular connection');
this._targetTopic = targetNode;
this._sourceTopic = sourceNode;
this._targetTopic = targetNode;
this._sourceTopic = sourceNode;
var line;
var ctrlPoints = this._getCtrlPoints(sourceNode, targetNode);
if (targetNode.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
line = this._createLine(lineType, ConnectionLine.CURVED);
line.setSrcControlPoint(ctrlPoints[0]);
line.setDestControlPoint(ctrlPoints[1]);
} else {
line = this._createLine(lineType, ConnectionLine.SIMPLE_CURVED);
line.setSrcControlPoint(ctrlPoints[0]);
line.setDestControlPoint(ctrlPoints[1]);
}
// Set line styles ...
var strokeColor = ConnectionLine.getStrokeColor();
line.setStroke(1, 'solid', strokeColor, 1);
line.setFill(strokeColor, 1);
let line;
const ctrlPoints = this._getCtrlPoints(sourceNode, targetNode);
if (targetNode.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
line = this._createLine(lineType, ConnectionLine.CURVED);
line.setSrcControlPoint(ctrlPoints[0]);
line.setDestControlPoint(ctrlPoints[1]);
} else {
line = this._createLine(lineType, ConnectionLine.SIMPLE_CURVED);
line.setSrcControlPoint(ctrlPoints[0]);
line.setDestControlPoint(ctrlPoints[1]);
}
// Set line styles ...
const strokeColor = ConnectionLine.getStrokeColor();
line.setStroke(1, 'solid', strokeColor, 1);
line.setFill(strokeColor, 1);
this._line2d = line;
},
this._line2d = line;
},
_getCtrlPoints: function (sourceNode, targetNode) {
var srcPos = sourceNode.workoutOutgoingConnectionPoint(targetNode.getPosition());
var destPos = targetNode.workoutIncomingConnectionPoint(sourceNode.getPosition());
var deltaX = (srcPos.x - destPos.x) / 3;
return [new core.Point(deltaX, 0), new core.Point(-deltaX, 0)];
},
_getCtrlPoints(sourceNode, targetNode) {
const srcPos = sourceNode.workoutOutgoingConnectionPoint(targetNode.getPosition());
const destPos = targetNode.workoutIncomingConnectionPoint(sourceNode.getPosition());
const deltaX = (srcPos.x - destPos.x) / 3;
return [new core.Point(deltaX, 0), new core.Point(-deltaX, 0)];
},
_createLine: function (lineType, defaultStyle) {
if (!$defined(lineType)) {
lineType = defaultStyle;
}
lineType = parseInt(lineType);
this._lineType = lineType;
var line = null;
switch (lineType) {
case ConnectionLine.POLYLINE:
line = new web2d.PolyLine();
break;
case ConnectionLine.CURVED:
line = new web2d.CurvedLine();
break;
case ConnectionLine.SIMPLE_CURVED:
line = new web2d.CurvedLine();
line.setStyle(web2d.CurvedLine.SIMPLE_LINE);
break;
default:
line = new web2d.Line();
break;
}
return line;
},
_createLine(lineType, defaultStyle) {
if (!$defined(lineType)) {
lineType = defaultStyle;
}
lineType = parseInt(lineType);
this._lineType = lineType;
let line = null;
switch (lineType) {
case ConnectionLine.POLYLINE:
line = new web2d.PolyLine();
break;
case ConnectionLine.CURVED:
line = new web2d.CurvedLine();
break;
case ConnectionLine.SIMPLE_CURVED:
line = new web2d.CurvedLine();
line.setStyle(web2d.CurvedLine.SIMPLE_LINE);
break;
default:
line = new web2d.Line();
break;
}
return line;
},
setVisibility: function (value) {
this._line2d.setVisibility(value);
},
setVisibility(value) {
this._line2d.setVisibility(value);
},
isVisible: function () {
return this._line2d.isVisible();
},
isVisible() {
return this._line2d.isVisible();
},
setOpacity: function (opacity) {
this._line2d.setOpacity(opacity);
},
setOpacity(opacity) {
this._line2d.setOpacity(opacity);
},
redraw: function () {
var line2d = this._line2d;
var sourceTopic = this._sourceTopic;
var sourcePosition = sourceTopic.getPosition();
redraw() {
const line2d = this._line2d;
const sourceTopic = this._sourceTopic;
const sourcePosition = sourceTopic.getPosition();
var targetTopic = this._targetTopic;
var targetPosition = targetTopic.getPosition();
const targetTopic = this._targetTopic;
const targetPosition = targetTopic.getPosition();
var sPos, tPos;
sPos = sourceTopic.workoutOutgoingConnectionPoint(targetPosition);
tPos = targetTopic.workoutIncomingConnectionPoint(sourcePosition);
let sPos; let
tPos;
sPos = sourceTopic.workoutOutgoingConnectionPoint(targetPosition);
tPos = targetTopic.workoutIncomingConnectionPoint(sourcePosition);
line2d.setFrom(tPos.x, tPos.y);
line2d.setTo(sPos.x, sPos.y);
line2d.setFrom(tPos.x, tPos.y);
line2d.setTo(sPos.x, sPos.y);
if (line2d.getType() == 'CurvedLine') {
var ctrlPoints = this._getCtrlPoints(this._sourceTopic, this._targetTopic);
line2d.setSrcControlPoint(ctrlPoints[0]);
line2d.setDestControlPoint(ctrlPoints[1]);
}
if (line2d.getType() == 'CurvedLine') {
const ctrlPoints = this._getCtrlPoints(this._sourceTopic, this._targetTopic);
line2d.setSrcControlPoint(ctrlPoints[0]);
line2d.setDestControlPoint(ctrlPoints[1]);
}
// Add connector ...
this._positionateConnector(targetTopic);
},
// Add connector ...
this._positionateConnector(targetTopic);
},
_positionateConnector: function (targetTopic) {
var targetPosition = targetTopic.getPosition();
var offset = Topic.CONNECTOR_WIDTH / 2;
var targetTopicSize = targetTopic.getSize();
var y, x;
if (targetTopic.getShapeType() == TopicShape.LINE) {
y = targetTopicSize.height;
} else {
y = targetTopicSize.height / 2;
}
y = y - offset;
_positionateConnector(targetTopic) {
const targetPosition = targetTopic.getPosition();
const offset = Topic.CONNECTOR_WIDTH / 2;
const targetTopicSize = targetTopic.getSize();
let y; let
x;
if (targetTopic.getShapeType() == TopicShape.LINE) {
y = targetTopicSize.height;
} else {
y = targetTopicSize.height / 2;
}
y -= offset;
var connector = targetTopic.getShrinkConnector();
if ($defined(connector)) {
if (Math.sign(targetPosition.x) > 0) {
x = targetTopicSize.width;
connector.setPosition(x, y);
} else {
x = -Topic.CONNECTOR_WIDTH;
}
connector.setPosition(x, y);
}
},
const connector = targetTopic.getShrinkConnector();
if ($defined(connector)) {
if (Math.sign(targetPosition.x) > 0) {
x = targetTopicSize.width;
connector.setPosition(x, y);
} else {
x = -Topic.CONNECTOR_WIDTH;
}
connector.setPosition(x, y);
}
},
setStroke: function (color, style, opacity) {
this._line2d.setStroke(null, null, color, opacity);
},
setStroke(color, style, opacity) {
this._line2d.setStroke(null, null, color, opacity);
},
addToWorkspace: function (workspace) {
workspace.append(this._line2d);
this._line2d.moveToBack();
},
addToWorkspace(workspace) {
workspace.append(this._line2d);
this._line2d.moveToBack();
},
removeFromWorkspace: function (workspace) {
workspace.removeChild(this._line2d);
},
removeFromWorkspace(workspace) {
workspace.removeChild(this._line2d);
},
getTargetTopic: function () {
return this._targetTopic;
},
getTargetTopic() {
return this._targetTopic;
},
getSourceTopic: function () {
return this._sourceTopic;
},
getSourceTopic() {
return this._sourceTopic;
},
getLineType: function () {
return this._lineType;
},
getLineType() {
return this._lineType;
},
getLine: function () {
return this._line2d;
},
getLine() {
return this._line2d;
},
getModel: function () {
return this._model;
},
getModel() {
return this._model;
},
setModel: function (model) {
this._model = model;
},
setModel(model) {
this._model = model;
},
getType: function () {
return 'ConnectionLine';
},
getType() {
return 'ConnectionLine';
},
getId: function () {
return this._model.getId();
},
getId() {
return this._model.getId();
},
moveToBack: function () {
this._line2d.moveToBack();
},
moveToBack() {
this._line2d.moveToBack();
},
moveToFront: function () {
this._line2d.moveToFront();
},
moveToFront() {
this._line2d.moveToFront();
},
});
ConnectionLine.getStrokeColor = function () {
return '#495879';
return '#495879';
};
ConnectionLine.SIMPLE = 0;

351
packages/mindplot/lib/components/ControlPoint.js
View File

@ -15,194 +15,193 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const Core = require('@wismapping/core-js')
const Core = require('@wismapping/core-js');
const core = Core();
const web2D = require('@wismapping/web2d')
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const Shape = require('./util/Shape').default
const Shape = require('./util/Shape').default;
const ActionDispatcher = require('./ActionDispatcher').default;
const ControlPoint = new Class({
initialize: function () {
var control1 = new web2d.Elipse({
width: 6,
height: 6,
stroke: '1 solid #6589de',
fillColor: 'gray',
visibility: false
});
control1.setCursor('pointer');
initialize() {
const control1 = new web2d.Elipse({
width: 6,
height: 6,
stroke: '1 solid #6589de',
fillColor: 'gray',
visibility: false,
});
control1.setCursor('pointer');
var control2 = new web2d.Elipse({
width: 6,
height: 6,
stroke: '1 solid #6589de',
fillColor: 'gray',
visibility: false
});
control2.setCursor('pointer');
const control2 = new web2d.Elipse({
width: 6,
height: 6,
stroke: '1 solid #6589de',
fillColor: 'gray',
visibility: false,
});
control2.setCursor('pointer');
this._controlPointsController = [control1, control2];
this._controlLines = [new web2d.Line({strokeColor: "#6589de", strokeWidth: 1, opacity: 0.3}),
new web2d.Line({strokeColor: "#6589de", strokeWidth: 1, opacity: 0.3})];
this._controlPointsController = [control1, control2];
this._controlLines = [new web2d.Line({ strokeColor: '#6589de', strokeWidth: 1, opacity: 0.3 }),
new web2d.Line({ strokeColor: '#6589de', strokeWidth: 1, opacity: 0.3 })];
this._isBinded = false;
var me = this;
this._controlPointsController[0].addEvent('mousedown', function (event) {
(me._mouseDown)(event, ControlPoint.FROM, me);
});
this._controlPointsController[0].addEvent('click', function (event) {
(me._mouseClick)(event);
});
this._controlPointsController[0].addEvent('dblclick', function (event) {
(me._mouseClick)(event);
});
this._isBinded = false;
const me = this;
this._controlPointsController[0].addEvent('mousedown', (event) => {
(me._mouseDown)(event, ControlPoint.FROM, me);
});
this._controlPointsController[0].addEvent('click', (event) => {
(me._mouseClick)(event);
});
this._controlPointsController[0].addEvent('dblclick', (event) => {
(me._mouseClick)(event);
});
this._controlPointsController[1].addEvent('mousedown', function (event) {
(me._mouseDown)(event, ControlPoint.TO, me);
});
this._controlPointsController[1].addEvent('click', function (event) {
(me._mouseClick)(event);
});
this._controlPointsController[1].addEvent('dblclick', function (event) {
(me._mouseClick)(event);
});
},
this._controlPointsController[1].addEvent('mousedown', (event) => {
(me._mouseDown)(event, ControlPoint.TO, me);
});
this._controlPointsController[1].addEvent('click', (event) => {
(me._mouseClick)(event);
});
this._controlPointsController[1].addEvent('dblclick', (event) => {
(me._mouseClick)(event);
});
},
setLine: function (line) {
if ($defined(this._line)) {
this._removeLine();
}
this._line = line;
this._createControlPoint();
this._endPoint = [];
this._orignalCtrlPoint = [];
this._orignalCtrlPoint[0] = this._controls[0].clone();
this._orignalCtrlPoint[1] = this._controls[1].clone();
this._endPoint[0] = this._line.getLine().getFrom().clone();
this._endPoint[1] = this._line.getLine().getTo().clone();
},
redraw: function () {
if ($defined(this._line))
this._createControlPoint();
},
_createControlPoint: function () {
this._controls = this._line.getLine().getControlPoints();
var pos = this._line.getLine().getFrom();
this._controlPointsController[0].setPosition(this._controls[ControlPoint.FROM].x + pos.x, this._controls[ControlPoint.FROM].y + pos.y - 3);
this._controlLines[0].setFrom(pos.x, pos.y);
this._controlLines[0].setTo(this._controls[ControlPoint.FROM].x + pos.x + 3, this._controls[ControlPoint.FROM].y + pos.y);
pos = this._line.getLine().getTo();
this._controlLines[1].setFrom(pos.x, pos.y);
this._controlLines[1].setTo(this._controls[ControlPoint.TO].x + pos.x + 3, this._controls[ControlPoint.TO].y + pos.y);
this._controlPointsController[1].setPosition(this._controls[ControlPoint.TO].x + pos.x, this._controls[ControlPoint.TO].y + pos.y - 3);
},
_removeLine: function () {
},
_mouseDown: function (event, point, me) {
if (!this._isBinded) {
this._isBinded = true;
this._mouseMoveFunction = function (event) {
(me._mouseMoveEvent)(event, point, me);
};
this._workspace.getScreenManager().addEvent('mousemove', this._mouseMoveFunction);
this._mouseUpFunction = function (event) {
(me._mouseUp)(event, point, me);
};
this._workspace.getScreenManager().addEvent('mouseup', this._mouseUpFunction);
}
event.preventDefault();
event.stopPropagation();
return false;
},
_mouseMoveEvent: function (event, point) {
var screen = this._workspace.getScreenManager();
var pos = screen.getWorkspaceMousePosition(event);
var cords;
if (point == 0) {
cords = Shape.calculateRelationShipPointCoordinates(this._line.getSourceTopic(), pos);
this._line.setFrom(cords.x, cords.y);
this._line.setSrcControlPoint(new core.Point(pos.x - cords.x, pos.y - cords.y));
} else {
cords = Shape.calculateRelationShipPointCoordinates(this._line.getTargetTopic(), pos);
this._line.setTo(cords.x, cords.y);
this._line.setDestControlPoint(new core.Point(pos.x - cords.x, pos.y - cords.y));
}
this._controls[point].x = (pos.x - cords.x);
this._controls[point].y = (pos.y - cords.y);
this._controlPointsController[point].setPosition(pos.x - 5, pos.y - 3);
this._controlLines[point].setFrom(cords.x, cords.y);
this._controlLines[point].setTo(pos.x - 2, pos.y);
this._line.getLine().updateLine(point);
},
_mouseUp: function (event, point) {
this._workspace.getScreenManager().removeEvent('mousemove', this._mouseMoveFunction);
this._workspace.getScreenManager().removeEvent('mouseup', this._mouseUpFunction);
var actionDispatcher = ActionDispatcher.getInstance();
actionDispatcher.moveControlPoint(this, point);
this._isBinded = false;
},
_mouseClick: function (event) {
event.preventDefault();
event.stopPropagation();
return false;
},
setVisibility: function (visible) {
if (visible) {
this._controlLines[0].moveToFront();
this._controlLines[1].moveToFront();
this._controlPointsController[0].moveToFront();
this._controlPointsController[1].moveToFront();
}
this._controlPointsController[0].setVisibility(visible);
this._controlPointsController[1].setVisibility(visible);
this._controlLines[0].setVisibility(visible);
this._controlLines[1].setVisibility(visible);
},
addToWorkspace: function (workspace) {
this._workspace = workspace;
workspace.append(this._controlPointsController[0]);
workspace.append(this._controlPointsController[1]);
workspace.append(this._controlLines[0]);
workspace.append(this._controlLines[1]);
},
removeFromWorkspace: function (workspace) {
this._workspace = null;
workspace.removeChild(this._controlPointsController[0]);
workspace.removeChild(this._controlPointsController[1]);
workspace.removeChild(this._controlLines[0]);
workspace.removeChild(this._controlLines[1]);
},
getControlPoint: function (index) {
return this._controls[index];
},
getOriginalEndPoint: function (index) {
return this._endPoint[index];
},
getOriginalCtrlPoint: function (index) {
return this._orignalCtrlPoint[index];
setLine(line) {
if ($defined(this._line)) {
this._removeLine();
}
this._line = line;
this._createControlPoint();
this._endPoint = [];
this._orignalCtrlPoint = [];
this._orignalCtrlPoint[0] = this._controls[0].clone();
this._orignalCtrlPoint[1] = this._controls[1].clone();
this._endPoint[0] = this._line.getLine().getFrom().clone();
this._endPoint[1] = this._line.getLine().getTo().clone();
},
redraw() {
if ($defined(this._line)) this._createControlPoint();
},
_createControlPoint() {
this._controls = this._line.getLine().getControlPoints();
let pos = this._line.getLine().getFrom();
this._controlPointsController[0].setPosition(this._controls[ControlPoint.FROM].x + pos.x, this._controls[ControlPoint.FROM].y + pos.y - 3);
this._controlLines[0].setFrom(pos.x, pos.y);
this._controlLines[0].setTo(this._controls[ControlPoint.FROM].x + pos.x + 3, this._controls[ControlPoint.FROM].y + pos.y);
pos = this._line.getLine().getTo();
this._controlLines[1].setFrom(pos.x, pos.y);
this._controlLines[1].setTo(this._controls[ControlPoint.TO].x + pos.x + 3, this._controls[ControlPoint.TO].y + pos.y);
this._controlPointsController[1].setPosition(this._controls[ControlPoint.TO].x + pos.x, this._controls[ControlPoint.TO].y + pos.y - 3);
},
_removeLine() {
},
_mouseDown(event, point, me) {
if (!this._isBinded) {
this._isBinded = true;
this._mouseMoveFunction = function (event) {
(me._mouseMoveEvent)(event, point, me);
};
this._workspace.getScreenManager().addEvent('mousemove', this._mouseMoveFunction);
this._mouseUpFunction = function (event) {
(me._mouseUp)(event, point, me);
};
this._workspace.getScreenManager().addEvent('mouseup', this._mouseUpFunction);
}
event.preventDefault();
event.stopPropagation();
return false;
},
_mouseMoveEvent(event, point) {
const screen = this._workspace.getScreenManager();
const pos = screen.getWorkspaceMousePosition(event);
let cords;
if (point == 0) {
cords = Shape.calculateRelationShipPointCoordinates(this._line.getSourceTopic(), pos);
this._line.setFrom(cords.x, cords.y);
this._line.setSrcControlPoint(new core.Point(pos.x - cords.x, pos.y - cords.y));
} else {
cords = Shape.calculateRelationShipPointCoordinates(this._line.getTargetTopic(), pos);
this._line.setTo(cords.x, cords.y);
this._line.setDestControlPoint(new core.Point(pos.x - cords.x, pos.y - cords.y));
}
this._controls[point].x = (pos.x - cords.x);
this._controls[point].y = (pos.y - cords.y);
this._controlPointsController[point].setPosition(pos.x - 5, pos.y - 3);
this._controlLines[point].setFrom(cords.x, cords.y);
this._controlLines[point].setTo(pos.x - 2, pos.y);
this._line.getLine().updateLine(point);
},
_mouseUp(event, point) {
this._workspace.getScreenManager().removeEvent('mousemove', this._mouseMoveFunction);
this._workspace.getScreenManager().removeEvent('mouseup', this._mouseUpFunction);
const actionDispatcher = ActionDispatcher.getInstance();
actionDispatcher.moveControlPoint(this, point);
this._isBinded = false;
},
_mouseClick(event) {
event.preventDefault();
event.stopPropagation();
return false;
},
setVisibility(visible) {
if (visible) {
this._controlLines[0].moveToFront();
this._controlLines[1].moveToFront();
this._controlPointsController[0].moveToFront();
this._controlPointsController[1].moveToFront();
}
this._controlPointsController[0].setVisibility(visible);
this._controlPointsController[1].setVisibility(visible);
this._controlLines[0].setVisibility(visible);
this._controlLines[1].setVisibility(visible);
},
addToWorkspace(workspace) {
this._workspace = workspace;
workspace.append(this._controlPointsController[0]);
workspace.append(this._controlPointsController[1]);
workspace.append(this._controlLines[0]);
workspace.append(this._controlLines[1]);
},
removeFromWorkspace(workspace) {
this._workspace = null;
workspace.removeChild(this._controlPointsController[0]);
workspace.removeChild(this._controlPointsController[1]);
workspace.removeChild(this._controlLines[0]);
workspace.removeChild(this._controlLines[1]);
},
getControlPoint(index) {
return this._controls[index];
},
getOriginalEndPoint(index) {
return this._endPoint[index];
},
getOriginalCtrlPoint(index) {
return this._orignalCtrlPoint[index];
},
});
ControlPoint.FROM = 0;

1492
packages/mindplot/lib/components/Designer.js
View File

File diff suppressed because it is too large Load Diff

56
packages/mindplot/lib/components/DesignerActionRunner.js
View File

@ -19,40 +19,38 @@ const DesignerUndoManager = require('./DesignerUndoManager').default;
const EventBus = require('./layout/EventBus').default;
const DesignerActionRunner = new Class({
initialize: function (commandContext, notifier) {
$assert(commandContext, "commandContext can not be null");
initialize(commandContext, notifier) {
$assert(commandContext, 'commandContext can not be null');
this._undoManager = new DesignerUndoManager();
this._context = commandContext;
this._notifier = notifier;
},
this._undoManager = new DesignerUndoManager();
this._context = commandContext;
this._notifier = notifier;
},
execute: function (command) {
$assert(command, "command can not be null");
command.execute(this._context);
this._undoManager.enqueue(command);
this.fireChangeEvent();
EventBus.instance.fireEvent(EventBus.events.DoLayout);
execute(command) {
$assert(command, 'command can not be null');
command.execute(this._context);
this._undoManager.enqueue(command);
this.fireChangeEvent();
EventBus.instance.fireEvent(EventBus.events.DoLayout);
},
},
undo() {
this._undoManager.execUndo(this._context);
this.fireChangeEvent();
EventBus.instance.fireEvent(EventBus.events.DoLayout);
},
undo: function () {
this._undoManager.execUndo(this._context);
this.fireChangeEvent();
EventBus.instance.fireEvent(EventBus.events.DoLayout);
},
redo() {
this._undoManager.execRedo(this._context);
this.fireChangeEvent();
EventBus.instance.fireEvent(EventBus.events.DoLayout);
},
redo: function () {
this._undoManager.execRedo(this._context);
this.fireChangeEvent();
EventBus.instance.fireEvent(EventBus.events.DoLayout);
},
fireChangeEvent: function () {
var event = this._undoManager.buildEvent();
this._notifier.fireEvent("modelUpdate", event);
}
fireChangeEvent() {
const event = this._undoManager.buildEvent();
this._notifier.fireEvent('modelUpdate', event);
},
});
export default DesignerActionRunner;

763
packages/mindplot/lib/components/DesignerKeyboard.js
View File

@ -18,383 +18,416 @@
const Keyboard = require('./Keyboard').default;
const DesignerKeyboard = new Class({
Extends: Keyboard,
Static:{
register:function (designer) {
this._instance = new DesignerKeyboard(designer);
},
Extends: Keyboard,
Static: {
register(designer) {
this._instance = new DesignerKeyboard(designer);
},
getInstance:function () {
return this._instance;
getInstance() {
return this._instance;
},
},
initialize(designer) {
$assert(designer, 'designer can not be null');
this._registerEvents(designer);
},
_registerEvents(designer) {
// Try with the keyboard ..
const model = designer.getModel();
this.addShortcut(
['backspace'], (event) => {
event.preventDefault();
event.stopPropagation();
designer.deleteSelectedEntities();
},
);
this.addShortcut(
['space'], () => {
designer.shrinkSelectedBranch();
},
);
this.addShortcut(
['f2'], (event) => {
event.stopPropagation();
event.preventDefault();
const node = model.selectedTopic();
if (node) {
node.showTextEditor();
}
},
},
);
this.addShortcut(
['del'], (event) => {
designer.deleteSelectedEntities();
event.preventDefault();
event.stopPropagation();
},
);
this.addShortcut(
['enter'], () => {
designer.createSiblingForSelectedNode();
},
);
this.addShortcut(
['insert'], (event) => {
designer.createChildForSelectedNode();
event.preventDefault();
event.stopPropagation();
},
);
this.addShortcut(
['tab'], (event) => {
designer.createChildForSelectedNode();
event.preventDefault();
event.stopPropagation();
},
);
this.addShortcut(
['meta+enter'], (event) => {
event.preventDefault();
event.stopPropagation();
designer.createChildForSelectedNode();
},
);
this.addShortcut(
['ctrl+z', 'meta+z'], (event) => {
event.preventDefault(event);
event.stopPropagation();
designer.undo();
},
);
this.addShortcut(
['ctrl+c', 'meta+c'], (event) => {
event.preventDefault(event);
event.stopPropagation();
designer.copyToClipboard();
},
);
this.addShortcut(
['ctrl+v', 'meta+v'], (event) => {
event.preventDefault(event);
event.stopPropagation();
designer.pasteClipboard();
},
);
this.addShortcut(
['ctrl+shift+z', 'meta+shift+z', 'ctrl+y', 'meta+y'], (event) => {
event.preventDefault();
event.stopPropagation();
designer.redo();
},
);
this.addShortcut(
['ctrl+a', 'meta+a'], (event) => {
event.preventDefault();
event.stopPropagation();
designer.selectAll();
},
);
this.addShortcut(
['ctrl+b', 'meta+b'], (event) => {
event.preventDefault();
event.stopPropagation();
initialize:function (designer) {
$assert(designer, "designer can not be null");
this._registerEvents(designer);
},
designer.changeFontWeight();
},
);
this.addShortcut(
['ctrl+s', 'meta+s'], (event) => {
event.preventDefault();
event.stopPropagation();
$(document).find('#save').trigger('click');
},
);
this.addShortcut(
['ctrl+i', 'meta+i'], (event) => {
event.preventDefault();
event.stopPropagation();
_registerEvents:function (designer) {
designer.changeFontStyle();
},
);
this.addShortcut(
['ctrl+shift+a', 'meta+shift+a'], (event) => {
event.preventDefault();
event.stopPropagation();
// Try with the keyboard ..
var model = designer.getModel();
this.addShortcut(
['backspace'], function (event) {
event.preventDefault();
event.stopPropagation();
designer.deleteSelectedEntities();
}
);
this.addShortcut(
['space'], function() {
designer.shrinkSelectedBranch();
}
);
this.addShortcut(
['f2'],function(event) {
event.stopPropagation();
event.preventDefault();
var node = model.selectedTopic();
if (node) {
node.showTextEditor();
}
}
);
this.addShortcut(
['del'], function(event) {
designer.deleteSelectedEntities();
event.preventDefault();
event.stopPropagation();
}
);
this.addShortcut(
['enter'], function() {
designer.createSiblingForSelectedNode();
}
);
this.addShortcut(
['insert'], function(event) {
designer.createChildForSelectedNode();
event.preventDefault();
event.stopPropagation();
}
);
this.addShortcut(
['tab'], function(event) {
designer.createChildForSelectedNode();
event.preventDefault();
event.stopPropagation();
}
);
this.addShortcut(
['meta+enter'], function(event) {
event.preventDefault();
event.stopPropagation();
designer.createChildForSelectedNode();
}
);
this.addShortcut(
['ctrl+z', 'meta+z'], function(event) {
event.preventDefault(event);
event.stopPropagation();
designer.undo();
}
);
this.addShortcut(
['ctrl+c', 'meta+c'], function (event) {
event.preventDefault(event);
event.stopPropagation();
designer.copyToClipboard();
}
);
this.addShortcut(
['ctrl+v', 'meta+v'], function (event) {
event.preventDefault(event);
event.stopPropagation();
designer.pasteClipboard();
}
);
this.addShortcut(
['ctrl+shift+z', 'meta+shift+z', 'ctrl+y', 'meta+y'], function (event) {
event.preventDefault();
event.stopPropagation();
designer.redo();
}
);
this.addShortcut(
['ctrl+a', 'meta+a'], function (event) {
event.preventDefault();
event.stopPropagation();
designer.selectAll();
}
);
this.addShortcut(
['ctrl+b', 'meta+b'], function (event) {
event.preventDefault();
event.stopPropagation();
designer.changeFontWeight();
}
);
this.addShortcut(
['ctrl+s', 'meta+s'], function (event) {
event.preventDefault();
event.stopPropagation();
$(document).find('#save').trigger('click');
}
);
this.addShortcut(
['ctrl+i', 'meta+i'], function (event) {
event.preventDefault();
event.stopPropagation();
designer.changeFontStyle();
}
);
this.addShortcut(
['ctrl+shift+a', 'meta+shift+a'], function (event) {
event.preventDefault();
event.stopPropagation();
designer.deselectAll();
}
);
this.addShortcut(
['meta+=', 'ctrl+='], function (event) {
event.preventDefault();
event.stopPropagation();
designer.zoomIn();
}
);
this.addShortcut(
['meta+-', 'ctrl+-'], function (event) {
event.preventDefault();
event.stopPropagation();
designer.zoomOut();
}
);
var me = this;
this.addShortcut(
'right', function (event) {
var node = model.selectedTopic();
if (node) {
if (node.isCentralTopic()) {
me._goToSideChild(designer, node, 'RIGHT');
}
else {
if (node.getPosition().x < 0) {
me._goToParent(designer, node);
}
else if (!node.areChildrenShrunken()) {
me._goToChild(designer, node);
}
}
} else {
var centralTopic = model.getCentralTopic();
me._goToNode(designer, centralTopic);
}
event.preventDefault();
event.stopPropagation();
}
);
this.addShortcut(
'left', function (event) {
var node = model.selectedTopic();
if (node) {
if (node.isCentralTopic()) {
me._goToSideChild(designer, node, 'LEFT');
}
else {
if (node.getPosition().x > 0) {
me._goToParent(designer, node);
}
else if (!node.areChildrenShrunken()) {
me._goToChild(designer, node);
}
}
} else {
var centralTopic = model.getCentralTopic();
me._goToNode(designer, centralTopic);
}
event.preventDefault();
event.stopPropagation();
}
);
this.addShortcut(
'up', function (event) {
var node = model.selectedTopic();
if (node) {
if (!node.isCentralTopic()) {
me._goToBrother(designer, node, 'UP');
}
} else {
var centralTopic = model.getCentralTopic();
me._goToNode(designer, centralTopic);
}
event.preventDefault();
event.stopPropagation();
}
);
this.addShortcut(
'down', function (event) {
var node = model.selectedTopic();
if (node) {
if (!node.isCentralTopic()) {
me._goToBrother(designer, node, 'DOWN');
}
} else {
var centralTopic = model.getCentralTopic();
me._goToNode(designer, centralTopic);
}
event.preventDefault();
event.stopPropagation();
}
);
var excludes = ['esc', 'escape', 'f1', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12'];
$(document).on('keypress', function (event) {
var keyCode;
// Firefox doesn't skip special keys for keypress event...
if (event.key && excludes.contains(event.key.toLowerCase())) {
return;
}
// Sometimes Firefox doesn't contain keyCode value
if (event.key && event.keyCode == 0) {
keyCode = event.charCode;
} else {
keyCode = event.keyCode;
}
var specialKey = jQuery.hotkeys.specialKeys[keyCode];
if (["enter", "capslock"].indexOf(specialKey) == -1 && !jQuery.hotkeys.shiftNums[keyCode]) {
var nodes = designer.getModel().filterSelectedTopics();
if (nodes.length > 0) {
// If a modifier is press, the key selected must be ignored.
var pressKey = String.fromCharCode(keyCode);
if (event.ctrlKey || event.altKey || event.metaKey) {
return;
}
nodes[0].showTextEditor(pressKey);
event.stopPropagation();
}
}
});
},
_goToBrother:function (designer, node, direction) {
var parent = node.getParent();
if (parent) {
var brothers = parent.getChildren();
var target = node;
var y = node.getPosition().y;
var x = node.getPosition().x;
var dist = null;
for (var i = 0; i < brothers.length; i++) {
var sameSide = (x * brothers[i].getPosition().x) >= 0;
if (brothers[i] != node && sameSide) {
var brother = brothers[i];
var brotherY = brother.getPosition().y;
if (direction == "DOWN" && brotherY > y) {
var distancia = y - brotherY;
if (distancia < 0) {
distancia = distancia * (-1);
}
if (dist == null || dist > distancia) {
dist = distancia;
target = brothers[i];
}
}
else if (direction == "UP" && brotherY < y) {
var distance = y - brotherY;
if (distance < 0) {
distance = distance * (-1);
}
if (dist == null || dist > distance) {
dist = distance;
target = brothers[i];
}
}
}
}
this._goToNode(designer, target);
}
},
_goToSideChild:function (designer, node, side) {
var children = node.getChildren();
if (children.length > 0) {
var target = children[0];
var top = null;
for (var i = 0; i < children.length; i++) {
var child = children[i];
var childY = child.getPosition().y;
if (side == 'LEFT' && child.getPosition().x < 0) {
if (top == null || childY < top) {
target = child;
top = childY;
}
}
if (side == 'RIGHT' && child.getPosition().x > 0) {
if (top == null || childY < top) {
target = child;
top = childY;
}
}
}
this._goToNode(designer, target);
}
},
_goToParent:function (designer, node) {
var parent = node.getParent();
if (parent) {
this._goToNode(designer, parent);
}
},
_goToChild:function (designer, node) {
var children = node.getChildren();
if (children.length > 0) {
var target = children[0];
var top = target.getPosition().y;
for (var i = 0; i < children.length; i++) {
var child = children[i];
if (child.getPosition().y < top) {
top = child.getPosition().y;
target = child;
}
}
this._goToNode(designer, target);
}
},
_goToNode:function (designer, node) {
// First deselect all the nodes ...
designer.deselectAll();
},
);
this.addShortcut(
['meta+=', 'ctrl+='], (event) => {
event.preventDefault();
event.stopPropagation();
// Give focus to the selected node....
node.setOnFocus(true);
designer.zoomIn();
},
);
this.addShortcut(
['meta+-', 'ctrl+-'], (event) => {
event.preventDefault();
event.stopPropagation();
designer.zoomOut();
},
);
const me = this;
this.addShortcut(
'right', (event) => {
const node = model.selectedTopic();
if (node) {
if (node.isCentralTopic()) {
me._goToSideChild(designer, node, 'RIGHT');
} else if (node.getPosition().x < 0) {
me._goToParent(designer, node);
} else if (!node.areChildrenShrunken()) {
me._goToChild(designer, node);
}
} else {
const centralTopic = model.getCentralTopic();
me._goToNode(designer, centralTopic);
}
event.preventDefault();
event.stopPropagation();
},
);
this.addShortcut(
'left', (event) => {
const node = model.selectedTopic();
if (node) {
if (node.isCentralTopic()) {
me._goToSideChild(designer, node, 'LEFT');
} else if (node.getPosition().x > 0) {
me._goToParent(designer, node);
} else if (!node.areChildrenShrunken()) {
me._goToChild(designer, node);
}
} else {
const centralTopic = model.getCentralTopic();
me._goToNode(designer, centralTopic);
}
event.preventDefault();
event.stopPropagation();
},
);
this.addShortcut(
'up', (event) => {
const node = model.selectedTopic();
if (node) {
if (!node.isCentralTopic()) {
me._goToBrother(designer, node, 'UP');
}
} else {
const centralTopic = model.getCentralTopic();
me._goToNode(designer, centralTopic);
}
event.preventDefault();
event.stopPropagation();
},
);
this.addShortcut(
'down', (event) => {
const node = model.selectedTopic();
if (node) {
if (!node.isCentralTopic()) {
me._goToBrother(designer, node, 'DOWN');
}
} else {
const centralTopic = model.getCentralTopic();
me._goToNode(designer, centralTopic);
}
event.preventDefault();
event.stopPropagation();
},
);
const excludes = ['esc', 'escape', 'f1', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12'];
$(document).on('keypress', (event) => {
let keyCode;
// Firefox doesn't skip special keys for keypress event...
if (event.key && excludes.contains(event.key.toLowerCase())) {
return;
}
// Sometimes Firefox doesn't contain keyCode value
if (event.key && event.keyCode == 0) {
keyCode = event.charCode;
} else {
keyCode = event.keyCode;
}
const specialKey = jQuery.hotkeys.specialKeys[keyCode];
if (['enter', 'capslock'].indexOf(specialKey) == -1 && !jQuery.hotkeys.shiftNums[keyCode]) {
const nodes = designer.getModel().filterSelectedTopics();
if (nodes.length > 0) {
// If a modifier is press, the key selected must be ignored.
const pressKey = String.fromCharCode(keyCode);
if (event.ctrlKey || event.altKey || event.metaKey) {
return;
}
nodes[0].showTextEditor(pressKey);
event.stopPropagation();
}
}
});
},
_goToBrother(designer, node, direction) {
const parent = node.getParent();
if (parent) {
const brothers = parent.getChildren();
let target = node;
const { y } = node.getPosition();
const { x } = node.getPosition();
let dist = null;
for (let i = 0; i < brothers.length; i++) {
const sameSide = (x * brothers[i].getPosition().x) >= 0;
if (brothers[i] != node && sameSide) {
const brother = brothers[i];
const brotherY = brother.getPosition().y;
if (direction == 'DOWN' && brotherY > y) {
let distancia = y - brotherY;
if (distancia < 0) {
distancia *= (-1);
}
if (dist == null || dist > distancia) {
dist = distancia;
target = brothers[i];
}
} else if (direction == 'UP' && brotherY < y) {
let distance = y - brotherY;
if (distance < 0) {
distance *= (-1);
}
if (dist == null || dist > distance) {
dist = distance;
target = brothers[i];
}
}
}
}
this._goToNode(designer, target);
}
},
_goToSideChild(designer, node, side) {
const children = node.getChildren();
if (children.length > 0) {
let target = children[0];
let top = null;
for (let i = 0; i < children.length; i++) {
const child = children[i];
const childY = child.getPosition().y;
if (side == 'LEFT' && child.getPosition().x < 0) {
if (top == null || childY < top) {
target = child;
top = childY;
}
}
if (side == 'RIGHT' && child.getPosition().x > 0) {
if (top == null || childY < top) {
target = child;
top = childY;
}
}
}
this._goToNode(designer, target);
}
},
_goToParent(designer, node) {
const parent = node.getParent();
if (parent) {
this._goToNode(designer, parent);
}
},
_goToChild(designer, node) {
const children = node.getChildren();
if (children.length > 0) {
let target = children[0];
let top = target.getPosition().y;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.getPosition().y < top) {
top = child.getPosition().y;
target = child;
}
}
this._goToNode(designer, target);
}
},
_goToNode(designer, node) {
// First deselect all the nodes ...
designer.deselectAll();
// Give focus to the selected node....
node.setOnFocus(true);
},
});
DesignerKeyboard.specialKeys = {
8: "backspace", 9: "tab", 10: "return", 13: "enter", 16: "shift", 17: "ctrl", 18: "alt", 19: "pause",
20: "capslock", 27: "esc", 32: "space", 33: "pageup", 34: "pagedown", 35: "end", 36: "home",
37: "left", 38: "up", 39: "right", 40: "down", 45: "insert", 46: "del",
96: "0", 97: "1", 98: "2", 99: "3", 100: "4", 101: "5", 102: "6", 103: "7",
104: "8", 105: "9", 106: "*", 107: "+", 109: "-", 110: ".", 111 : "/",
112: "f1", 113: "f2", 114: "f3", 115: "f4", 116: "f5", 117: "f6", 118: "f7", 119: "f8",
120: "f9", 121: "f10", 122: "f11", 123: "f12", 144: "numlock", 145: "scroll", 186: ";", 191: "/",
220: "\\", 222: "'", 224: "meta"
8: 'backspace',
9: 'tab',
10: 'return',
13: 'enter',
16: 'shift',
17: 'ctrl',
18: 'alt',
19: 'pause',
20: 'capslock',
27: 'esc',
32: 'space',
33: 'pageup',
34: 'pagedown',
35: 'end',
36: 'home',
37: 'left',
38: 'up',
39: 'right',
40: 'down',
45: 'insert',
46: 'del',
96: '0',
97: '1',
98: '2',
99: '3',
100: '4',
101: '5',
102: '6',
103: '7',
104: '8',
105: '9',
106: '*',
107: '+',
109: '-',
110: '.',
111: '/',
112: 'f1',
113: 'f2',
114: 'f3',
115: 'f4',
116: 'f5',
117: 'f6',
118: 'f7',
119: 'f8',
120: 'f9',
121: 'f10',
122: 'f11',
123: 'f12',
144: 'numlock',
145: 'scroll',
186: ';',
191: '/',
220: '\\',
222: "'",
224: 'meta',
};
export default DesignerKeyboard;

230
packages/mindplot/lib/components/DesignerModel.js
View File

@ -18,174 +18,172 @@
const Events = require('./Events').default;
const DesignerModel = new Class(/** @lends DesignerModel */{
Implements:[Events],
/**
Implements: [Events],
/**
* @implements {mindplot.Events}
* @constructs
* @param {{readOnly: Boolean, zoom: Number, saveOnLoad: Boolean, size: {width: Number,
* height: Number}, viewPort: {width: Number, height: Number}, container: String,
* @param {{readOnly: Boolean, zoom: Number, saveOnLoad: Boolean, size: {width: Number,
* height: Number}, viewPort: {width: Number, height: Number}, container: String,
* persistenceManager: String, mapId: String, locale: String}} options
* options loaded from json config
* options loaded from json config
* @see {@link ConfigParameters.md}
* @see {@link editor.html}
*/
initialize:function (options) {
this._zoom = options.zoom;
this._topics = [];
this._relationships = [];
},
initialize(options) {
this._zoom = options.zoom;
this._topics = [];
this._relationships = [];
},
/** @return {Number} zoom between 0.3 (largest text) and 1.9 */
getZoom:function () {
return this._zoom;
},
/** @return {Number} zoom between 0.3 (largest text) and 1.9 */
getZoom() {
return this._zoom;
},
/** @param {Number} zoom number between 0.3 and 1.9 to set the zoom to */
setZoom:function (zoom) {
this._zoom = zoom;
},
/** @param {Number} zoom number between 0.3 and 1.9 to set the zoom to */
setZoom(zoom) {
this._zoom = zoom;
},
/** @return {@link mindplot.Topic[]} all topics */
getTopics:function () {
return this._topics;
},
/** @return {@link mindplot.Topic[]} all topics */
getTopics() {
return this._topics;
},
/** @return {mindplot.Relationship[]} all relationships */
getRelationships:function () {
return this._relationships;
},
/** @return {mindplot.Relationship[]} all relationships */
getRelationships() {
return this._relationships;
},
/** @return {mindplot.CentralTopic} the central topic */
getCentralTopic:function () {
var topics = this.getTopics();
return topics[0];
},
/** @return {mindplot.CentralTopic} the central topic */
getCentralTopic() {
const topics = this.getTopics();
return topics[0];
},
/** @return {mindplot.Topic[]} selected topics */
filterSelectedTopics:function () {
var result = [];
for (var i = 0; i < this._topics.length; i++) {
if (this._topics[i].isOnFocus()) {
result.push(this._topics[i]);
}
}
return result;
},
/** @return {mindplot.Topic[]} selected topics */
filterSelectedTopics() {
const result = [];
for (let i = 0; i < this._topics.length; i++) {
if (this._topics[i].isOnFocus()) {
result.push(this._topics[i]);
}
}
return result;
},
/**
/**
* @return {mindplot.Relationship[]} selected relationships
*/
filterSelectedRelationships:function () {
var result = [];
for (var i = 0; i < this._relationships.length; i++) {
if (this._relationships[i].isOnFocus()) {
result.push(this._relationships[i]);
}
}
return result;
},
filterSelectedRelationships() {
const result = [];
for (let i = 0; i < this._relationships.length; i++) {
if (this._relationships[i].isOnFocus()) {
result.push(this._relationships[i]);
}
}
return result;
},
/**
/**
* @return {Array.<mindplot.Relationship, mindplot.Topic>} all topics and relationships
*/
getEntities:function () {
var result = [].append(this._topics);
result.append(this._relationships);
return result;
},
getEntities() {
const result = [].append(this._topics);
result.append(this._relationships);
return result;
},
/**
/**
* removes occurrences of the given topic from the topic array
* @param {mindplot.Topic} topic the topic to remove
*/
removeTopic:function (topic) {
$assert(topic, "topic can not be null");
this._topics.erase(topic);
},
removeTopic(topic) {
$assert(topic, 'topic can not be null');
this._topics.erase(topic);
},
/**
/**
* removes occurrences of the given relationship from the relationship array
* @param {mindplot.Relationship} rel the relationship to remove
*/
removeRelationship:function (rel) {
$assert(rel, "rel can not be null");
this._relationships.erase(rel);
},
removeRelationship(rel) {
$assert(rel, 'rel can not be null');
this._relationships.erase(rel);
},
/**
/**
* adds the given topic to the topic array
* @param {mindplot.Topic} topic the topic to add
* @throws will throw an error if topic is null or undefined
* @throws will throw an error if the topic's id is not a number
*/
addTopic:function (topic) {
$assert(topic, "topic can not be null");
$assert(typeof topic.getId() == "number", "id is not a number:" + topic.getId());
this._topics.push(topic);
},
addTopic(topic) {
$assert(topic, 'topic can not be null');
$assert(typeof topic.getId() === 'number', `id is not a number:${topic.getId()}`);
this._topics.push(topic);
},
/**
/**
* adds the given relationship to the relationship array
* @param {mindplot.Relationship} rel the relationship to add
* @throws will throw an error if rel is null or undefined
*/
addRelationship:function (rel) {
$assert(rel, "rel can not be null");
this._relationships.push(rel);
},
addRelationship(rel) {
$assert(rel, 'rel can not be null');
this._relationships.push(rel);
},
/**
/**
* @param {Function=} validate a function to validate nodes
* @param {String=} errorMsg an error message to display if the validation fails
* @return {String} returns an array of the selected (and, if applicable, valid) topics' ids
*/
filterTopicsIds:function (validate, errorMsg) {
var result = [];
var topics = this.filterSelectedTopics();
filterTopicsIds(validate, errorMsg) {
const result = [];
const topics = this.filterSelectedTopics();
let isValid = true;
for (let i = 0; i < topics.length; i++) {
const selectedNode = topics[i];
if ($defined(validate)) {
isValid = validate(selectedNode);
}
var isValid = true;
for (var i = 0; i < topics.length; i++) {
var selectedNode = topics[i];
if ($defined(validate)) {
isValid = validate(selectedNode);
}
// Add node only if it's valid.
if (isValid) {
result.push(selectedNode.getId());
} else {
$notify(errorMsg);
}
}
return result;
},
// Add node only if it's valid.
if (isValid) {
result.push(selectedNode.getId());
} else {
$notify(errorMsg);
}
}
return result;
},
/**
* @return {mindplot.Topic} the first selected topic if one or more are found by the
/**
* @return {mindplot.Topic} the first selected topic if one or more are found by the
* filterSelectedTopics function, null otherwise
*/
selectedTopic:function () {
var topics = this.filterSelectedTopics();
return (topics.length > 0) ? topics[0] : null;
},
selectedTopic() {
const topics = this.filterSelectedTopics();
return (topics.length > 0) ? topics[0] : null;
},
/**
/**
* @param {String} id the id of the topic to be retrieved
* @return {mindplot.Topic} the topic with the respective id
*/
findTopicById:function (id) {
var result = null;
for (var i = 0; i < this._topics.length; i++) {
var topic = this._topics[i];
if (topic.getId() == id) {
result = topic;
break;
}
}
return result;
findTopicById(id) {
let result = null;
for (let i = 0; i < this._topics.length; i++) {
const topic = this._topics[i];
if (topic.getId() == id) {
result = topic;
break;
}
}
return result;
},
});
export default DesignerModel;

122
packages/mindplot/lib/components/DesignerUndoManager.js
View File

@ -17,69 +17,69 @@
*/
const DesignerUndoManager = new Class({
initialize: function(fireChange) {
this._undoQueue = [];
this._redoQueue = [];
this._baseId = 0;
},
initialize(fireChange) {
this._undoQueue = [];
this._redoQueue = [];
this._baseId = 0;
},
enqueue:function(command) {
$assert(command, "Command can not be null");
var length = this._undoQueue.length;
if (command.discardDuplicated && length > 0) {
// Skip duplicated events ...
var lastItem = this._undoQueue[length - 1];
if (lastItem.discardDuplicated != command.discardDuplicated) {
this._undoQueue.push(command);
}
} else {
this._undoQueue.push(command);
}
this._redoQueue = [];
},
execUndo: function(commandContext) {
if (this._undoQueue.length > 0) {
var command = this._undoQueue.pop();
this._redoQueue.push(command);
command.undoExecute(commandContext);
}
},
execRedo: function(commandContext) {
if (this._redoQueue.length > 0) {
var command = this._redoQueue.pop();
this._undoQueue.push(command);
command.execute(commandContext);
}
},
buildEvent: function() {
return {undoSteps: this._undoQueue.length, redoSteps:this._redoQueue.length};
},
markAsChangeBase: function() {
var undoLength = this._undoQueue.length;
if (undoLength > 0) {
var command = this._undoQueue[undoLength - 1];
this._baseId = command.getId();
} else {
this._baseId = 0;
}
},
hasBeenChanged: function() {
var result = true;
var undoLength= this._undoQueue.length;
if (undoLength == 0 && this._baseId == 0) {
result = false;
} else if (undoLength > 0) {
var command = this._undoQueue[undoLength - 1];
result = (this._baseId != command.getId());
}
return result;
enqueue(command) {
$assert(command, 'Command can not be null');
const { length } = this._undoQueue;
if (command.discardDuplicated && length > 0) {
// Skip duplicated events ...
const lastItem = this._undoQueue[length - 1];
if (lastItem.discardDuplicated != command.discardDuplicated) {
this._undoQueue.push(command);
}
} else {
this._undoQueue.push(command);
}
this._redoQueue = [];
},
execUndo(commandContext) {
if (this._undoQueue.length > 0) {
const command = this._undoQueue.pop();
this._redoQueue.push(command);
command.undoExecute(commandContext);
}
},
execRedo(commandContext) {
if (this._redoQueue.length > 0) {
const command = this._redoQueue.pop();
this._undoQueue.push(command);
command.execute(commandContext);
}
},
buildEvent() {
return { undoSteps: this._undoQueue.length, redoSteps: this._redoQueue.length };
},
markAsChangeBase() {
const undoLength = this._undoQueue.length;
if (undoLength > 0) {
const command = this._undoQueue[undoLength - 1];
this._baseId = command.getId();
} else {
this._baseId = 0;
}
},
hasBeenChanged() {
let result = true;
const undoLength = this._undoQueue.length;
if (undoLength == 0 && this._baseId == 0) {
result = false;
} else if (undoLength > 0) {
const command = this._undoQueue[undoLength - 1];
result = (this._baseId != command.getId());
}
return result;
},
});
export default DesignerUndoManager;

167
packages/mindplot/lib/components/DragConnector.js
View File

@ -17,99 +17,94 @@
*/
const DragConnector = new Class({
initialize:function (designerModel, workspace) {
$assert(designerModel, 'designerModel can not be null');
$assert(workspace, 'workspace can not be null');
initialize(designerModel, workspace) {
$assert(designerModel, 'designerModel can not be null');
$assert(workspace, 'workspace can not be null');
// this._layoutManager = layoutManager;
this._designerModel = designerModel;
this._workspace = workspace;
},
// this._layoutManager = layoutManager;
this._designerModel = designerModel;
this._workspace = workspace;
},
checkConnection:function (dragTopic) {
var topics = this._designerModel.getTopics();
checkConnection(dragTopic) {
const topics = this._designerModel.getTopics();
// Must be disconnected from their current connection ?.
var candidates = this._searchConnectionCandidates(dragTopic);
var currentConnection = dragTopic.getConnectedToTopic();
if (currentConnection && (candidates.length == 0 || candidates[0] != currentConnection)) {
dragTopic.disconnect(this._workspace);
}
// Finally, connect nodes ...
if (!dragTopic.isConnected() && candidates.length > 0) {
dragTopic.connectTo(candidates[0]);
}
},
_searchConnectionCandidates:function (dragTopic) {
var topics = this._designerModel.getTopics();
var draggedNode = dragTopic.getDraggedTopic();
// Drag node connects to the border ...
var dragTopicWidth = dragTopic.getSize ? dragTopic.getSize().width : 0; // Hack...
var xMouseGap = dragTopic.getPosition().x > 0 ? 0 : dragTopicWidth;
var sPos = {x:dragTopic.getPosition().x - xMouseGap, y:dragTopic.getPosition().y};
// Perform a initial filter to discard topics:
// - Exclude dragged topic
// - Exclude dragTopic pivot
// - Nodes that are collapsed
// - It's not part of the branch dragged itself
topics = topics.filter(function (topic) {
var result = draggedNode != topic;
result = result && topic != draggedNode;
result = result && !topic.areChildrenShrunken() && !topic.isCollapsed();
result = result && !draggedNode.isChildTopic(topic);
return result;
});
// Filter all the nodes that are outside the vertical boundary:
// * The node is to out of the x scope
// * The x distance greater the vertical tolerated distance
topics = topics.filter(function (topic) {
var tpos = topic.getPosition();
// Center topic has different alignment than the rest of the nodes. That's why i need to divide it by two...
var txborder = tpos.x + (topic.getSize().width / 2) * Math.sign(sPos.x);
var distance = (sPos.x - txborder) * Math.sign(sPos.x);
return distance > 0 && (distance < DragConnector.MAX_VERTICAL_CONNECTION_TOLERANCE);
});
// Assign a priority based on the distance:
// - Alignment with the targetNode
// - Vertical distance
// - Horizontal proximity
// - It's already connected.
var currentConnection = dragTopic.getConnectedToTopic();
var me = this;
topics = topics.sort(function (a, b) {
var aPos = a.getPosition();
var bPos = b.getPosition();
var av = me._isVerticallyAligned(a.getSize(), aPos, sPos);
var bv = me._isVerticallyAligned(b.getSize(), bPos, sPos);
return me._proximityWeight(av, a, sPos, currentConnection) - me._proximityWeight(bv, b, sPos, currentConnection);
});
return topics;
},
_proximityWeight:function (isAligned, target, sPos, currentConnection) {
var tPos = target.getPosition();
return (isAligned ? 0 : 200 ) + Math.abs(tPos.x - sPos.x) + Math.abs(tPos.y - sPos.y) + (currentConnection == target ? 0 : 100);
},
_isVerticallyAligned:function (targetSize, targetPosition, sourcePosition) {
return Math.abs(sourcePosition.y - targetPosition.y) < targetSize.height / 2;
// Must be disconnected from their current connection ?.
const candidates = this._searchConnectionCandidates(dragTopic);
const currentConnection = dragTopic.getConnectedToTopic();
if (currentConnection && (candidates.length == 0 || candidates[0] != currentConnection)) {
dragTopic.disconnect(this._workspace);
}
// Finally, connect nodes ...
if (!dragTopic.isConnected() && candidates.length > 0) {
dragTopic.connectTo(candidates[0]);
}
},
_searchConnectionCandidates(dragTopic) {
let topics = this._designerModel.getTopics();
const draggedNode = dragTopic.getDraggedTopic();
// Drag node connects to the border ...
const dragTopicWidth = dragTopic.getSize ? dragTopic.getSize().width : 0; // Hack...
const xMouseGap = dragTopic.getPosition().x > 0 ? 0 : dragTopicWidth;
const sPos = { x: dragTopic.getPosition().x - xMouseGap, y: dragTopic.getPosition().y };
// Perform a initial filter to discard topics:
// - Exclude dragged topic
// - Exclude dragTopic pivot
// - Nodes that are collapsed
// - It's not part of the branch dragged itself
topics = topics.filter((topic) => {
let result = draggedNode != topic;
result = result && topic != draggedNode;
result = result && !topic.areChildrenShrunken() && !topic.isCollapsed();
result = result && !draggedNode.isChildTopic(topic);
return result;
});
// Filter all the nodes that are outside the vertical boundary:
// * The node is to out of the x scope
// * The x distance greater the vertical tolerated distance
topics = topics.filter((topic) => {
const tpos = topic.getPosition();
// Center topic has different alignment than the rest of the nodes. That's why i need to divide it by two...
const txborder = tpos.x + (topic.getSize().width / 2) * Math.sign(sPos.x);
const distance = (sPos.x - txborder) * Math.sign(sPos.x);
return distance > 0 && (distance < DragConnector.MAX_VERTICAL_CONNECTION_TOLERANCE);
});
// Assign a priority based on the distance:
// - Alignment with the targetNode
// - Vertical distance
// - Horizontal proximity
// - It's already connected.
const currentConnection = dragTopic.getConnectedToTopic();
const me = this;
topics = topics.sort((a, b) => {
const aPos = a.getPosition();
const bPos = b.getPosition();
const av = me._isVerticallyAligned(a.getSize(), aPos, sPos);
const bv = me._isVerticallyAligned(b.getSize(), bPos, sPos);
return me._proximityWeight(av, a, sPos, currentConnection) - me._proximityWeight(bv, b, sPos, currentConnection);
});
return topics;
},
_proximityWeight(isAligned, target, sPos, currentConnection) {
const tPos = target.getPosition();
return (isAligned ? 0 : 200) + Math.abs(tPos.x - sPos.x) + Math.abs(tPos.y - sPos.y) + (currentConnection == target ? 0 : 100);
},
_isVerticallyAligned(targetSize, targetPosition, sourcePosition) {
return Math.abs(sourcePosition.y - targetPosition.y) < targetSize.height / 2;
},
});
DragConnector.MAX_VERTICAL_CONNECTION_TOLERANCE = 80;
export default DragConnector
export default DragConnector;

297
packages/mindplot/lib/components/DragManager.js
View File

@ -1,151 +1,146 @@
/*
* 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 DragTopic = require('./DragTopic').default;
const DragManager = new Class({
initialize:function(workspace, eventDispatcher) {
this._workspace = workspace;
this._designerModel = workspace;
this._listeners = {};
this._isDragInProcess = false;
this._eventDispatcher = eventDispatcher;
DragTopic.init(this._workspace);
},
add : function(node) {
// Add behaviour ...
var workspace = this._workspace;
var screen = workspace.getScreenManager();
var dragManager = this;
var me = this;
var mouseDownListener = function(event) {
if (workspace.isWorkspaceEventsEnabled()) {
// Disable double drag...
workspace.enableWorkspaceEvents(false);
// Set initial position.
var layoutManager = me._eventDispatcher.getLayoutManager();
var dragNode = node.createDragNode(layoutManager);
// Register mouse move listener ...
var mouseMoveListener = dragManager._buildMouseMoveListener(workspace, dragNode, dragManager);
screen.addEvent('mousemove', mouseMoveListener);
// Register mouse up listeners ...
var mouseUpListener = dragManager._buildMouseUpListener(workspace, node, dragNode, dragManager);
screen.addEvent('mouseup', mouseUpListener);
// Change cursor.
window.document.body.style.cursor = 'move';
}
};
node.addEvent('mousedown', mouseDownListener);
},
remove : function(node) {
var nodes = this._topics;
var contained = false;
var index = -1;
for (var i = 0; i < nodes.length; i++) {
if (nodes[i] == node) {
contained = true;
index = i;
}
}
},
_buildMouseMoveListener : function(workspace, dragNode, dragManager) {
var screen = workspace.getScreenManager();
var me = this;
var result = function(event) {
if (!me._isDragInProcess) {
// Execute Listeners ..
var startDragListener = dragManager._listeners['startdragging'];
startDragListener(event, dragNode);
// Add shadow node to the workspace.
workspace.append(dragNode);
me._isDragInProcess = true;
}
var pos = screen.getWorkspaceMousePosition(event);
dragNode.setPosition(pos.x, pos.y);
// Call mouse move listeners ...
var dragListener = dragManager._listeners['dragging'];
if ($defined(dragListener)) {
dragListener(event, dragNode);
}
event.preventDefault();
};
dragManager._mouseMoveListener = result;
return result;
},
_buildMouseUpListener : function(workspace, node, dragNode, dragManager) {
var screen = workspace.getScreenManager();
var me = this;
var result = function(event) {
$assert(dragNode.isDragTopic, 'dragNode must be an DragTopic');
// Remove all the events.
screen.removeEvent('mousemove', dragManager._mouseMoveListener);
screen.removeEvent('mouseup', dragManager._mouseUpListener);
// Help GC
dragManager._mouseMoveListener = null;
dragManager._mouseUpListener = null;
workspace.enableWorkspaceEvents(true);
// Change the cursor to the default.
window.document.body.style.cursor = 'default';
if (me._isDragInProcess) {
// Execute Listeners only if the node has been moved.
var endDragListener = dragManager._listeners['enddragging'];
endDragListener(event, dragNode);
// Remove drag node from the workspace.
dragNode.removeFromWorkspace(workspace);
me._isDragInProcess = false;
}
};
dragManager._mouseUpListener = result;
return result;
},
/**
* type:
* - startdragging.
* - dragging
* - enddragging
*/
addEvent : function(type, listener) {
this._listeners[type] = listener;
}
});
export default DragManager;
/*
* 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 DragTopic = require('./DragTopic').default;
const DragManager = new Class({
initialize(workspace, eventDispatcher) {
this._workspace = workspace;
this._designerModel = workspace;
this._listeners = {};
this._isDragInProcess = false;
this._eventDispatcher = eventDispatcher;
DragTopic.init(this._workspace);
},
add(node) {
// Add behaviour ...
const workspace = this._workspace;
const screen = workspace.getScreenManager();
const dragManager = this;
const me = this;
const mouseDownListener = function (event) {
if (workspace.isWorkspaceEventsEnabled()) {
// Disable double drag...
workspace.enableWorkspaceEvents(false);
// Set initial position.
const layoutManager = me._eventDispatcher.getLayoutManager();
const dragNode = node.createDragNode(layoutManager);
// Register mouse move listener ...
const mouseMoveListener = dragManager._buildMouseMoveListener(workspace, dragNode, dragManager);
screen.addEvent('mousemove', mouseMoveListener);
// Register mouse up listeners ...
const mouseUpListener = dragManager._buildMouseUpListener(workspace, node, dragNode, dragManager);
screen.addEvent('mouseup', mouseUpListener);
// Change cursor.
window.document.body.style.cursor = 'move';
}
};
node.addEvent('mousedown', mouseDownListener);
},
remove(node) {
const nodes = this._topics;
let contained = false;
let index = -1;
for (let i = 0; i < nodes.length; i++) {
if (nodes[i] == node) {
contained = true;
index = i;
}
}
},
_buildMouseMoveListener(workspace, dragNode, dragManager) {
const screen = workspace.getScreenManager();
const me = this;
const result = function (event) {
if (!me._isDragInProcess) {
// Execute Listeners ..
const startDragListener = dragManager._listeners.startdragging;
startDragListener(event, dragNode);
// Add shadow node to the workspace.
workspace.append(dragNode);
me._isDragInProcess = true;
}
const pos = screen.getWorkspaceMousePosition(event);
dragNode.setPosition(pos.x, pos.y);
// Call mouse move listeners ...
const dragListener = dragManager._listeners.dragging;
if ($defined(dragListener)) {
dragListener(event, dragNode);
}
event.preventDefault();
};
dragManager._mouseMoveListener = result;
return result;
},
_buildMouseUpListener(workspace, node, dragNode, dragManager) {
const screen = workspace.getScreenManager();
const me = this;
const result = function (event) {
$assert(dragNode.isDragTopic, 'dragNode must be an DragTopic');
// Remove all the events.
screen.removeEvent('mousemove', dragManager._mouseMoveListener);
screen.removeEvent('mouseup', dragManager._mouseUpListener);
// Help GC
dragManager._mouseMoveListener = null;
dragManager._mouseUpListener = null;
workspace.enableWorkspaceEvents(true);
// Change the cursor to the default.
window.document.body.style.cursor = 'default';
if (me._isDragInProcess) {
// Execute Listeners only if the node has been moved.
const endDragListener = dragManager._listeners.enddragging;
endDragListener(event, dragNode);
// Remove drag node from the workspace.
dragNode.removeFromWorkspace(workspace);
me._isDragInProcess = false;
}
};
dragManager._mouseUpListener = result;
return result;
},
/**
* type:
* - startdragging.
* - dragging
* - enddragging
*/
addEvent(type, listener) {
this._listeners[type] = listener;
},
});
export default DragManager;

478
packages/mindplot/lib/components/DragPivot.js
View File

@ -1,238 +1,240 @@
/*
* 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 Core = require('@wismapping/core-js')
const core = Core();
const web2D = require('@wismapping/web2d')
const web2d = web2D();
const DragTopic = require('./DragTopic').default;
const Shape = require('./util/Shape').default;
const INodeModel = require('./model/INodeModel').default;
const DragPivot = new Class({
initialize:function() {
this._position = new core.Point();
this._size = DragTopic.PIVOT_SIZE;
this._straightLine = this._buildStraightLine();
this._curvedLine = this._buildCurvedLine();
this._dragPivot = this._buildRect();
this._connectRect = this._buildRect();
this._targetTopic = null;
this._isVisible = false;
},
isVisible:function() {
return this._isVisible;
},
getTargetTopic : function() {
return this._targetTopic;
},
_buildStraightLine : function() {
var line = new web2d.CurvedLine();
line.setStyle(web2d.CurvedLine.SIMPLE_LINE);
line.setStroke(1, 'solid', '#CC0033');
line.setOpacity(0.4);
line.setVisibility(false);
return line;
},
_buildCurvedLine : function() {
var line = new web2d.CurvedLine();
line.setStyle(web2d.CurvedLine.SIMPLE_LINE);
line.setStroke(1, 'solid', '#CC0033');
line.setOpacity(0.4);
line.setVisibility(false);
return line;
},
_redrawLine : function() {
// Update line position.
$assert(this.getTargetTopic(), 'Illegal invocation. Target node can not be null');
var pivotRect = this._getPivotRect();
// Pivot position has not changed. In this case, position change is not required.
var targetTopic = this.getTargetTopic();
var position = this._position;
// Calculate pivot connection point ...
var size = this._size;
var targetPosition = targetTopic.getPosition();
var line = this._getConnectionLine();
// Update Line position.
var isAtRight = Shape.isAtRight(targetPosition, position);
var pivotPoint = Shape.calculateRectConnectionPoint(position, size, isAtRight);
line.setFrom(pivotPoint.x, pivotPoint.y);
// Update rect position
var cx = position.x - (parseInt(size.width) / 2);
var cy = position.y - (parseInt(size.height) / 2);
pivotRect.setPosition(cx, cy);
// Make line visible only when the position has been already changed.
// This solve several strange effects ;)
var targetPoint = targetTopic.workoutIncomingConnectionPoint(pivotPoint);
line.setTo(targetPoint.x, targetPoint.y);
},
setPosition : function(point) {
this._position = point;
this._redrawLine();
},
getPosition : function() {
return this._position;
},
_buildRect : function() {
var size = this._size;
var rectAttributes = {fillColor:'#CC0033',opacity:0.4,width:size.width,height:size.height,strokeColor:'#FF9933'};
var rect = new web2d.Rect(0, rectAttributes);
rect.setVisibility(false);
return rect;
},
_getPivotRect : function() {
return this._dragPivot;
},
getSize : function() {
var elem2d = this._getPivotRect();
return elem2d.getSize();
},
setVisibility : function(value) {
if (this.isVisible() != value) {
var pivotRect = this._getPivotRect();
pivotRect.setVisibility(value);
var connectRect = this._connectRect;
connectRect.setVisibility(value);
var line = this._getConnectionLine();
if (line) {
line.setVisibility(value);
}
this._isVisible = value;
}
},
// If the node is connected, validate that there is a line connecting both...
_getConnectionLine : function() {
var result = null;
var parentTopic = this._targetTopic;
if (parentTopic) {
if (parentTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
result = this._straightLine;
} else {
result = this._curvedLine;
}
}
return result;
},
addToWorkspace : function(workspace) {
var pivotRect = this._getPivotRect();
workspace.append(pivotRect);
var connectToRect = this._connectRect;
workspace.append(connectToRect);
// Add a hidden straight line ...
var straighLine = this._straightLine;
straighLine.setVisibility(false);
workspace.append(straighLine);
straighLine.moveToBack();
// Add a hidden curved line ...
var curvedLine = this._curvedLine;
curvedLine.setVisibility(false);
workspace.append(curvedLine);
curvedLine.moveToBack();
// Add a connect rect ...
var connectRect = this._connectRect;
connectRect.setVisibility(false);
workspace.append(connectRect);
connectRect.moveToBack();
},
removeFromWorkspace : function(workspace) {
var shape = this._getPivotRect();
workspace.removeChild(shape);
var connectToRect = this._connectRect;
workspace.removeChild(connectToRect);
if ($defined(this._straightLine)) {
workspace.removeChild(this._straightLine);
}
if ($defined(this._curvedLine)) {
workspace.removeChild(this._curvedLine);
}
},
connectTo : function(targetTopic, position) {
$assert(!this._outgoingLine, 'Could not connect an already connected node');
$assert(targetTopic != this, 'Circular connection are not allowed');
$assert(position, 'position can not be null');
$assert(targetTopic, 'parent can not be null');
this._position = position;
this._targetTopic = targetTopic;
// Connected to Rect ...
var connectRect = this._connectRect;
var targetSize = targetTopic.getSize();
// Add 4 pixel in order to keep create a rect bigger than the topic.
var width = targetSize.width + 4;
var height = targetSize.height + 4;
connectRect.setSize(width, height);
var targetPosition = targetTopic.getPosition();
var cx = Math.ceil(targetPosition.x - (width / 2));
var cy = Math.ceil(targetPosition.y - (height / 2));
connectRect.setPosition(cx, cy);
// Change elements position ...
var pivotRect = this._getPivotRect();
pivotRect.moveToFront();
pivotRect.setPosition(position.x, position.y);
this._redrawLine();
},
disconnect : function(workspace) {
$assert(workspace, 'workspace can not be null.');
$assert(this._targetTopic, 'There are not connected topic.');
this.setVisibility(false);
this._targetTopic = null;
}
});
export default DragPivot;
/*
* 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 Core = require('@wismapping/core-js');
const core = Core();
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const DragTopic = require('./DragTopic').default;
const Shape = require('./util/Shape').default;
const INodeModel = require('./model/INodeModel').default;
const DragPivot = new Class({
initialize() {
this._position = new core.Point();
this._size = DragTopic.PIVOT_SIZE;
this._straightLine = this._buildStraightLine();
this._curvedLine = this._buildCurvedLine();
this._dragPivot = this._buildRect();
this._connectRect = this._buildRect();
this._targetTopic = null;
this._isVisible = false;
},
isVisible() {
return this._isVisible;
},
getTargetTopic() {
return this._targetTopic;
},
_buildStraightLine() {
const line = new web2d.CurvedLine();
line.setStyle(web2d.CurvedLine.SIMPLE_LINE);
line.setStroke(1, 'solid', '#CC0033');
line.setOpacity(0.4);
line.setVisibility(false);
return line;
},
_buildCurvedLine() {
const line = new web2d.CurvedLine();
line.setStyle(web2d.CurvedLine.SIMPLE_LINE);
line.setStroke(1, 'solid', '#CC0033');
line.setOpacity(0.4);
line.setVisibility(false);
return line;
},
_redrawLine() {
// Update line position.
$assert(this.getTargetTopic(), 'Illegal invocation. Target node can not be null');
const pivotRect = this._getPivotRect();
// Pivot position has not changed. In this case, position change is not required.
const targetTopic = this.getTargetTopic();
const position = this._position;
// Calculate pivot connection point ...
const size = this._size;
const targetPosition = targetTopic.getPosition();
const line = this._getConnectionLine();
// Update Line position.
const isAtRight = Shape.isAtRight(targetPosition, position);
const pivotPoint = Shape.calculateRectConnectionPoint(position, size, isAtRight);
line.setFrom(pivotPoint.x, pivotPoint.y);
// Update rect position
const cx = position.x - (parseInt(size.width) / 2);
const cy = position.y - (parseInt(size.height) / 2);
pivotRect.setPosition(cx, cy);
// Make line visible only when the position has been already changed.
// This solve several strange effects ;)
const targetPoint = targetTopic.workoutIncomingConnectionPoint(pivotPoint);
line.setTo(targetPoint.x, targetPoint.y);
},
setPosition(point) {
this._position = point;
this._redrawLine();
},
getPosition() {
return this._position;
},
_buildRect() {
const size = this._size;
const rectAttributes = {
fillColor: '#CC0033', opacity: 0.4, width: size.width, height: size.height, strokeColor: '#FF9933',
};
const rect = new web2d.Rect(0, rectAttributes);
rect.setVisibility(false);
return rect;
},
_getPivotRect() {
return this._dragPivot;
},
getSize() {
const elem2d = this._getPivotRect();
return elem2d.getSize();
},
setVisibility(value) {
if (this.isVisible() != value) {
const pivotRect = this._getPivotRect();
pivotRect.setVisibility(value);
const connectRect = this._connectRect;
connectRect.setVisibility(value);
const line = this._getConnectionLine();
if (line) {
line.setVisibility(value);
}
this._isVisible = value;
}
},
// If the node is connected, validate that there is a line connecting both...
_getConnectionLine() {
let result = null;
const parentTopic = this._targetTopic;
if (parentTopic) {
if (parentTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
result = this._straightLine;
} else {
result = this._curvedLine;
}
}
return result;
},
addToWorkspace(workspace) {
const pivotRect = this._getPivotRect();
workspace.append(pivotRect);
const connectToRect = this._connectRect;
workspace.append(connectToRect);
// Add a hidden straight line ...
const straighLine = this._straightLine;
straighLine.setVisibility(false);
workspace.append(straighLine);
straighLine.moveToBack();
// Add a hidden curved line ...
const curvedLine = this._curvedLine;
curvedLine.setVisibility(false);
workspace.append(curvedLine);
curvedLine.moveToBack();
// Add a connect rect ...
const connectRect = this._connectRect;
connectRect.setVisibility(false);
workspace.append(connectRect);
connectRect.moveToBack();
},
removeFromWorkspace(workspace) {
const shape = this._getPivotRect();
workspace.removeChild(shape);
const connectToRect = this._connectRect;
workspace.removeChild(connectToRect);
if ($defined(this._straightLine)) {
workspace.removeChild(this._straightLine);
}
if ($defined(this._curvedLine)) {
workspace.removeChild(this._curvedLine);
}
},
connectTo(targetTopic, position) {
$assert(!this._outgoingLine, 'Could not connect an already connected node');
$assert(targetTopic != this, 'Circular connection are not allowed');
$assert(position, 'position can not be null');
$assert(targetTopic, 'parent can not be null');
this._position = position;
this._targetTopic = targetTopic;
// Connected to Rect ...
const connectRect = this._connectRect;
const targetSize = targetTopic.getSize();
// Add 4 pixel in order to keep create a rect bigger than the topic.
const width = targetSize.width + 4;
const height = targetSize.height + 4;
connectRect.setSize(width, height);
const targetPosition = targetTopic.getPosition();
const cx = Math.ceil(targetPosition.x - (width / 2));
const cy = Math.ceil(targetPosition.y - (height / 2));
connectRect.setPosition(cx, cy);
// Change elements position ...
const pivotRect = this._getPivotRect();
pivotRect.moveToFront();
pivotRect.setPosition(position.x, position.y);
this._redrawLine();
},
disconnect(workspace) {
$assert(workspace, 'workspace can not be null.');
$assert(this._targetTopic, 'There are not connected topic.');
this.setVisibility(false);
this._targetTopic = null;
},
});
export default DragPivot;

367
packages/mindplot/lib/components/DragTopic.js
View File

@ -15,207 +15,206 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const Core = require('@wismapping/core-js')
const Core = require('@wismapping/core-js');
const core = Core();
const ActionDispatcher = require('./ActionDispatcher').default
const ActionDispatcher = require('./ActionDispatcher').default;
const DragPivot = require('./DragPivot').default;
const DragTopic = new Class({
initialize:function (dragShape, draggedNode, layoutManger) {
$assert(dragShape, 'Rect can not be null.');
$assert(draggedNode, 'draggedNode can not be null.');
$assert(layoutManger, 'layoutManger can not be null.');
initialize(dragShape, draggedNode, layoutManger) {
$assert(dragShape, 'Rect can not be null.');
$assert(draggedNode, 'draggedNode can not be null.');
$assert(layoutManger, 'layoutManger can not be null.');
this._elem2d = dragShape;
this._order = null;
this._draggedNode = draggedNode;
this._layoutManager = layoutManger;
this._position = new core.Point();
this._isInWorkspace = false;
this._isFreeLayoutEnabled = false;
},
this._elem2d = dragShape;
this._order = null;
this._draggedNode = draggedNode;
this._layoutManager = layoutManger;
this._position = new core.Point();
this._isInWorkspace = false;
this._isFreeLayoutEnabled = false;
},
setOrder:function (order) {
this._order = order;
},
setOrder(order) {
this._order = order;
},
setPosition:function (x, y) {
// Update drag shadow position ....
var position = {x:x, y:y};
if (this.isFreeLayoutOn() && this.isConnected()) {
var _layoutManager = this._layoutManager;
var par = this.getConnectedToTopic();
position = _layoutManager.predict(par.getId(), this._draggedNode.getId(), position, true).position;
}
this._position.setValue(position.x, position.y);
// Elements are positioned in the center.
// All topic element must be positioned based on the innerShape.
var draggedNode = this._draggedNode;
var size = draggedNode.getSize();
var cx = position.x - (position.x > 0 ? 0 : size.width);
var cy = Math.ceil(position.y - (size.height / 2));
this._elem2d.setPosition(cx, cy);
// In case is not free, pivot must be draw ...
if (this.isConnected() && !this.isFreeLayoutOn()) {
var parent = this.getConnectedToTopic();
var predict = this._layoutManager.predict(parent.getId(), this._draggedNode.getId(), this.getPosition());
if (this._order != predict.order) {
var dragPivot = this._getDragPivot();
var pivotPosition = predict.position;
dragPivot.connectTo(parent, pivotPosition);
this.setOrder(predict.order);
}
}
},
updateFreeLayout:function (event) {
var isFreeEnabled = (event.metaKey && Browser.Platform.mac) || (event.ctrlKey && !Browser.Platform.mac);
if (this.isFreeLayoutOn() != isFreeEnabled) {
var dragPivot = this._getDragPivot();
dragPivot.setVisibility(!isFreeEnabled);
this._isFreeLayoutEnabled = isFreeEnabled;
}
},
setVisibility:function (value) {
var dragPivot = this._getDragPivot();
dragPivot.setVisibility(value);
},
isVisible:function () {
var dragPivot = this._getDragPivot();
return dragPivot.isVisible();
},
getInnerShape:function () {
return this._elem2d;
},
disconnect:function (workspace) {
// Clear connection line ...
var dragPivot = this._getDragPivot();
dragPivot.disconnect(workspace);
},
connectTo:function (parent) {
$assert(parent, 'Parent connection node can not be null.');
// Where it should be connected ?
var predict = designer._eventBussDispatcher._layoutManager.predict(parent.getId(), this._draggedNode.getId(), this.getPosition());
// Connect pivot ...
var dragPivot = this._getDragPivot();
var position = predict.position;
dragPivot.connectTo(parent, position);
dragPivot.setVisibility(true);
this.setOrder(predict.order);
},
getDraggedTopic:function () {
return this._draggedNode;
},
removeFromWorkspace:function (workspace) {
if (this._isInWorkspace) {
// Remove drag shadow.
workspace.removeChild(this._elem2d);
// Remove pivot shape. To improve performance it will not be removed. Only the visibility will be changed.
var dragPivot = this._getDragPivot();
dragPivot.setVisibility(false);
this._isInWorkspace = false;
}
},
isInWorkspace:function () {
return this._isInWorkspace;
},
addToWorkspace:function (workspace) {
if (!this._isInWorkspace) {
workspace.append(this._elem2d);
var dragPivot = this._getDragPivot();
dragPivot.addToWorkspace(workspace);
this._isInWorkspace = true;
}
},
_getDragPivot:function () {
return DragTopic.__getDragPivot();
},
getPosition:function () {
return this._position;
},
isDragTopic:function () {
return true;
},
applyChanges:function (workspace) {
$assert(workspace, 'workspace can not be null');
var actionDispatcher = ActionDispatcher.getInstance();
var draggedTopic = this.getDraggedTopic();
var topicId = draggedTopic.getId();
var position = this.getPosition();
if (!this.isFreeLayoutOn()) {
var order = null;
var parent = null;
var isDragConnected = this.isConnected();
if (isDragConnected) {
var targetTopic = this.getConnectedToTopic();
order = this._order;
parent = targetTopic;
}
// If the node is not connected, position based on the original drag topic position.
actionDispatcher.dragTopic(topicId, position, order, parent);
} else {
actionDispatcher.moveTopic(topicId, position);
}
},
getConnectedToTopic:function () {
var dragPivot = this._getDragPivot();
return dragPivot.getTargetTopic();
},
isConnected:function () {
return this.getConnectedToTopic() != null;
},
isFreeLayoutOn:function () {
// return this._isFreeLayoutEnabled;
// Disable free layout ...
return false;
setPosition(x, y) {
// Update drag shadow position ....
let position = { x, y };
if (this.isFreeLayoutOn() && this.isConnected()) {
const { _layoutManager } = this;
const par = this.getConnectedToTopic();
position = _layoutManager.predict(par.getId(), this._draggedNode.getId(), position, true).position;
}
this._position.setValue(position.x, position.y);
// Elements are positioned in the center.
// All topic element must be positioned based on the innerShape.
const draggedNode = this._draggedNode;
const size = draggedNode.getSize();
const cx = position.x - (position.x > 0 ? 0 : size.width);
const cy = Math.ceil(position.y - (size.height / 2));
this._elem2d.setPosition(cx, cy);
// In case is not free, pivot must be draw ...
if (this.isConnected() && !this.isFreeLayoutOn()) {
const parent = this.getConnectedToTopic();
const predict = this._layoutManager.predict(parent.getId(), this._draggedNode.getId(), this.getPosition());
if (this._order != predict.order) {
const dragPivot = this._getDragPivot();
const pivotPosition = predict.position;
dragPivot.connectTo(parent, pivotPosition);
this.setOrder(predict.order);
}
}
},
updateFreeLayout(event) {
const isFreeEnabled = (event.metaKey && Browser.Platform.mac) || (event.ctrlKey && !Browser.Platform.mac);
if (this.isFreeLayoutOn() != isFreeEnabled) {
const dragPivot = this._getDragPivot();
dragPivot.setVisibility(!isFreeEnabled);
this._isFreeLayoutEnabled = isFreeEnabled;
}
},
setVisibility(value) {
const dragPivot = this._getDragPivot();
dragPivot.setVisibility(value);
},
isVisible() {
const dragPivot = this._getDragPivot();
return dragPivot.isVisible();
},
getInnerShape() {
return this._elem2d;
},
disconnect(workspace) {
// Clear connection line ...
const dragPivot = this._getDragPivot();
dragPivot.disconnect(workspace);
},
connectTo(parent) {
$assert(parent, 'Parent connection node can not be null.');
// Where it should be connected ?
const predict = designer._eventBussDispatcher._layoutManager.predict(parent.getId(), this._draggedNode.getId(), this.getPosition());
// Connect pivot ...
const dragPivot = this._getDragPivot();
const { position } = predict;
dragPivot.connectTo(parent, position);
dragPivot.setVisibility(true);
this.setOrder(predict.order);
},
getDraggedTopic() {
return this._draggedNode;
},
removeFromWorkspace(workspace) {
if (this._isInWorkspace) {
// Remove drag shadow.
workspace.removeChild(this._elem2d);
// Remove pivot shape. To improve performance it will not be removed. Only the visibility will be changed.
const dragPivot = this._getDragPivot();
dragPivot.setVisibility(false);
this._isInWorkspace = false;
}
},
isInWorkspace() {
return this._isInWorkspace;
},
addToWorkspace(workspace) {
if (!this._isInWorkspace) {
workspace.append(this._elem2d);
const dragPivot = this._getDragPivot();
dragPivot.addToWorkspace(workspace);
this._isInWorkspace = true;
}
},
_getDragPivot() {
return DragTopic.__getDragPivot();
},
getPosition() {
return this._position;
},
isDragTopic() {
return true;
},
applyChanges(workspace) {
$assert(workspace, 'workspace can not be null');
const actionDispatcher = ActionDispatcher.getInstance();
const draggedTopic = this.getDraggedTopic();
const topicId = draggedTopic.getId();
const position = this.getPosition();
if (!this.isFreeLayoutOn()) {
let order = null;
let parent = null;
const isDragConnected = this.isConnected();
if (isDragConnected) {
const targetTopic = this.getConnectedToTopic();
order = this._order;
parent = targetTopic;
}
// If the node is not connected, position based on the original drag topic position.
actionDispatcher.dragTopic(topicId, position, order, parent);
} else {
actionDispatcher.moveTopic(topicId, position);
}
},
getConnectedToTopic() {
const dragPivot = this._getDragPivot();
return dragPivot.getTargetTopic();
},
isConnected() {
return this.getConnectedToTopic() != null;
},
isFreeLayoutOn() {
// return this._isFreeLayoutEnabled;
// Disable free layout ...
return false;
},
});
DragTopic.PIVOT_SIZE = {width:50, height:6};
DragTopic.PIVOT_SIZE = { width: 50, height: 6 };
DragTopic.init = function (workspace) {
$assert(workspace, "workspace can not be null");
var pivot = DragTopic.__getDragPivot();
workspace.append(pivot);
$assert(workspace, 'workspace can not be null');
const pivot = DragTopic.__getDragPivot();
workspace.append(pivot);
};
DragTopic.__getDragPivot = function () {
var result = DragTopic._dragPivot;
if (!$defined(result)) {
result = new DragPivot();
DragTopic._dragPivot = result;
}
return result;
let result = DragTopic._dragPivot;
if (!$defined(result)) {
result = new DragPivot();
DragTopic._dragPivot = result;
}
return result;
};
export default DragTopic;

9
packages/mindplot/lib/components/EditorOptions.js
View File

@ -16,11 +16,10 @@
* limitations under the License.
*/
const EditorOptions =
{
LayoutManager:"OriginalLayout",
// LayoutManager:"FreeMindLayout",
textEditor:"TextEditor"
const EditorOptions = {
LayoutManager: 'OriginalLayout',
// LayoutManager:"FreeMindLayout",
textEditor: 'TextEditor',
// textEditor:"RichTextEditor"
};

76
packages/mindplot/lib/components/EditorProperties.js
View File

@ -1,38 +1,38 @@
/*
* 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 EditorProperties = new Class({
initialize: function () {
this._zoom = 0;
this._position = 0;
},
setZoom: function (zoom) {
this._zoom = zoom;
},
getZoom: function () {
return this._zoom;
},
asProperties: function () {
return "zoom=" + this._zoom + "\n";
}
});
export default EditorProperties;
/*
* 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 EditorProperties = new Class({
initialize() {
this._zoom = 0;
this._position = 0;
},
setZoom(zoom) {
this._zoom = zoom;
},
getZoom() {
return this._zoom;
},
asProperties() {
return `zoom=${this._zoom}\n`;
},
});
export default EditorProperties;

70
packages/mindplot/lib/components/Events.js
View File

@ -1,45 +1,43 @@
const Events = new Class({
$events: {},
$events: {},
_removeOn: function (string) {
return string.replace(/^on([A-Z])/, function (full, first) {
return first.toLowerCase();
});
},
_removeOn(string) {
return string.replace(/^on([A-Z])/, (full, first) => first.toLowerCase());
},
addEvent: function (type, fn, internal) {
type = this._removeOn(type);
addEvent(type, fn, internal) {
type = this._removeOn(type);
this.$events[type] = (this.$events[type] || []).include(fn);
if (internal) fn.internal = true;
return this;
},
this.$events[type] = (this.$events[type] || []).include(fn);
if (internal) fn.internal = true;
return this;
},
fireEvent: function (type, args, delay) {
type = this._removeOn(type);
var events = this.$events[type];
if (!events) return this;
args = Array.isArray(args) ? args : [args];
_.each(
events,
function (fn) {
if (delay) fn.delay(delay, this, args);
else fn.apply(this, args);
},
this
);
return this;
},
fireEvent(type, args, delay) {
type = this._removeOn(type);
const events = this.$events[type];
if (!events) return this;
args = Array.isArray(args) ? args : [args];
_.each(
events,
function (fn) {
if (delay) fn.delay(delay, this, args);
else fn.apply(this, args);
},
this,
);
return this;
},
removeEvent: function (type, fn) {
type = this._removeOn(type);
var events = this.$events[type];
if (events && !fn.internal) {
var index = events.indexOf(fn);
if (index != -1) events.splice(index, 1);
}
return this;
},
removeEvent(type, fn) {
type = this._removeOn(type);
const events = this.$events[type];
if (events && !fn.internal) {
const index = events.indexOf(fn);
if (index != -1) events.splice(index, 1);
}
return this;
},
});
export default Events;

59
packages/mindplot/lib/components/Icon.js
View File

@ -15,44 +15,45 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const web2D = require('@wismapping/web2d')
const web2d = web2D()
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const Icon = new Class({
initialize: function (url) {
$assert(url, 'topic can not be null');
this._image = new web2d.Image();
this._image.setHref(url);
this._image.setSize(Icon.SIZE, Icon.SIZE);
},
initialize(url) {
$assert(url, 'topic can not be null');
this._image = new web2d.Image();
this._image.setHref(url);
this._image.setSize(Icon.SIZE, Icon.SIZE);
},
getImage: function () {
return this._image;
},
getImage() {
return this._image;
},
setGroup: function (group) {
this._group = group;
},
setGroup(group) {
this._group = group;
},
getGroup: function () {
return this._group;
},
getGroup() {
return this._group;
},
getSize: function () {
return this._image.getSize();
},
getSize() {
return this._image.getSize();
},
getPosition: function () {
return this._image.getPosition();
},
getPosition() {
return this._image.getPosition();
},
addEvent: function (type, fnc) {
this._image.addEvent(type, fnc);
},
addEvent(type, fnc) {
this._image.addEvent(type, fnc);
},
remove: function () {
throw "Unsupported operation";
}
remove() {
throw 'Unsupported operation';
},
});
Icon.SIZE = 90;

494
packages/mindplot/lib/components/IconGroup.js
View File

@ -15,157 +15,154 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const web2D = require('@wismapping/web2d')
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const Icon = require('./Icon');
const IconGroup = new Class(/**@lends IconGroup */{
/**
const IconGroup = new Class(/** @lends IconGroup */{
/**
* @constructs
* @param topicId
* @param iconSize
* @throws will throw an error if topicId is null or undefined
* @throws will throw an error if iconSize is null or undefined
*/
initialize: function (topicId, iconSize) {
$assert($defined(topicId), "topicId can not be null");
$assert($defined(iconSize), "iconSize can not be null");
initialize(topicId, iconSize) {
$assert($defined(topicId), 'topicId can not be null');
$assert($defined(iconSize), 'iconSize can not be null');
this._icons = [];
this._group = new web2d.Group({
width: 0,
height: iconSize,
x: 0,
y: 0,
coordSizeWidth: 0,
coordSizeHeight: 100
});
this._removeTip = new IconGroup.RemoveTip(this._group, topicId);
this.seIconSize(iconSize, iconSize);
this._icons = [];
this._group = new web2d.Group({
width: 0,
height: iconSize,
x: 0,
y: 0,
coordSizeWidth: 0,
coordSizeHeight: 100,
});
this._removeTip = new IconGroup.RemoveTip(this._group, topicId);
this.seIconSize(iconSize, iconSize);
this._registerListeners();
this._registerListeners();
},
},
/** */
setPosition(x, y) {
this._group.setPosition(x, y);
},
/** */
setPosition: function (x, y) {
this._group.setPosition(x, y);
},
/** */
getPosition() {
return this._group.getPosition();
},
/** */
getPosition: function () {
return this._group.getPosition();
},
/** */
getNativeElement() {
return this._group;
},
/** */
getNativeElement: function () {
return this._group;
},
/** */
getSize() {
return this._group.getSize();
},
/** */
getSize: function () {
return this._group.getSize();
},
/** */
seIconSize(width, height) {
this._iconSize = { width, height };
this._resize(this._icons.length);
},
/** */
seIconSize: function (width, height) {
this._iconSize = {width: width, height: height};
this._resize(this._icons.length);
},
/**
/**
* @param icon the icon to be added to the icon group
* @param {Boolean} remove
* @throws will throw an error if icon is not defined
*/
addIcon: function (icon, remove) {
$defined(icon, "icon is not defined");
addIcon(icon, remove) {
$defined(icon, 'icon is not defined');
icon.setGroup(this);
this._icons.push(icon);
icon.setGroup(this);
this._icons.push(icon);
// Adjust group and position ...
this._resize(this._icons.length);
this._positionIcon(icon, this._icons.length - 1);
// Adjust group and position ...
this._resize(this._icons.length);
this._positionIcon(icon, this._icons.length - 1);
var imageShape = icon.getImage();
this._group.append(imageShape);
const imageShape = icon.getImage();
this._group.append(imageShape);
// Register event for the group ..
if (remove) {
this._removeTip.decorate(this._topicId, icon);
}
},
_findIconFromModel: function (iconModel) {
var result = null;
_.each(this._icons, function (icon) {
var elModel = icon.getModel();
if (elModel.getId() == iconModel.getId()) {
result = icon;
}
}, this);
if (result == null) {
throw new Error("Icon can no be found:" + iconModel.getId() + ", Icons:" + this._icons);
}
return result;
},
/** */
removeIconByModel: function (featureModel) {
$assert(featureModel, "featureModel can not be null");
var icon = this._findIconFromModel(featureModel);
this._removeIcon(icon);
},
_removeIcon: function (icon) {
$assert(icon, "icon can not be null");
this._removeTip.close(0);
this._group.removeChild(icon.getImage());
this._icons.erase(icon);
this._resize(this._icons.length);
var me = this;
// Add all again ...
_.each(this._icons, function (elem, i) {
me._positionIcon(elem, i);
});
},
/** */
moveToFront: function () {
this._group.moveToFront();
},
_registerListeners: function () {
this._group.addEvent('click', function (event) {
// Avoid node creation ...
event.stopPropagation();
});
this._group.addEvent('dblclick', function (event) {
event.stopPropagation();
});
},
_resize: function (iconsLength) {
this._group.setSize(iconsLength * this._iconSize.width, this._iconSize.height);
var iconSize = Icon.SIZE + (IconGroup.ICON_PADDING * 2);
this._group.setCoordSize(iconsLength * iconSize, iconSize);
},
_positionIcon: function (icon, order) {
var iconSize = Icon.SIZE + (IconGroup.ICON_PADDING * 2);
icon.getImage().setPosition(iconSize * order + IconGroup.ICON_PADDING, IconGroup.ICON_PADDING);
// Register event for the group ..
if (remove) {
this._removeTip.decorate(this._topicId, icon);
}
},
_findIconFromModel(iconModel) {
let result = null;
_.each(this._icons, (icon) => {
const elModel = icon.getModel();
if (elModel.getId() == iconModel.getId()) {
result = icon;
}
}, this);
if (result == null) {
throw new Error(`Icon can no be found:${iconModel.getId()}, Icons:${this._icons}`);
}
return result;
},
/** */
removeIconByModel(featureModel) {
$assert(featureModel, 'featureModel can not be null');
const icon = this._findIconFromModel(featureModel);
this._removeIcon(icon);
},
_removeIcon(icon) {
$assert(icon, 'icon can not be null');
this._removeTip.close(0);
this._group.removeChild(icon.getImage());
this._icons.erase(icon);
this._resize(this._icons.length);
const me = this;
// Add all again ...
_.each(this._icons, (elem, i) => {
me._positionIcon(elem, i);
});
},
/** */
moveToFront() {
this._group.moveToFront();
},
_registerListeners() {
this._group.addEvent('click', (event) => {
// Avoid node creation ...
event.stopPropagation();
});
this._group.addEvent('dblclick', (event) => {
event.stopPropagation();
});
},
_resize(iconsLength) {
this._group.setSize(iconsLength * this._iconSize.width, this._iconSize.height);
const iconSize = Icon.SIZE + (IconGroup.ICON_PADDING * 2);
this._group.setCoordSize(iconsLength * iconSize, iconSize);
},
_positionIcon(icon, order) {
const iconSize = Icon.SIZE + (IconGroup.ICON_PADDING * 2);
icon.getImage().setPosition(iconSize * order + IconGroup.ICON_PADDING, IconGroup.ICON_PADDING);
},
});
/**
@ -176,169 +173,164 @@ const IconGroup = new Class(/**@lends IconGroup */{
IconGroup.ICON_PADDING = 5;
IconGroup.RemoveTip = new Class(/** @lends IconGroup.RemoveTip */{
/**
/**
* @classdesc inner class of IconGroup
* @constructs
* @param container
*/
initialize: function (container) {
$assert(container, "group can not be null");
this._fadeElem = container;
},
initialize(container) {
$assert(container, 'group can not be null');
this._fadeElem = container;
},
/**
/**
* @param topicId
* @param icon
* @throws will throw an error if icon is null or undefined
*/
show: function (topicId, icon) {
$assert(icon, 'icon can not be null');
show(topicId, icon) {
$assert(icon, 'icon can not be null');
// Nothing to do ...
if (this._activeIcon != icon) {
// If there is an active icon, close it first ...
if (this._activeIcon) {
this.close(0);
}
// Nothing to do ...
if (this._activeIcon != icon) {
// If there is an active icon, close it first ...
if (this._activeIcon) {
this.close(0);
}
// Now, let move the position the icon...
var pos = icon.getPosition();
// Now, let move the position the icon...
const pos = icon.getPosition();
// Register events ...
var widget = this._buildWeb2d();
widget.addEvent('click', function () {
icon.remove();
});
// Register events ...
const widget = this._buildWeb2d();
widget.addEvent('click', () => {
icon.remove();
});
var me = this;
const me = this;
widget.addEvent('mouseover', function () {
me.show(topicId, icon);
});
widget.addEvent('mouseover', () => {
me.show(topicId, icon);
});
widget.addEvent('mouseout', function () {
me.hide();
});
widget.addEvent('mouseout', () => {
me.hide();
});
widget.setPosition(pos.x + 80, pos.y - 50);
this._fadeElem.append(widget);
widget.setPosition(pos.x + 80, pos.y - 50);
this._fadeElem.append(widget);
// Setup current element ...
this._activeIcon = icon;
this._widget = widget;
// Setup current element ...
this._activeIcon = icon;
this._widget = widget;
} else {
clearTimeout(this._closeTimeoutId);
}
},
} else {
clearTimeout(this._closeTimeoutId);
}
},
/** */
hide() {
this.close(200);
},
/** */
hide: function () {
this.close(200);
},
/**
/**
* @param delay
*/
close: function (delay) {
close(delay) {
// This is not ok, trying to close the same dialog twice ?
if (this._closeTimeoutId) {
clearTimeout(this._closeTimeoutId);
}
// This is not ok, trying to close the same dialog twice ?
if (this._closeTimeoutId) {
clearTimeout(this._closeTimeoutId)
}
const me = this;
if (this._activeIcon) {
const widget = this._widget;
const close = function () {
me._activeIcon = null;
me._fadeElem.removeChild(widget);
me._widget = null;
me._closeTimeoutId = null;
};
var me = this;
if (this._activeIcon) {
var widget = this._widget;
var close = function () {
me._activeIcon = null;
me._fadeElem.removeChild(widget);
me._widget = null;
me._closeTimeoutId = null;
};
if (!$defined(delay) || delay == 0) {
close();
} else {
this._closeTimeoutId = close.delay(delay);
}
}
},
if (!$defined(delay) || delay == 0) {
close();
}
else {
this._closeTimeoutId = close.delay(delay);
}
}
},
_buildWeb2d() {
const result = new web2d.Group({
width: 10,
height: 10,
x: 0,
y: 0,
coordSizeWidth: 10,
coordSizeHeight: 10,
});
_buildWeb2d: function () {
var result = new web2d.Group({
width: 10,
height: 10,
x: 0,
y: 0,
coordSizeWidth: 10,
coordSizeHeight: 10
});
const outerRect = new web2d.Rect(0, {
x: 0,
y: 0,
width: 10,
height: 10,
stroke: '0',
fillColor: 'black',
});
result.append(outerRect);
outerRect.setCursor('pointer');
var outerRect = new web2d.Rect(0, {
x: 0,
y: 0,
width: 10,
height: 10,
stroke: '0',
fillColor: 'black'
});
result.append(outerRect);
outerRect.setCursor('pointer');
const innerRect = new web2d.Rect(0, {
x: 1,
y: 1,
width: 8,
height: 8,
stroke: '1 solid white',
fillColor: 'gray',
});
result.append(innerRect);
var innerRect = new web2d.Rect(0, {
x: 1,
y: 1,
width: 8,
height: 8,
stroke: '1 solid white',
fillColor: 'gray'
});
result.append(innerRect);
const line = new web2d.Line({ stroke: '1 solid white' });
line.setFrom(1, 1);
line.setTo(9, 9);
result.append(line);
var line = new web2d.Line({stroke: '1 solid white'});
line.setFrom(1, 1);
line.setTo(9, 9);
result.append(line);
const line2 = new web2d.Line({ stroke: '1 solid white' });
line2.setFrom(1, 9);
line2.setTo(9, 1);
result.append(line2);
var line2 = new web2d.Line({stroke: '1 solid white'});
line2.setFrom(1, 9);
line2.setTo(9, 1);
result.append(line2);
// Some events ...
result.addEvent('mouseover', () => {
innerRect.setFill('#CC0033');
});
result.addEvent('mouseout', () => {
innerRect.setFill('gray');
});
// Some events ...
result.addEvent('mouseover', function () {
innerRect.setFill('#CC0033');
});
result.addEvent('mouseout', function () {
innerRect.setFill('gray');
});
result.setSize(50, 50);
return result;
},
result.setSize(50, 50);
return result;
},
/**
/**
* @param topicId
* @param icon
*/
decorate: function (topicId, icon) {
decorate(topicId, icon) {
const me = this;
var me = this;
if (!icon.__remove) {
icon.addEvent('mouseover', () => {
me.show(topicId, icon);
});
if (!icon.__remove) {
icon.addEvent('mouseover', function () {
me.show(topicId, icon);
});
icon.addEvent('mouseout', function () {
me.hide();
});
icon.__remove = true;
}
icon.addEvent('mouseout', () => {
me.hide();
});
icon.__remove = true;
}
},
});

264
packages/mindplot/lib/components/ImageIcon.js
View File

@ -19,148 +19,144 @@ const Icon = require('./Icon').default;
const ActionDispatcher = require('./ActionDispatcher').default;
const ImageIcon = new Class({
Extends: Icon,
initialize: function (topic, iconModel, readOnly) {
$assert(iconModel, 'iconModel can not be null');
$assert(topic, 'topic can not be null');
Extends: Icon,
initialize(topic, iconModel, readOnly) {
$assert(iconModel, 'iconModel can not be null');
$assert(topic, 'topic can not be null');
this._topicId = topic.getId();
this._featureModel = iconModel;
this._topicId = topic.getId();
this._featureModel = iconModel;
// Build graph image representation ...
var iconType = iconModel.getIconType();
var imgUrl = this._getImageUrl(iconType);
this.parent(imgUrl);
// Build graph image representation ...
const iconType = iconModel.getIconType();
const imgUrl = this._getImageUrl(iconType);
this.parent(imgUrl);
if (!readOnly) {
if (!readOnly) {
// Icon
const image = this.getImage();
const me = this;
image.addEvent('click', () => {
const iconType = iconModel.getIconType();
const newIconType = me._getNextFamilyIconId(iconType);
iconModel.setIconType(newIconType);
//Icon
var image = this.getImage();
var me = this;
image.addEvent('click', function () {
var iconType = iconModel.getIconType();
var newIconType = me._getNextFamilyIconId(iconType);
iconModel.setIconType(newIconType);
var imgUrl = me._getImageUrl(newIconType);
me._image.setHref(imgUrl);
});
this._image.setCursor('pointer');
}
},
_getImageUrl: function (iconId) {
return "icons/" + iconId + ".png";
},
getModel: function () {
return this._featureModel;
},
_getNextFamilyIconId: function (iconId) {
var familyIcons = this._getFamilyIcons(iconId);
$assert(familyIcons != null, "Family Icon not found!");
var result = null;
for (var i = 0; i < familyIcons.length && result == null; i++) {
if (familyIcons[i] == iconId) {
//Is last one?
if (i == (familyIcons.length - 1)) {
result = familyIcons[0];
} else {
result = familyIcons[i + 1];
}
break;
}
}
return result;
},
_getFamilyIcons: function (iconId) {
$assert(iconId != null, "id must not be null");
$assert(iconId.indexOf("_") != -1, "Invalid icon id (it must contain '_')");
var result = null;
for (var i = 0; i < ImageIcon.prototype.ICON_FAMILIES.length; i++) {
var family = ImageIcon.prototype.ICON_FAMILIES[i];
var iconFamilyId = iconId.substr(0, iconId.indexOf("_"));
if (family.id == iconFamilyId) {
result = family.icons;
break;
}
}
return result;
},
remove: function () {
var actionDispatcher = ActionDispatcher.getInstance();
var featureId = this._featureModel.getId();
var topicId = this._topicId;
actionDispatcher.removeFeatureFromTopic(topicId, featureId);
const imgUrl = me._getImageUrl(newIconType);
me._image.setHref(imgUrl);
});
this._image.setCursor('pointer');
}
},
_getImageUrl(iconId) {
return `icons/${iconId}.png`;
},
getModel() {
return this._featureModel;
},
_getNextFamilyIconId(iconId) {
const familyIcons = this._getFamilyIcons(iconId);
$assert(familyIcons != null, 'Family Icon not found!');
let result = null;
for (let i = 0; i < familyIcons.length && result == null; i++) {
if (familyIcons[i] == iconId) {
// Is last one?
if (i == (familyIcons.length - 1)) {
result = familyIcons[0];
} else {
result = familyIcons[i + 1];
}
break;
}
}
return result;
},
_getFamilyIcons(iconId) {
$assert(iconId != null, 'id must not be null');
$assert(iconId.indexOf('_') != -1, "Invalid icon id (it must contain '_')");
let result = null;
for (let i = 0; i < ImageIcon.prototype.ICON_FAMILIES.length; i++) {
const family = ImageIcon.prototype.ICON_FAMILIES[i];
const iconFamilyId = iconId.substr(0, iconId.indexOf('_'));
if (family.id == iconFamilyId) {
result = family.icons;
break;
}
}
return result;
},
remove() {
const actionDispatcher = ActionDispatcher.getInstance();
const featureId = this._featureModel.getId();
const topicId = this._topicId;
actionDispatcher.removeFeatureFromTopic(topicId, featureId);
},
});
ImageIcon.prototype.ICON_FAMILIES = [
{"id": "face", "icons": ["face_plain", "face_sad", "face_crying", "face_smile", "face_surprise", "face_wink"]},
{"id": "funy", "icons": ["funy_angel", "funy_devilish", "funy_glasses", "funy_grin", "funy_kiss", "funy_monkey"]},
{"id": "conn", "icons": ["conn_connect", "conn_disconnect"]},
{
"id": "sport",
"icons": ["sport_basketball", "sport_football", "sport_golf", "sport_raquet", "sport_shuttlecock", "sport_soccer", "sport_tennis"]
},
{"id": "bulb", "icons": ["bulb_light_on", "bulb_light_off"]},
{"id": "thumb", "icons": ["thumb_thumb_up", "thumb_thumb_down"]},
{"id": "tick", "icons": ["tick_tick", "tick_cross"]},
{
"id": "onoff",
"icons": ["onoff_clock", "onoff_clock_red", "onoff_add", "onoff_delete", "onoff_status_offline", "onoff_status_online"]
},
{
"id": "money",
"icons": ["money_money", "money_dollar", "money_euro", "money_pound", "money_yen", "money_coins", "money_ruby"]
},
{"id": "time", "icons": ["time_calendar", "time_clock", "time_hourglass"]},
{
"id": "number",
"icons": ["number_1", "number_2", "number_3", "number_4", "number_5", "number_6", "number_7", "number_8", "number_9"]
},
{"id": "chart", "icons": ["chart_bar", "chart_line", "chart_curve", "chart_pie", "chart_organisation"]},
{"id": "sign", "icons": ["sign_warning", "sign_info", "sign_stop", "sign_help", "sign_cancel"]},
{
"id": "hard",
"icons": ["hard_cd", "hard_computer", "hard_controller", "hard_driver_disk", "hard_ipod", "hard_keyboard", "hard_mouse", "hard_printer"]
},
{
"id": "soft",
"icons": ["soft_bug", "soft_cursor", "soft_database_table", "soft_database", "soft_feed", "soft_folder_explore", "soft_rss", "soft_penguin"]
},
{"id": "arrow", "icons": ["arrow_up", "arrow_down", "arrow_left", "arrow_right"]},
{
"id": "arrowc",
"icons": ["arrowc_rotate_anticlockwise", "arrowc_rotate_clockwise", "arrowc_turn_left", "arrowc_turn_right"]
},
{"id": "people", "icons": ["people_group", "people_male1", "people_male2", "people_female1", "people_female2"]},
{"id": "mail", "icons": ["mail_envelop", "mail_mailbox", "mail_edit", "mail_list"]},
{"id": "flag", "icons": ["flag_blue", "flag_green", "flag_orange", "flag_pink", "flag_purple", "flag_yellow"]},
{
"id": "bullet",
"icons": ["bullet_black", "bullet_blue", "bullet_green", "bullet_orange", "bullet_red", "bullet_pink", "bullet_purple"]
},
{"id": "tag", "icons": ["tag_blue", "tag_green", "tag_orange", "tag_red", "tag_pink", "tag_yellow"]},
{
"id": "object",
"icons": ["object_bell", "object_clanbomber", "object_key", "object_pencil", "object_phone", "object_magnifier", "object_clip", "object_music", "object_star", "object_wizard", "object_house", "object_cake", "object_camera", "object_palette", "object_rainbow"]
},
{
"id": "weather",
"icons": ["weather_clear-night", "weather_clear", "weather_few-clouds-night", "weather_few-clouds", "weather_overcast", "weather_severe-alert", "weather_showers-scattered", "weather_showers", "weather_snow", "weather_storm"]
},
{"id": "task", "icons": ["task_0", "task_25", "task_50", "task_75", "task_100"]}
{ id: 'face', icons: ['face_plain', 'face_sad', 'face_crying', 'face_smile', 'face_surprise', 'face_wink'] },
{ id: 'funy', icons: ['funy_angel', 'funy_devilish', 'funy_glasses', 'funy_grin', 'funy_kiss', 'funy_monkey'] },
{ id: 'conn', icons: ['conn_connect', 'conn_disconnect'] },
{
id: 'sport',
icons: ['sport_basketball', 'sport_football', 'sport_golf', 'sport_raquet', 'sport_shuttlecock', 'sport_soccer', 'sport_tennis'],
},
{ id: 'bulb', icons: ['bulb_light_on', 'bulb_light_off'] },
{ id: 'thumb', icons: ['thumb_thumb_up', 'thumb_thumb_down'] },
{ id: 'tick', icons: ['tick_tick', 'tick_cross'] },
{
id: 'onoff',
icons: ['onoff_clock', 'onoff_clock_red', 'onoff_add', 'onoff_delete', 'onoff_status_offline', 'onoff_status_online'],
},
{
id: 'money',
icons: ['money_money', 'money_dollar', 'money_euro', 'money_pound', 'money_yen', 'money_coins', 'money_ruby'],
},
{ id: 'time', icons: ['time_calendar', 'time_clock', 'time_hourglass'] },
{
id: 'number',
icons: ['number_1', 'number_2', 'number_3', 'number_4', 'number_5', 'number_6', 'number_7', 'number_8', 'number_9'],
},
{ id: 'chart', icons: ['chart_bar', 'chart_line', 'chart_curve', 'chart_pie', 'chart_organisation'] },
{ id: 'sign', icons: ['sign_warning', 'sign_info', 'sign_stop', 'sign_help', 'sign_cancel'] },
{
id: 'hard',
icons: ['hard_cd', 'hard_computer', 'hard_controller', 'hard_driver_disk', 'hard_ipod', 'hard_keyboard', 'hard_mouse', 'hard_printer'],
},
{
id: 'soft',
icons: ['soft_bug', 'soft_cursor', 'soft_database_table', 'soft_database', 'soft_feed', 'soft_folder_explore', 'soft_rss', 'soft_penguin'],
},
{ id: 'arrow', icons: ['arrow_up', 'arrow_down', 'arrow_left', 'arrow_right'] },
{
id: 'arrowc',
icons: ['arrowc_rotate_anticlockwise', 'arrowc_rotate_clockwise', 'arrowc_turn_left', 'arrowc_turn_right'],
},
{ id: 'people', icons: ['people_group', 'people_male1', 'people_male2', 'people_female1', 'people_female2'] },
{ id: 'mail', icons: ['mail_envelop', 'mail_mailbox', 'mail_edit', 'mail_list'] },
{ id: 'flag', icons: ['flag_blue', 'flag_green', 'flag_orange', 'flag_pink', 'flag_purple', 'flag_yellow'] },
{
id: 'bullet',
icons: ['bullet_black', 'bullet_blue', 'bullet_green', 'bullet_orange', 'bullet_red', 'bullet_pink', 'bullet_purple'],
},
{ id: 'tag', icons: ['tag_blue', 'tag_green', 'tag_orange', 'tag_red', 'tag_pink', 'tag_yellow'] },
{
id: 'object',
icons: ['object_bell', 'object_clanbomber', 'object_key', 'object_pencil', 'object_phone', 'object_magnifier', 'object_clip', 'object_music', 'object_star', 'object_wizard', 'object_house', 'object_cake', 'object_camera', 'object_palette', 'object_rainbow'],
},
{
id: 'weather',
icons: ['weather_clear-night', 'weather_clear', 'weather_few-clouds-night', 'weather_few-clouds', 'weather_overcast', 'weather_severe-alert', 'weather_showers-scattered', 'weather_showers', 'weather_snow', 'weather_storm'],
},
{ id: 'task', icons: ['task_0', 'task_25', 'task_50', 'task_75', 'task_100'] },
];
export default ImageIcon;

18
packages/mindplot/lib/components/Keyboard.js
View File

@ -18,17 +18,17 @@
const Keyboard = new Class({
initialize: function () {
},
initialize() {
},
addShortcut: function (shortcuts, callback) {
if (!$.isArray(shortcuts)) {
shortcuts = [shortcuts];
}
_.each(shortcuts, function (shortcut) {
$(document).bind('keydown', shortcut, callback);
});
addShortcut(shortcuts, callback) {
if (!$.isArray(shortcuts)) {
shortcuts = [shortcuts];
}
_.each(shortcuts, (shortcut) => {
$(document).bind('keydown', shortcut, callback);
});
},
});

82
packages/mindplot/lib/components/LinkIcon.js
View File

@ -20,53 +20,51 @@ const LinkIconTooltip = require('./widget/LinkIconTooltip').default;
const LinkIcon = new Class({
Extends: Icon,
initialize: function (topic, linkModel, readOnly) {
$assert(topic, 'topic can not be null');
$assert(linkModel, 'linkModel can not be null');
Extends: Icon,
initialize(topic, linkModel, readOnly) {
$assert(topic, 'topic can not be null');
$assert(linkModel, 'linkModel can not be null');
this.parent(LinkIcon.IMAGE_URL);
this._linksModel = linkModel;
this._topic = topic;
this._readOnly = readOnly;
this.parent(LinkIcon.IMAGE_URL);
this._linksModel = linkModel;
this._topic = topic;
this._readOnly = readOnly;
this._registerEvents();
},
this._registerEvents();
},
_registerEvents: function () {
this._image.setCursor('pointer');
this._tip = new LinkIconTooltip(this);
_registerEvents() {
this._image.setCursor('pointer');
this._tip = new LinkIconTooltip(this);
var me = this;
if (!this._readOnly) {
// Add on click event to open the editor ...
this.addEvent('click', function (event) {
me._tip.hide();
me._topic.showLinkEditor();
event.stopPropagation();
});
//FIXME: we shouldn't have timeout of that..
this.addEvent("mouseleave", function (event) {
window.setTimeout(function () {
if (!$("#linkPopover:hover").length) {
me._tip.hide();
}
event.stopPropagation();
}, 100)
});
}
$(this.getImage()._peer._native).mouseenter(function () {
me._tip.show();
})
},
getModel: function () {
return this._linksModel;
const me = this;
if (!this._readOnly) {
// Add on click event to open the editor ...
this.addEvent('click', (event) => {
me._tip.hide();
me._topic.showLinkEditor();
event.stopPropagation();
});
// FIXME: we shouldn't have timeout of that..
this.addEvent('mouseleave', (event) => {
window.setTimeout(() => {
if (!$('#linkPopover:hover').length) {
me._tip.hide();
}
event.stopPropagation();
}, 100);
});
}
$(this.getImage()._peer._native).mouseenter(() => {
me._tip.show();
});
},
getModel() {
return this._linksModel;
},
});
LinkIcon.IMAGE_URL = "images/links.png";
LinkIcon.IMAGE_URL = 'images/links.png';
export default LinkIcon;

79
packages/mindplot/lib/components/LocalStorageManager.js
View File

@ -18,47 +18,46 @@
const PersistenceManager = require('./PersistenceManager').default;
const LocalStorageManager = new Class({
Extends: PersistenceManager,
initialize: function (documentUrl, forceLoad) {
this.parent();
this.documentUrl = documentUrl;
this.forceLoad = forceLoad;
Extends: PersistenceManager,
initialize(documentUrl, forceLoad) {
this.parent();
this.documentUrl = documentUrl;
this.forceLoad = forceLoad;
},
saveMapXml(mapId, mapXml, pref, saveHistory, events) {
localStorage.setItem(`${mapId}-xml`, mapXml);
},
discardChanges(mapId) {
localStorage.removeItem(`${mapId}-xml`);
},
loadMapDom(mapId) {
let xml = localStorage.getItem(`${mapId}-xml`);
if (xml == null || this.forceLoad) {
$.ajax({
url: this.documentUrl.replace('{id}', mapId),
headers: { 'Content-Type': 'text/plain', Accept: 'application/xml' },
type: 'get',
dataType: 'text',
async: false,
success(response) {
xml = response;
},
saveMapXml: function (mapId, mapXml, pref, saveHistory, events) {
localStorage.setItem(mapId + "-xml", mapXml);
},
discardChanges: function (mapId) {
localStorage.removeItem(mapId + "-xml");
},
loadMapDom: function (mapId) {
var xml = localStorage.getItem(mapId + "-xml");
if (xml == null || this.forceLoad) {
$.ajax({
url: this.documentUrl.replace("{id}", mapId),
headers: {"Content-Type": "text/plain", "Accept": "application/xml"},
type: 'get',
dataType: "text",
async: false,
success: function (response) {
xml = response;
}
});
// If I could not load it from a file, hard code one.
if (xml == null) {
throw new Error("Map could not be loaded");
}
}
return jQuery.parseXML(xml);
},
unlockMap: function (mindmap) {
// Ignore, no implementation required ...
}
});
// If I could not load it from a file, hard code one.
if (xml == null) {
throw new Error('Map could not be loaded');
}
}
);
return jQuery.parseXML(xml);
},
unlockMap(mindmap) {
// Ignore, no implementation required ...
},
});
export default LocalStorageManager;

339
packages/mindplot/lib/components/MainTopic.js
View File

@ -1,169 +1,170 @@
/*
* 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 Core = require('@wismapping/core-js')
const core = Core();
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const Topic = require('./Topic').default;
const { TopicShape } = require('./model/INodeModel');
const Shape = require('./util/Shape').default;
const MainTopic = new Class(/** @lends MainTopic */ {
Extends: Topic,
/**
* @extends mindplot.Topic
* @constructs
* @param model
* @param options
*/
initialize: function (model, options) {
this.parent(model, options);
},
INNER_RECT_ATTRIBUTES: { stroke: '0.5 solid #009900' },
_buildDragShape: function () {
var innerShape = this._buildShape(this.INNER_RECT_ATTRIBUTES, this.getShapeType());
var size = this.getSize();
innerShape.setSize(size.width, size.height);
innerShape.setPosition(0, 0);
innerShape.setOpacity(0.5);
innerShape.setCursor('default');
innerShape.setVisibility(true);
var brColor = this.getBorderColor();
innerShape.setAttribute('strokeColor', brColor);
var bgColor = this.getBackgroundColor();
innerShape.setAttribute('fillColor', bgColor);
// Create group ...
var groupAttributes = {
width: 100,
height: 100,
coordSizeWidth: 100,
coordSizeHeight: 100,
};
var group = new web2d.Group(groupAttributes);
group.append(innerShape);
// Add Text ...
if (this.getShapeType() != TopicShape.IMAGE) {
var textShape = this._buildTextShape(true);
var text = this.getText();
textShape.setText(text);
textShape.setOpacity(0.5);
group.append(textShape);
}
return group;
},
/** */
updateTopicShape: function (targetTopic, workspace) {
// Change figure based on the connected topic ...
var model = this.getModel();
var shapeType = model.getShapeType();
if (!targetTopic.isCentralTopic()) {
if (!$defined(shapeType)) {
// Get the real shape type ...
shapeType = this.getShapeType();
this._setShapeType(shapeType, false);
}
}
},
/** */
disconnect: function (workspace) {
this.parent(workspace);
var size = this.getSize();
var model = this.getModel();
var shapeType = model.getShapeType();
if (!$defined(shapeType)) {
// Change figure ...
shapeType = this.getShapeType();
this._setShapeType(TopicShape.ROUNDED_RECT, false);
}
var innerShape = this.getInnerShape();
innerShape.setVisibility(true);
},
_updatePositionOnChangeSize: function (oldSize, newSize) {
var xOffset = Math.round((newSize.width - oldSize.width) / 2);
var pos = this.getPosition();
if ($defined(pos)) {
if (pos.x > 0) {
pos.x = pos.x + xOffset;
} else {
pos.x = pos.x - xOffset;
}
this.setPosition(pos);
}
},
/** */
workoutIncomingConnectionPoint: function (sourcePosition) {
return Shape.workoutIncomingConnectionPoint(this, sourcePosition);
},
/** */
workoutOutgoingConnectionPoint: function (targetPosition) {
$assert(targetPosition, 'targetPoint can not be null');
var pos = this.getPosition();
var isAtRight = Shape.isAtRight(targetPosition, pos);
var size = this.getSize();
var result;
if (this.getShapeType() == TopicShape.LINE) {
result = new core.Point();
var groupPosition = this._elem2d.getPosition();
var innerShareSize = this.getInnerShape().getSize();
if (innerShareSize) {
var magicCorrectionNumber = 0.3;
if (!isAtRight) {
result.x = groupPosition.x + innerShareSize.width - magicCorrectionNumber;
} else {
result.x = groupPosition.x + magicCorrectionNumber;
}
result.y = groupPosition.y + innerShareSize.height;
} else {
// Hack: When the size has not being defined. This is because the node has not being added.
// Try to do our best ...
if (!isAtRight) {
result.x = pos.x + size.width / 2;
} else {
result.x = pos.x - size.width / 2;
}
result.y = pos.y + size.height / 2;
}
} else {
result = Shape.calculateRectConnectionPoint(
pos,
size,
isAtRight,
true
);
}
return result;
},
}
);
export default MainTopic;
/*
* 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 Core = require('@wismapping/core-js');
const core = Core();
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const Topic = require('./Topic').default;
const { TopicShape } = require('./model/INodeModel');
const Shape = require('./util/Shape').default;
const MainTopic = new Class(/** @lends MainTopic */ {
Extends: Topic,
/**
* @extends mindplot.Topic
* @constructs
* @param model
* @param options
*/
initialize(model, options) {
this.parent(model, options);
},
INNER_RECT_ATTRIBUTES: { stroke: '0.5 solid #009900' },
_buildDragShape() {
const innerShape = this._buildShape(this.INNER_RECT_ATTRIBUTES, this.getShapeType());
const size = this.getSize();
innerShape.setSize(size.width, size.height);
innerShape.setPosition(0, 0);
innerShape.setOpacity(0.5);
innerShape.setCursor('default');
innerShape.setVisibility(true);
const brColor = this.getBorderColor();
innerShape.setAttribute('strokeColor', brColor);
const bgColor = this.getBackgroundColor();
innerShape.setAttribute('fillColor', bgColor);
// Create group ...
const groupAttributes = {
width: 100,
height: 100,
coordSizeWidth: 100,
coordSizeHeight: 100,
};
const group = new web2d.Group(groupAttributes);
group.append(innerShape);
// Add Text ...
if (this.getShapeType() != TopicShape.IMAGE) {
const textShape = this._buildTextShape(true);
const text = this.getText();
textShape.setText(text);
textShape.setOpacity(0.5);
group.append(textShape);
}
return group;
},
/** */
updateTopicShape(targetTopic, workspace) {
// Change figure based on the connected topic ...
const model = this.getModel();
let shapeType = model.getShapeType();
if (!targetTopic.isCentralTopic()) {
if (!$defined(shapeType)) {
// Get the real shape type ...
shapeType = this.getShapeType();
this._setShapeType(shapeType, false);
}
}
},
/** */
disconnect(workspace) {
this.parent(workspace);
const size = this.getSize();
const model = this.getModel();
let shapeType = model.getShapeType();
if (!$defined(shapeType)) {
// Change figure ...
shapeType = this.getShapeType();
this._setShapeType(TopicShape.ROUNDED_RECT, false);
}
const innerShape = this.getInnerShape();
innerShape.setVisibility(true);
},
_updatePositionOnChangeSize(oldSize, newSize) {
const xOffset = Math.round((newSize.width - oldSize.width) / 2);
const pos = this.getPosition();
if ($defined(pos)) {
if (pos.x > 0) {
pos.x += xOffset;
} else {
pos.x -= xOffset;
}
this.setPosition(pos);
}
},
/** */
workoutIncomingConnectionPoint(sourcePosition) {
return Shape.workoutIncomingConnectionPoint(this, sourcePosition);
},
/** */
workoutOutgoingConnectionPoint(targetPosition) {
$assert(targetPosition, 'targetPoint can not be null');
const pos = this.getPosition();
const isAtRight = Shape.isAtRight(targetPosition, pos);
const size = this.getSize();
let result;
if (this.getShapeType() == TopicShape.LINE) {
result = new core.Point();
const groupPosition = this._elem2d.getPosition();
const innerShareSize = this.getInnerShape().getSize();
if (innerShareSize) {
const magicCorrectionNumber = 0.3;
if (!isAtRight) {
result.x = groupPosition.x + innerShareSize.width - magicCorrectionNumber;
} else {
result.x = groupPosition.x + magicCorrectionNumber;
}
result.y = groupPosition.y + innerShareSize.height;
} else {
// Hack: When the size has not being defined. This is because the node has not being added.
// Try to do our best ...
if (!isAtRight) {
result.x = pos.x + size.width / 2;
} else {
result.x = pos.x - size.width / 2;
}
result.y = pos.y + size.height / 2;
}
} else {
result = Shape.calculateRectConnectionPoint(
pos,
size,
isAtRight,
true,
);
}
return result;
},
});
export default MainTopic;

32
packages/mindplot/lib/components/Messages.js
View File

@ -17,27 +17,27 @@
*/
const Messages = new Class({
Static: {
init: function (locale) {
locale = $defined(locale) ? locale : 'en';
var bundle = Messages.BUNDLES[locale];
if (bundle == null && locale.indexOf('_') != -1) {
// Try to locate without the specialization ...
locale = locale.substring(0, locale.indexOf('_'));
bundle = Messages.BUNDLES[locale];
}
Messages.__bundle = bundle;
},
Static: {
init(locale) {
locale = $defined(locale) ? locale : 'en';
let bundle = Messages.BUNDLES[locale];
if (bundle == null && locale.indexOf('_') != -1) {
// Try to locate without the specialization ...
locale = locale.substring(0, locale.indexOf('_'));
bundle = Messages.BUNDLES[locale];
}
Messages.__bundle = bundle;
},
},
});
global.$msg = function (key) {
if (!Messages.__bundle) {
Messages.init('en');
}
if (!Messages.__bundle) {
Messages.init('en');
}
var msg = Messages.__bundle[key];
return msg ? msg : key;
const msg = Messages.__bundle[key];
return msg || key;
};
Messages.BUNDLES = {};

547
packages/mindplot/lib/components/MultilineTextEditor.js
View File

@ -19,298 +19,285 @@ const Events = require('./Events').default;
const ActionDispatcher = require('./ActionDispatcher').default;
const MultilineTextEditor = new Class({
Extends: Events,
initialize: function () {
this._topic = null;
this._timeoutId = -1;
},
Extends: Events,
initialize() {
this._topic = null;
this._timeoutId = -1;
},
_buildEditor: function () {
_buildEditor() {
const result = $('<div></div>')
.attr('id', 'textContainer')
.css({
display: 'none',
zIndex: '8',
overflow: 'hidden',
border: '0 none',
});
var result = $('<div></div>')
.attr('id', 'textContainer')
.css({
display: "none",
zIndex: "8",
overflow: "hidden",
border: "0 none"
});
const textareaElem = $('<textarea tabindex="-1" value="" wrap="off" ></textarea>')
.css({
border: '1px gray dashed',
background: 'rgba(98, 135, 167, .3)',
outline: '0 none',
resize: 'none',
overflow: 'hidden',
});
result.append(textareaElem);
return result;
},
var textareaElem = $('<textarea tabindex="-1" value="" wrap="off" ></textarea>')
.css({
border: "1px gray dashed",
background: "rgba(98, 135, 167, .3)",
outline: '0 none',
resize: 'none',
overflow: "hidden"
});
result.append(textareaElem);
return result;
},
_registerEvents: function (containerElem) {
var textareaElem = this._getTextareaElem();
var me = this;
textareaElem.on('keydown', function (event) {
switch (jQuery.hotkeys.specialKeys[event.keyCode]) {
case 'esc':
me.close(false);
break;
case 'enter':
if (event.metaKey || event.ctrlKey) {
// Add return ...
var text = textareaElem.val();
var cursorPosition = text.length;
if (textareaElem.selectionStart) {
cursorPosition = textareaElem.selectionStart;
}
var head = text.substring(0, cursorPosition);
var tail = "";
if (cursorPosition < text.length) {
tail = text.substring(cursorPosition, text.length);
}
textareaElem.val(head + "\n" + tail);
// Position cursor ...
if (textareaElem[0].setSelectionRange) {
textareaElem.focus();
textareaElem[0].setSelectionRange(cursorPosition + 1, cursorPosition + 1);
} else if (textareaElem.createTextRange) {
var range = textareaElem.createTextRange();
range.moveStart('character', cursorPosition + 1);
range.select();
}
}
else {
me.close(true);
}
break;
case 'tab':
event.preventDefault();
var start = $(this).get(0).selectionStart;
var end = $(this).get(0).selectionEnd;
// set textarea value to: text before caret + tab + text after caret
$(this).val($(this).val().substring(0, start) + "\t" + $(this).val().substring(end));
// put caret at right position again
$(this).get(0).selectionStart = $(this).get(0).selectionEnd = start + 1;
break;
}
event.stopPropagation();
});
textareaElem.on('keypress', function (event) {
event.stopPropagation();
});
textareaElem.on('keyup', function (event) {
var text = me._getTextareaElem().val();
me.fireEvent('input', [event, text]);
me._adjustEditorSize();
});
// If the user clicks on the input, all event must be ignored ...
containerElem.on('click', function (event) {
event.stopPropagation();
});
containerElem.on('dblclick', function (event) {
event.stopPropagation();
});
containerElem.on('mousedown', function (event) {
event.stopPropagation();
});
},
_adjustEditorSize: function () {
if (this.isVisible()) {
var textElem = this._getTextareaElem();
var lines = textElem.val().split('\n');
var maxLineLength = 1;
_.each(lines, function (line) {
if (maxLineLength < line.length)
maxLineLength = line.length;
});
textElem.attr('cols', maxLineLength);
textElem.attr('rows', lines.length);
this._containerElem.css({
width: (maxLineLength + 3) + 'em',
height: textElem.height()
});
}
},
isVisible: function () {
return $defined(this._containerElem) && this._containerElem.css('display') == 'block';
},
_updateModel: function () {
if (this._topic.getText() != this._getText()) {
var text = this._getText();
var topicId = this._topic.getId();
var actionDispatcher = ActionDispatcher.getInstance();
actionDispatcher.changeTextToTopic([topicId], text);
}
},
show: function (topic, text) {
// Close a previous node editor if it's opened ...
if (this._topic) {
this.close(false);
}
this._topic = topic;
if (!this.isVisible()) {
//Create editor ui
var containerElem = this._buildEditor();
$('body').append(containerElem);
this._containerElem = containerElem;
this._registerEvents(containerElem);
this._showEditor(text);
}
},
_showEditor: function (defaultText) {
var topic = this._topic;
// Hide topic text ...
topic.getTextShape().setVisibility(false);
// Set Editor Style
var nodeText = topic.getTextShape();
var font = nodeText.getFont();
font.size = nodeText.getHtmlFontSize();
font.color = nodeText.getColor();
this._setStyle(font);
var me = this;
// Set editor's initial size
var displayFunc = function () {
// Position the editor and set the size...
var textShape = topic.getTextShape();
me._containerElem.css('display', 'block');
//FIXME: Im not sure if this is best way...
var shapePosition = textShape.getNativePosition();
me._containerElem.offset(shapePosition);
// Set editor's initial text ...
var text = $defined(defaultText) ? defaultText : topic.getText();
me._setText(text);
// Set the element focus and select the current text ...
var inputElem = me._getTextareaElem();
me._positionCursor(inputElem, !$defined(defaultText));
};
this._timeoutId = displayFunc.delay(10);
},
_setStyle: function (fontStyle) {
var inputField = this._getTextareaElem();
if (!$defined(fontStyle.font)) {
fontStyle.font = "Arial";
}
if (!$defined(fontStyle.style)) {
fontStyle.style = "normal";
}
if (!$defined(fontStyle.weight)) {
fontStyle.weight = "normal";
}
if (!$defined(fontStyle.size)) {
fontStyle.size = 12;
}
var style = {
fontSize: fontStyle.size + "px",
fontFamily: fontStyle.font,
fontStyle: fontStyle.style,
fontWeight: fontStyle.weight,
color: fontStyle.color
};
inputField.css(style);
this._containerElem.css(style);
},
_setText: function (text) {
var textareaElem = this._getTextareaElem();
textareaElem.val(text);
this._adjustEditorSize();
},
_getText: function () {
return this._getTextareaElem().val();
},
_getTextareaElem: function () {
return this._containerElem.find('textarea');
},
_positionCursor: function (textareaElem, selectText) {
textareaElem.focus();
var lengh = textareaElem.val().length;
if (selectText) {
// Mark text as selected ...
if (textareaElem.createTextRange) {
var rang = textareaElem.createTextRange();
rang.select();
rang.move("character", lengh);
}
else {
textareaElem[0].setSelectionRange(0, lengh);
_registerEvents(containerElem) {
const textareaElem = this._getTextareaElem();
const me = this;
textareaElem.on('keydown', function (event) {
switch (jQuery.hotkeys.specialKeys[event.keyCode]) {
case 'esc':
me.close(false);
break;
case 'enter':
if (event.metaKey || event.ctrlKey) {
// Add return ...
const text = textareaElem.val();
let cursorPosition = text.length;
if (textareaElem.selectionStart) {
cursorPosition = textareaElem.selectionStart;
}
} else {
// Move the cursor to the last character ..
if (textareaElem.createTextRange) {
var range = textareaElem.createTextRange();
range.move("character", lengh);
} else {
if (Browser.ie11) {
textareaElem[0].selectionStart = lengh;
textareaElem[0].selectionEnd = lengh;
} else {
textareaElem.selectionStart = lengh;
textareaElem.selectionEnd = lengh;
}
textareaElem.focus();
const head = text.substring(0, cursorPosition);
let tail = '';
if (cursorPosition < text.length) {
tail = text.substring(cursorPosition, text.length);
}
}
textareaElem.val(`${head}\n${tail}`);
},
close: function (update) {
if (this.isVisible() && this._topic) {
// Update changes ...
clearTimeout(this._timeoutId);
if (!$defined(update) || update) {
this._updateModel();
// Position cursor ...
if (textareaElem[0].setSelectionRange) {
textareaElem.focus();
textareaElem[0].setSelectionRange(cursorPosition + 1, cursorPosition + 1);
} else if (textareaElem.createTextRange) {
const range = textareaElem.createTextRange();
range.moveStart('character', cursorPosition + 1);
range.select();
}
} else {
me.close(true);
}
break;
case 'tab':
event.preventDefault();
var start = $(this).get(0).selectionStart;
var end = $(this).get(0).selectionEnd;
// Let make the visible text in the node visible again ...
this._topic.getTextShape().setVisibility(true);
// set textarea value to: text before caret + tab + text after caret
$(this).val(`${$(this).val().substring(0, start)}\t${$(this).val().substring(end)}`);
// Remove it form the screen ...
this._containerElem.remove();
this._containerElem = null;
this._timeoutId = -1;
}
this._topic = null;
// put caret at right position again
$(this).get(0).selectionStart = $(this).get(0).selectionEnd = start + 1;
break;
}
event.stopPropagation();
});
textareaElem.on('keypress', (event) => {
event.stopPropagation();
});
textareaElem.on('keyup', (event) => {
const text = me._getTextareaElem().val();
me.fireEvent('input', [event, text]);
me._adjustEditorSize();
});
// If the user clicks on the input, all event must be ignored ...
containerElem.on('click', (event) => {
event.stopPropagation();
});
containerElem.on('dblclick', (event) => {
event.stopPropagation();
});
containerElem.on('mousedown', (event) => {
event.stopPropagation();
});
},
_adjustEditorSize() {
if (this.isVisible()) {
const textElem = this._getTextareaElem();
const lines = textElem.val().split('\n');
let maxLineLength = 1;
_.each(lines, (line) => {
if (maxLineLength < line.length) maxLineLength = line.length;
});
textElem.attr('cols', maxLineLength);
textElem.attr('rows', lines.length);
this._containerElem.css({
width: `${maxLineLength + 3}em`,
height: textElem.height(),
});
}
},
isVisible() {
return $defined(this._containerElem) && this._containerElem.css('display') == 'block';
},
_updateModel() {
if (this._topic.getText() != this._getText()) {
const text = this._getText();
const topicId = this._topic.getId();
const actionDispatcher = ActionDispatcher.getInstance();
actionDispatcher.changeTextToTopic([topicId], text);
}
},
show(topic, text) {
// Close a previous node editor if it's opened ...
if (this._topic) {
this.close(false);
}
this._topic = topic;
if (!this.isVisible()) {
// Create editor ui
const containerElem = this._buildEditor();
$('body').append(containerElem);
this._containerElem = containerElem;
this._registerEvents(containerElem);
this._showEditor(text);
}
},
_showEditor(defaultText) {
const topic = this._topic;
// Hide topic text ...
topic.getTextShape().setVisibility(false);
// Set Editor Style
const nodeText = topic.getTextShape();
const font = nodeText.getFont();
font.size = nodeText.getHtmlFontSize();
font.color = nodeText.getColor();
this._setStyle(font);
const me = this;
// Set editor's initial size
const displayFunc = function () {
// Position the editor and set the size...
const textShape = topic.getTextShape();
me._containerElem.css('display', 'block');
// FIXME: Im not sure if this is best way...
const shapePosition = textShape.getNativePosition();
me._containerElem.offset(shapePosition);
// Set editor's initial text ...
const text = $defined(defaultText) ? defaultText : topic.getText();
me._setText(text);
// Set the element focus and select the current text ...
const inputElem = me._getTextareaElem();
me._positionCursor(inputElem, !$defined(defaultText));
};
this._timeoutId = displayFunc.delay(10);
},
_setStyle(fontStyle) {
const inputField = this._getTextareaElem();
if (!$defined(fontStyle.font)) {
fontStyle.font = 'Arial';
}
if (!$defined(fontStyle.style)) {
fontStyle.style = 'normal';
}
if (!$defined(fontStyle.weight)) {
fontStyle.weight = 'normal';
}
if (!$defined(fontStyle.size)) {
fontStyle.size = 12;
}
const style = {
fontSize: `${fontStyle.size}px`,
fontFamily: fontStyle.font,
fontStyle: fontStyle.style,
fontWeight: fontStyle.weight,
color: fontStyle.color,
};
inputField.css(style);
this._containerElem.css(style);
},
_setText(text) {
const textareaElem = this._getTextareaElem();
textareaElem.val(text);
this._adjustEditorSize();
},
_getText() {
return this._getTextareaElem().val();
},
_getTextareaElem() {
return this._containerElem.find('textarea');
},
_positionCursor(textareaElem, selectText) {
textareaElem.focus();
const lengh = textareaElem.val().length;
if (selectText) {
// Mark text as selected ...
if (textareaElem.createTextRange) {
const rang = textareaElem.createTextRange();
rang.select();
rang.move('character', lengh);
} else {
textareaElem[0].setSelectionRange(0, lengh);
}
} else {
// Move the cursor to the last character ..
if (textareaElem.createTextRange) {
const range = textareaElem.createTextRange();
range.move('character', lengh);
} else {
if (Browser.ie11) {
textareaElem[0].selectionStart = lengh;
textareaElem[0].selectionEnd = lengh;
} else {
textareaElem.selectionStart = lengh;
textareaElem.selectionEnd = lengh;
}
textareaElem.focus();
}
}
},
close(update) {
if (this.isVisible() && this._topic) {
// Update changes ...
clearTimeout(this._timeoutId);
if (!$defined(update) || update) {
this._updateModel();
}
// Let make the visible text in the node visible again ...
this._topic.getTextShape().setVisibility(true);
// Remove it form the screen ...
this._containerElem.remove();
this._containerElem = null;
this._timeoutId = -1;
}
this._topic = null;
},
});
export default MultilineTextEditor;

276
packages/mindplot/lib/components/NodeGraph.js
View File

@ -20,171 +20,171 @@ const DragTopic = require('./DragTopic').default;
const INodeModel = require('./model/INodeModel').default;
const NodeGraph = new Class(
/** @lends NodeGraph */ {
/**
/** @lends NodeGraph */ {
/**
* @constructs
* @param {mindplot.model.NodeModel} nodeModel
* @param {Object<Number, String, Boolean>} options
* @throws will throw an error if nodeModel is null or undefined
*/
initialize: function (nodeModel, options) {
$assert(nodeModel, 'model can not be null');
initialize(nodeModel, options) {
$assert(nodeModel, 'model can not be null');
this._options = options;
this._mouseEvents = true;
this.setModel(nodeModel);
this._onFocus = false;
this._size = { width: 50, height: 20 };
},
this._options = options;
this._mouseEvents = true;
this.setModel(nodeModel);
this._onFocus = false;
this._size = { width: 50, height: 20 };
},
/** @return true if option is set to read-only */
isReadOnly: function () {
return this._options.readOnly;
},
/** @return true if option is set to read-only */
isReadOnly() {
return this._options.readOnly;
},
/** @return model type */
getType: function () {
var model = this.getModel();
return model.getType();
},
/** @return model type */
getType() {
const model = this.getModel();
return model.getType();
},
/**
/**
* @param {String} id
* @throws will throw an error if the topic id is not a number
*/
setId: function (id) {
$assert(typeof topic.getId() == 'number', 'id is not a number:' + id);
this.getModel().setId(id);
},
setId(id) {
$assert(typeof topic.getId() === 'number', `id is not a number:${id}`);
this.getModel().setId(id);
},
_set2DElement: function (elem2d) {
this._elem2d = elem2d;
},
_set2DElement(elem2d) {
this._elem2d = elem2d;
},
/**
/**
* @return 2D element
* @throws will throw an error if the element is null or undefined within node graph
*/
get2DElement: function () {
$assert(this._elem2d, 'NodeGraph has not been initialized properly');
return this._elem2d;
},
get2DElement() {
$assert(this._elem2d, 'NodeGraph has not been initialized properly');
return this._elem2d;
},
/** @abstract */
setPosition: function (point, fireEvent) {
throw 'Unsupported operation';
},
/** @abstract */
setPosition(point, fireEvent) {
throw 'Unsupported operation';
},
/** */
addEvent: function (type, listener) {
var elem = this.get2DElement();
elem.addEvent(type, listener);
},
/** */
addEvent(type, listener) {
const elem = this.get2DElement();
elem.addEvent(type, listener);
},
/** */
removeEvent: function (type, listener) {
var elem = this.get2DElement();
elem.removeEvent(type, listener);
},
/** */
removeEvent(type, listener) {
const elem = this.get2DElement();
elem.removeEvent(type, listener);
},
/** */
fireEvent: function (type, event) {
var elem = this.get2DElement();
elem.trigger(type, event);
},
/** */
fireEvent(type, event) {
const elem = this.get2DElement();
elem.trigger(type, event);
},
/** */
setMouseEventsEnabled: function (isEnabled) {
this._mouseEvents = isEnabled;
},
/** */
setMouseEventsEnabled(isEnabled) {
this._mouseEvents = isEnabled;
},
/** */
isMouseEventsEnabled: function () {
return this._mouseEvents;
},
/** */
isMouseEventsEnabled() {
return this._mouseEvents;
},
/** @return {Object<Number>} size*/
getSize: function () {
return this._size;
},
/** @return {Object<Number>} size */
getSize() {
return this._size;
},
/** @param {Object<Number>} size*/
setSize: function (size) {
this._size.width = parseInt(size.width);
this._size.height = parseInt(size.height);
},
/** @param {Object<Number>} size */
setSize(size) {
this._size.width = parseInt(size.width);
this._size.height = parseInt(size.height);
},
/**
/**
* @return {mindplot.model.NodeModel} the node model
*/
getModel: function () {
$assert(this._model, 'Model has not been initialized yet');
return this._model;
},
getModel() {
$assert(this._model, 'Model has not been initialized yet');
return this._model;
},
/**
/**
* @param {mindplot.NodeModel} model the node model
* @throws will throw an error if model is null or undefined
*/
setModel: function (model) {
$assert(model, 'Model can not be null');
this._model = model;
},
setModel(model) {
$assert(model, 'Model can not be null');
this._model = model;
},
/** */
getId: function () {
return this._model.getId();
},
/** */
getId() {
return this._model.getId();
},
/** */
setOnFocus: function (focus) {
if (this._onFocus != focus) {
this._onFocus = focus;
var outerShape = this.getOuterShape();
if (focus) {
outerShape.setFill(Topic.OUTER_SHAPE_ATTRIBUTES_FOCUS.fillColor);
outerShape.setOpacity(1);
} else {
outerShape.setFill(Topic.OUTER_SHAPE_ATTRIBUTES.fillColor);
outerShape.setOpacity(0);
}
this.setCursor('move');
/** */
setOnFocus(focus) {
if (this._onFocus != focus) {
this._onFocus = focus;
const outerShape = this.getOuterShape();
if (focus) {
outerShape.setFill(Topic.OUTER_SHAPE_ATTRIBUTES_FOCUS.fillColor);
outerShape.setOpacity(1);
} else {
outerShape.setFill(Topic.OUTER_SHAPE_ATTRIBUTES.fillColor);
outerShape.setOpacity(0);
}
this.setCursor('move');
// In any case, always try to hide the editor ...
this.closeEditors();
// In any case, always try to hide the editor ...
this.closeEditors();
// Fire event ...
this.fireEvent(focus ? 'ontfocus' : 'ontblur', this);
}
},
// Fire event ...
this.fireEvent(focus ? 'ontfocus' : 'ontblur', this);
}
},
/** @return {Boolean} true if the node graph is on focus */
isOnFocus: function () {
return this._onFocus;
},
/** @return {Boolean} true if the node graph is on focus */
isOnFocus() {
return this._onFocus;
},
/** */
dispose: function (workspace) {
this.setOnFocus(false);
workspace.removeChild(this);
},
/** */
dispose(workspace) {
this.setOnFocus(false);
workspace.removeChild(this);
},
/** */
createDragNode: function (layoutManager) {
var dragShape = this._buildDragShape();
return new DragTopic(dragShape, this, layoutManager);
},
/** */
createDragNode(layoutManager) {
const dragShape = this._buildDragShape();
return new DragTopic(dragShape, this, layoutManager);
},
_buildDragShape: function () {
$assert(false, '_buildDragShape must be implemented by all nodes.');
},
_buildDragShape() {
$assert(false, '_buildDragShape must be implemented by all nodes.');
},
/** */
getPosition: function () {
var model = this.getModel();
return model.getPosition();
},
}
/** */
getPosition() {
const model = this.getModel();
return model.getPosition();
},
},
);
/**
@ -199,24 +199,24 @@ const NodeGraph = new Class(
* @return {mindplot.CentralTopic|mindplot.MainTopic} the new topic
*/
NodeGraph.create = function (nodeModel, options) {
const CentralTopic = require('./CentralTopic').default;
const MainTopic = require('./MainTopic').default;
const CentralTopic = require('./CentralTopic').default;
const MainTopic = require('./MainTopic').default;
$assert(nodeModel, 'Model can not be null');
$assert(nodeModel, 'Model can not be null');
var type = nodeModel.getType();
$assert(type, 'Node model type can not be null');
const type = nodeModel.getType();
$assert(type, 'Node model type can not be null');
var result;
if (type == INodeModel.CENTRAL_TOPIC_TYPE) {
result = new CentralTopic(nodeModel, options);
} else if (type == INodeModel.MAIN_TOPIC_TYPE) {
result = new MainTopic(nodeModel, options);
} else {
$assert(false, 'unsupported node type:' + type);
}
let result;
if (type == INodeModel.CENTRAL_TOPIC_TYPE) {
result = new CentralTopic(nodeModel, options);
} else if (type == INodeModel.MAIN_TOPIC_TYPE) {
result = new MainTopic(nodeModel, options);
} else {
$assert(false, `unsupported node type:${type}`);
}
return result;
return result;
};
export default NodeGraph;

108
packages/mindplot/lib/components/NoteIcon.js
View File

@ -19,66 +19,64 @@ const Icon = require('./Icon').default;
const FloatingTip = require('./widget/FloatingTip').default;
const NoteIcon = new Class({
Extends: Icon,
initialize: function (topic, noteModel, readOnly) {
$assert(topic, 'topic can not be null');
Extends: Icon,
initialize(topic, noteModel, readOnly) {
$assert(topic, 'topic can not be null');
this.parent(NoteIcon.IMAGE_URL);
this._linksModel = noteModel;
this._topic = topic;
this._readOnly = readOnly;
this.parent(NoteIcon.IMAGE_URL);
this._linksModel = noteModel;
this._topic = topic;
this._readOnly = readOnly;
this._registerEvents();
},
this._registerEvents();
},
_registerEvents: function () {
this._image.setCursor('pointer');
var me = this;
_registerEvents() {
this._image.setCursor('pointer');
const me = this;
if (!this._readOnly) {
// Add on click event to open the editor ...
this.addEvent('click', function (event) {
me._topic.showNoteEditor();
event.stopPropagation();
});
}
this._tip = new FloatingTip($(me.getImage()._peer._native), {
title: $msg('NOTE'),
container: 'body',
// Content can also be a function of the target element!
content: function () {
return me._buildTooltipContent();
},
html: true,
placement: 'bottom',
destroyOnExit: true
});
},
_buildTooltipContent: function () {
if ($("body").find("#textPopoverNote").length == 1) {
var text = $("body").find("#textPopoverNote");
text.text(this._linksModel.getText());
} else {
var result = $('<div id="textPopoverNote"></div>').css({padding: '5px'});
var text = $('<div></div>').text(this._linksModel.getText())
.css({
'white-space': 'pre-wrap',
'word-wrap': 'break-word'
}
);
result.append(text);
return result;
}
},
getModel: function () {
return this._linksModel;
if (!this._readOnly) {
// Add on click event to open the editor ...
this.addEvent('click', (event) => {
me._topic.showNoteEditor();
event.stopPropagation();
});
}
this._tip = new FloatingTip($(me.getImage()._peer._native), {
title: $msg('NOTE'),
container: 'body',
// Content can also be a function of the target element!
content() {
return me._buildTooltipContent();
},
html: true,
placement: 'bottom',
destroyOnExit: true,
});
},
_buildTooltipContent() {
if ($('body').find('#textPopoverNote').length == 1) {
var text = $('body').find('#textPopoverNote');
text.text(this._linksModel.getText());
} else {
const result = $('<div id="textPopoverNote"></div>').css({ padding: '5px' });
var text = $('<div></div>').text(this._linksModel.getText())
.css({
'white-space': 'pre-wrap',
'word-wrap': 'break-word',
});
result.append(text);
return result;
}
},
getModel() {
return this._linksModel;
},
});
NoteIcon.IMAGE_URL = "images/notes.png";
NoteIcon.IMAGE_URL = 'images/notes.png';
export default NoteIcon
export default NoteIcon;

18
packages/mindplot/lib/components/Options.js
View File

@ -1,14 +1,16 @@
const Options = new Class({
setOptions: function () {
var options = this.options = Object.merge.apply(null, [{}, this.options].append(arguments));
if (this.addEvent) for (var option in options) {
if (typeOf(options[option]) != 'function' || !(/^on[A-Z]/).test(option)) continue;
this.addEvent(option, options[option]);
delete options[option];
}
return this;
setOptions() {
const options = this.options = Object.merge.apply(null, [{}, this.options].append(arguments));
if (this.addEvent) {
for (const option in options) {
if (typeOf(options[option]) != 'function' || !(/^on[A-Z]/).test(option)) continue;
this.addEvent(option, options[option]);
delete options[option];
}
}
return this;
},
});

87
packages/mindplot/lib/components/PersistenceManager.js
View File

@ -16,71 +16,72 @@
* limitations under the License.
*/
const Core = require('@wismapping/core-js');
const core = Core();
const XMLSerializerFactory = require('./persistence/XMLSerializerFactory');
const PersistenceManager = new Class({
Static: {
loadFromDom: function (mapId, mapDom) {
$assert(mapId, 'mapId can not be null');
$assert(mapDom, 'mapDom can not be null');
Static: {
loadFromDom(mapId, mapDom) {
$assert(mapId, 'mapId can not be null');
$assert(mapDom, 'mapDom can not be null');
var serializer = XMLSerializerFactory.getSerializerFromDocument(mapDom);
return serializer.loadFromDom(mapDom, mapId);
},
const serializer = XMLSerializerFactory.getSerializerFromDocument(mapDom);
return serializer.loadFromDom(mapDom, mapId);
},
},
initialize: function () {},
initialize() {},
save: function (mindmap, editorProperties, saveHistory, events, sync) {
$assert(mindmap, 'mindmap can not be null');
$assert(editorProperties, 'editorProperties can not be null');
save(mindmap, editorProperties, saveHistory, events, sync) {
$assert(mindmap, 'mindmap can not be null');
$assert(editorProperties, 'editorProperties can not be null');
var mapId = mindmap.getId();
$assert(mapId, 'mapId can not be null');
const mapId = mindmap.getId();
$assert(mapId, 'mapId can not be null');
var serializer = XMLSerializerFactory.getSerializerFromMindmap(mindmap);
var domMap = serializer.toXML(mindmap);
var mapXml = core.Utils.innerXML(domMap);
const serializer = XMLSerializerFactory.getSerializerFromMindmap(mindmap);
const domMap = serializer.toXML(mindmap);
const mapXml = core.Utils.innerXML(domMap);
var pref = JSON.stringify(editorProperties);
try {
this.saveMapXml(mapId, mapXml, pref, saveHistory, events, sync);
} catch (e) {
console.log(e);
events.onError(this._buildError());
}
},
const pref = JSON.stringify(editorProperties);
try {
this.saveMapXml(mapId, mapXml, pref, saveHistory, events, sync);
} catch (e) {
console.log(e);
events.onError(this._buildError());
}
},
load: function (mapId) {
$assert(mapId, 'mapId can not be null');
var domDocument = this.loadMapDom(mapId);
return PersistenceManager.loadFromDom(mapId, domDocument);
},
load(mapId) {
$assert(mapId, 'mapId can not be null');
const domDocument = this.loadMapDom(mapId);
return PersistenceManager.loadFromDom(mapId, domDocument);
},
discardChanges: function (mapId) {
throw new Error('Method must be implemented');
},
discardChanges(mapId) {
throw new Error('Method must be implemented');
},
loadMapDom: function (mapId) {
throw new Error('Method must be implemented');
},
loadMapDom(mapId) {
throw new Error('Method must be implemented');
},
saveMapXml: function (mapId, mapXml, pref, saveHistory, events, sync) {
throw new Error('Method must be implemented');
},
saveMapXml(mapId, mapXml, pref, saveHistory, events, sync) {
throw new Error('Method must be implemented');
},
unlockMap: function (mindmap) {
throw new Error('Method must be implemented');
},
unlockMap(mindmap) {
throw new Error('Method must be implemented');
},
});
PersistenceManager.init = function (instance) {
PersistenceManager._instance = instance;
PersistenceManager._instance = instance;
};
PersistenceManager.getInstance = function () {
return PersistenceManager._instance;
return PersistenceManager._instance;
};
export default PersistenceManager;

604
packages/mindplot/lib/components/Relationship.js
View File

@ -15,10 +15,12 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const Core = require('@wismapping/core-js')
const Core = require('@wismapping/core-js');
const core = Core();
const web2D = require('@wismapping/web2d')
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const ConnectionLine = require('./ConnectionLine').default;
@ -26,320 +28,310 @@ const ControlPoint = require('./ControlPoint').default;
const INodeModel = require('./model/INodeModel').default;
const Shape = require('./util/Shape').default
const Shape = require('./util/Shape').default;
const Relationship = new Class({
Extends: ConnectionLine,
Static: {
getStrokeColor: function () {
return '#9b74e6';
},
type: "Relationship"
Extends: ConnectionLine,
Static: {
getStrokeColor() {
return '#9b74e6';
},
initialize: function (sourceNode, targetNode, model) {
$assert(sourceNode, "sourceNode can not be null");
$assert(targetNode, "targetNode can not be null");
type: 'Relationship',
},
initialize(sourceNode, targetNode, model) {
$assert(sourceNode, 'sourceNode can not be null');
$assert(targetNode, 'targetNode can not be null');
this.parent(sourceNode, targetNode, model.getLineType());
this.setModel(model);
this.parent(sourceNode, targetNode, model.getLineType());
this.setModel(model);
var strokeColor = Relationship.getStrokeColor();
const strokeColor = Relationship.getStrokeColor();
this._line2d.setIsSrcControlPointCustom(false);
this._line2d.setIsDestControlPointCustom(false);
this._line2d.setCursor('pointer');
this._line2d.setStroke(1, 'solid', strokeColor);
this._line2d.setDashed(4, 2);
this._focusShape = this._createLine(this.getLineType(), ConnectionLine.SIMPLE_CURVED);
this._focusShape.setStroke(2, "solid", "#3f96ff");
this._line2d.setIsSrcControlPointCustom(false);
this._line2d.setIsDestControlPointCustom(false);
this._line2d.setCursor('pointer');
this._line2d.setStroke(1, 'solid', strokeColor);
this._line2d.setDashed(4, 2);
this._focusShape = this._createLine(this.getLineType(), ConnectionLine.SIMPLE_CURVED);
this._focusShape.setStroke(2, 'solid', '#3f96ff');
var ctrlPoints = this._line2d.getControlPoints();
this._focusShape.setSrcControlPoint(ctrlPoints[0]);
this._focusShape.setDestControlPoint(ctrlPoints[1]);
this._focusShape.setVisibility(false);
this._onFocus = false;
this._isInWorkspace = false;
this._controlPointsController = new ControlPoint();
const ctrlPoints = this._line2d.getControlPoints();
this._focusShape.setSrcControlPoint(ctrlPoints[0]);
this._focusShape.setDestControlPoint(ctrlPoints[1]);
this._focusShape.setVisibility(false);
this._onFocus = false;
this._isInWorkspace = false;
this._controlPointsController = new ControlPoint();
this._startArrow = new web2d.Arrow();
this._startArrow.setStrokeColor(strokeColor);
this._startArrow.setStrokeWidth(2);
this.setShowStartArrow(true);
this._startArrow = new web2d.Arrow();
this._startArrow.setStrokeColor(strokeColor);
this._startArrow.setStrokeWidth(2);
this.setShowStartArrow(true);
// Share style is disable ...
if (this._showEndArrow) {
this._endArrow = new web2d.Arrow();
this._endArrow.setStrokeColor(strokeColor);
this._endArrow.setStrokeWidth(2);
}
// Position the line ...
if ($defined(model.getSrcCtrlPoint())) {
var srcPoint = model.getSrcCtrlPoint().clone();
this.setSrcControlPoint(srcPoint);
}
if ($defined(model.getDestCtrlPoint())) {
var destPoint = model.getDestCtrlPoint().clone();
this.setDestControlPoint(destPoint);
}
},
setStroke: function (color, style, opacity) {
this.parent(color, style, opacity);
this._startArrow.setStrokeColor(color);
},
redraw: function () {
var line2d = this._line2d;
var sourceTopic = this._sourceTopic;
var sourcePosition = sourceTopic.getPosition();
var targetTopic = this._targetTopic;
var targetPosition = targetTopic.getPosition();
if (targetTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
targetPosition = Shape.workoutIncomingConnectionPoint(targetTopic, sourcePosition);
}
var sPos, tPos;
this._line2d.setStroke(2);
var ctrlPoints = this._line2d.getControlPoints();
if (!this._line2d.isDestControlPointCustom() && !this._line2d.isSrcControlPointCustom()) {
var defaultPoints = Shape.calculateDefaultControlPoints(sourcePosition, targetPosition);
ctrlPoints[0].x = defaultPoints[0].x;
ctrlPoints[0].y = defaultPoints[0].y;
ctrlPoints[1].x = defaultPoints[1].x;
ctrlPoints[1].y = defaultPoints[1].y;
}
var spoint = new core.Point();
spoint.x = parseInt(ctrlPoints[0].x) + parseInt(sourcePosition.x);
spoint.y = parseInt(ctrlPoints[0].y) + parseInt(sourcePosition.y);
var tpoint = new core.Point();
tpoint.x = parseInt(ctrlPoints[1].x) + parseInt(targetPosition.x);
tpoint.y = parseInt(ctrlPoints[1].y) + parseInt(targetPosition.y);
sPos = Shape.calculateRelationShipPointCoordinates(sourceTopic, spoint);
tPos = Shape.calculateRelationShipPointCoordinates(targetTopic, tpoint);
line2d.setFrom(sPos.x, sPos.y);
line2d.setTo(tPos.x, tPos.y);
line2d.moveToFront();
//Positionate Arrows
this._positionArrows();
// Add connector ...
this._positionateConnector(targetTopic);
if (this.isOnFocus()) {
this._refreshShape();
}
this._focusShape.moveToBack();
this._controlPointsController.redraw();
},
_positionArrows: function () {
var tpos = this._line2d.getTo();
var spos = this._line2d.getFrom();
this._startArrow.setFrom(spos.x, spos.y);
this._startArrow.moveToBack();
if (this._endArrow) {
this._endArrow.setFrom(tpos.x, tpos.y);
this._endArrow.moveToBack();
}
if (this._line2d.getType() == "CurvedLine") {
var controlPoints = this._line2d.getControlPoints();
this._startArrow.setControlPoint(controlPoints[0]);
if (this._endArrow) {
this._endArrow.setControlPoint(controlPoints[1]);
}
} else {
this._startArrow.setControlPoint(this._line2d.getTo());
if (this._endArrow) {
this._endArrow.setControlPoint(this._line2d.getFrom());
}
}
if (this._showEndArrow) {
this._endArrow.setVisibility(this.isVisible());
}
this._startArrow.setVisibility(this.isVisible() && this._showStartArrow);
},
addToWorkspace: function (workspace) {
workspace.append(this._focusShape);
workspace.append(this._controlPointsController);
this._controlPointControllerListener = this._initializeControlPointController.bind(this);
this._line2d.addEvent('click', this._controlPointControllerListener);
this._isInWorkspace = true;
workspace.append(this._startArrow);
if (this._endArrow)
workspace.append(this._endArrow);
this.parent(workspace);
this._positionArrows();
this.redraw();
},
_initializeControlPointController: function () {
this.setOnFocus(true);
},
removeFromWorkspace: function (workspace) {
workspace.removeChild(this._focusShape);
workspace.removeChild(this._controlPointsController);
this._line2d.removeEvent('click', this._controlPointControllerListener);
this._isInWorkspace = false;
workspace.removeChild(this._startArrow);
if (this._endArrow)
workspace.removeChild(this._endArrow);
this.parent(workspace);
},
getType: function () {
return Relationship.type;
},
setOnFocus: function (focus) {
// Change focus shape
if (this.isOnFocus() != focus) {
if (focus) {
this._refreshShape();
this._controlPointsController.setLine(this);
}
this._focusShape.setVisibility(focus);
this._controlPointsController.setVisibility(focus);
this._onFocus = focus;
this.fireEvent(focus ? 'ontfocus' : 'ontblur', this);
}
},
_refreshShape: function () {
var sPos = this._line2d.getFrom();
var tPos = this._line2d.getTo();
var ctrlPoints = this._line2d.getControlPoints();
this._focusShape.setFrom(sPos.x, sPos.y);
this._focusShape.setTo(tPos.x, tPos.y);
var shapeCtrlPoints = this._focusShape.getControlPoints();
shapeCtrlPoints[0].x = ctrlPoints[0].x;
shapeCtrlPoints[0].y = ctrlPoints[0].y;
shapeCtrlPoints[1].x = ctrlPoints[1].x;
shapeCtrlPoints[1].y = ctrlPoints[1].y;
this._focusShape.updateLine();
},
addEvent: function (type, listener) {
// Translate to web 2d events ...
if (type == 'onfocus') {
type = 'mousedown';
}
var line = this._line2d;
line.addEvent(type, listener);
},
isOnFocus: function () {
return this._onFocus;
},
isInWorkspace: function () {
return this._isInWorkspace;
},
setVisibility: function (value) {
this.parent(value);
if (this._showEndArrow)
this._endArrow.setVisibility(this._showEndArrow);
this._startArrow.setVisibility(this._showStartArrow && value);
},
setOpacity: function (opacity) {
this.parent(opacity);
if (this._showEndArrow)
this._endArrow.setOpacity(opacity);
if (this._showStartArrow)
this._startArrow.setOpacity(opacity);
},
setShowEndArrow: function (visible) {
this._showEndArrow = visible;
if (this._isInWorkspace)
this.redraw();
},
setShowStartArrow: function (visible) {
this._showStartArrow = visible;
if (this._isInWorkspace)
this.redraw();
},
setFrom: function (x, y) {
$assert($defined(x), "x must be defined");
$assert($defined(y), "y must be defined");
this._line2d.setFrom(x, y);
this._startArrow.setFrom(x, y);
},
setTo: function (x, y) {
$assert($defined(x), "x must be defined");
$assert($defined(y), "y must be defined");
this._line2d.setTo(x, y);
if (this._endArrow)
this._endArrow.setFrom(x, y);
},
setSrcControlPoint: function (control) {
this._line2d.setSrcControlPoint(control);
this._startArrow.setControlPoint(control);
},
setDestControlPoint: function (control) {
this._line2d.setDestControlPoint(control);
if (this._showEndArrow)
this._endArrow.setControlPoint(control);
},
getControlPoints: function () {
return this._line2d.getControlPoints();
},
isSrcControlPointCustom: function () {
return this._line2d.isSrcControlPointCustom();
},
isDestControlPointCustom: function () {
return this._line2d.isDestControlPointCustom();
},
setIsSrcControlPointCustom: function (isCustom) {
this._line2d.setIsSrcControlPointCustom(isCustom);
},
setIsDestControlPointCustom: function (isCustom) {
this._line2d.setIsDestControlPointCustom(isCustom);
},
getId: function () {
return this._model.getId();
},
fireEvent: function (type, event) {
var elem = this._line2d;
elem.trigger(type, event);
// Share style is disable ...
if (this._showEndArrow) {
this._endArrow = new web2d.Arrow();
this._endArrow.setStrokeColor(strokeColor);
this._endArrow.setStrokeWidth(2);
}
// Position the line ...
if ($defined(model.getSrcCtrlPoint())) {
const srcPoint = model.getSrcCtrlPoint().clone();
this.setSrcControlPoint(srcPoint);
}
if ($defined(model.getDestCtrlPoint())) {
const destPoint = model.getDestCtrlPoint().clone();
this.setDestControlPoint(destPoint);
}
},
setStroke(color, style, opacity) {
this.parent(color, style, opacity);
this._startArrow.setStrokeColor(color);
},
redraw() {
const line2d = this._line2d;
const sourceTopic = this._sourceTopic;
const sourcePosition = sourceTopic.getPosition();
const targetTopic = this._targetTopic;
let targetPosition = targetTopic.getPosition();
if (targetTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
targetPosition = Shape.workoutIncomingConnectionPoint(targetTopic, sourcePosition);
}
let sPos; let
tPos;
this._line2d.setStroke(2);
const ctrlPoints = this._line2d.getControlPoints();
if (!this._line2d.isDestControlPointCustom() && !this._line2d.isSrcControlPointCustom()) {
const defaultPoints = Shape.calculateDefaultControlPoints(sourcePosition, targetPosition);
ctrlPoints[0].x = defaultPoints[0].x;
ctrlPoints[0].y = defaultPoints[0].y;
ctrlPoints[1].x = defaultPoints[1].x;
ctrlPoints[1].y = defaultPoints[1].y;
}
const spoint = new core.Point();
spoint.x = parseInt(ctrlPoints[0].x) + parseInt(sourcePosition.x);
spoint.y = parseInt(ctrlPoints[0].y) + parseInt(sourcePosition.y);
const tpoint = new core.Point();
tpoint.x = parseInt(ctrlPoints[1].x) + parseInt(targetPosition.x);
tpoint.y = parseInt(ctrlPoints[1].y) + parseInt(targetPosition.y);
sPos = Shape.calculateRelationShipPointCoordinates(sourceTopic, spoint);
tPos = Shape.calculateRelationShipPointCoordinates(targetTopic, tpoint);
line2d.setFrom(sPos.x, sPos.y);
line2d.setTo(tPos.x, tPos.y);
line2d.moveToFront();
// Positionate Arrows
this._positionArrows();
// Add connector ...
this._positionateConnector(targetTopic);
if (this.isOnFocus()) {
this._refreshShape();
}
this._focusShape.moveToBack();
this._controlPointsController.redraw();
},
_positionArrows() {
const tpos = this._line2d.getTo();
const spos = this._line2d.getFrom();
this._startArrow.setFrom(spos.x, spos.y);
this._startArrow.moveToBack();
if (this._endArrow) {
this._endArrow.setFrom(tpos.x, tpos.y);
this._endArrow.moveToBack();
}
if (this._line2d.getType() == 'CurvedLine') {
const controlPoints = this._line2d.getControlPoints();
this._startArrow.setControlPoint(controlPoints[0]);
if (this._endArrow) {
this._endArrow.setControlPoint(controlPoints[1]);
}
} else {
this._startArrow.setControlPoint(this._line2d.getTo());
if (this._endArrow) {
this._endArrow.setControlPoint(this._line2d.getFrom());
}
}
if (this._showEndArrow) {
this._endArrow.setVisibility(this.isVisible());
}
this._startArrow.setVisibility(this.isVisible() && this._showStartArrow);
},
addToWorkspace(workspace) {
workspace.append(this._focusShape);
workspace.append(this._controlPointsController);
this._controlPointControllerListener = this._initializeControlPointController.bind(this);
this._line2d.addEvent('click', this._controlPointControllerListener);
this._isInWorkspace = true;
workspace.append(this._startArrow);
if (this._endArrow) workspace.append(this._endArrow);
this.parent(workspace);
this._positionArrows();
this.redraw();
},
_initializeControlPointController() {
this.setOnFocus(true);
},
removeFromWorkspace(workspace) {
workspace.removeChild(this._focusShape);
workspace.removeChild(this._controlPointsController);
this._line2d.removeEvent('click', this._controlPointControllerListener);
this._isInWorkspace = false;
workspace.removeChild(this._startArrow);
if (this._endArrow) workspace.removeChild(this._endArrow);
this.parent(workspace);
},
getType() {
return Relationship.type;
},
setOnFocus(focus) {
// Change focus shape
if (this.isOnFocus() != focus) {
if (focus) {
this._refreshShape();
this._controlPointsController.setLine(this);
}
this._focusShape.setVisibility(focus);
this._controlPointsController.setVisibility(focus);
this._onFocus = focus;
this.fireEvent(focus ? 'ontfocus' : 'ontblur', this);
}
},
_refreshShape() {
const sPos = this._line2d.getFrom();
const tPos = this._line2d.getTo();
const ctrlPoints = this._line2d.getControlPoints();
this._focusShape.setFrom(sPos.x, sPos.y);
this._focusShape.setTo(tPos.x, tPos.y);
const shapeCtrlPoints = this._focusShape.getControlPoints();
shapeCtrlPoints[0].x = ctrlPoints[0].x;
shapeCtrlPoints[0].y = ctrlPoints[0].y;
shapeCtrlPoints[1].x = ctrlPoints[1].x;
shapeCtrlPoints[1].y = ctrlPoints[1].y;
this._focusShape.updateLine();
},
addEvent(type, listener) {
// Translate to web 2d events ...
if (type == 'onfocus') {
type = 'mousedown';
}
const line = this._line2d;
line.addEvent(type, listener);
},
isOnFocus() {
return this._onFocus;
},
isInWorkspace() {
return this._isInWorkspace;
},
setVisibility(value) {
this.parent(value);
if (this._showEndArrow) this._endArrow.setVisibility(this._showEndArrow);
this._startArrow.setVisibility(this._showStartArrow && value);
},
setOpacity(opacity) {
this.parent(opacity);
if (this._showEndArrow) this._endArrow.setOpacity(opacity);
if (this._showStartArrow) this._startArrow.setOpacity(opacity);
},
setShowEndArrow(visible) {
this._showEndArrow = visible;
if (this._isInWorkspace) this.redraw();
},
setShowStartArrow(visible) {
this._showStartArrow = visible;
if (this._isInWorkspace) this.redraw();
},
setFrom(x, y) {
$assert($defined(x), 'x must be defined');
$assert($defined(y), 'y must be defined');
this._line2d.setFrom(x, y);
this._startArrow.setFrom(x, y);
},
setTo(x, y) {
$assert($defined(x), 'x must be defined');
$assert($defined(y), 'y must be defined');
this._line2d.setTo(x, y);
if (this._endArrow) this._endArrow.setFrom(x, y);
},
setSrcControlPoint(control) {
this._line2d.setSrcControlPoint(control);
this._startArrow.setControlPoint(control);
},
setDestControlPoint(control) {
this._line2d.setDestControlPoint(control);
if (this._showEndArrow) this._endArrow.setControlPoint(control);
},
getControlPoints() {
return this._line2d.getControlPoints();
},
isSrcControlPointCustom() {
return this._line2d.isSrcControlPointCustom();
},
isDestControlPointCustom() {
return this._line2d.isDestControlPointCustom();
},
setIsSrcControlPointCustom(isCustom) {
this._line2d.setIsSrcControlPointCustom(isCustom);
},
setIsDestControlPointCustom(isCustom) {
this._line2d.setIsDestControlPointCustom(isCustom);
},
getId() {
return this._model.getId();
},
fireEvent(type, event) {
const elem = this._line2d;
elem.trigger(type, event);
},
});
export default Relationship;

258
packages/mindplot/lib/components/RelationshipPivot.js
View File

@ -15,153 +15,151 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const Core = require('@wismapping/core-js')
const Core = require('@wismapping/core-js');
const core = Core();
const web2D = require('@wismapping/web2d')
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const INodeModel = require('./model/INodeModel').default
const INodeModel = require('./model/INodeModel').default;
const Shape = require('./util/Shape').default;
const RelationshipPivot = new Class({
initialize: function (workspace, designer) {
$assert(workspace, "workspace can not be null");
$assert(designer, "designer can not be null");
this._workspace = workspace;
this._designer = designer;
initialize(workspace, designer) {
$assert(workspace, 'workspace can not be null');
$assert(designer, 'designer can not be null');
this._workspace = workspace;
this._designer = designer;
//FIXME: the aim of the migration is remove .bind mootools method, please remove these!
this._mouseMoveEvent = this._mouseMove.bind(this);
this._onClickEvent = this._cleanOnMouseClick.bind(this);
this._onTopicClick = this._connectOnFocus.bind(this);
// FIXME: the aim of the migration is remove .bind mootools method, please remove these!
this._mouseMoveEvent = this._mouseMove.bind(this);
this._onClickEvent = this._cleanOnMouseClick.bind(this);
this._onTopicClick = this._connectOnFocus.bind(this);
},
},
start(sourceTopic, targetPos) {
$assert(sourceTopic, 'sourceTopic can not be null');
$assert(targetPos, 'targetPos can not be null');
start: function (sourceTopic, targetPos) {
$assert(sourceTopic, "sourceTopic can not be null");
$assert(targetPos, "targetPos can not be null");
this.dispose();
this._sourceTopic = sourceTopic;
if (sourceTopic != null) {
this._workspace.enableWorkspaceEvents(false);
this.dispose();
this._sourceTopic = sourceTopic;
if (sourceTopic != null) {
this._workspace.enableWorkspaceEvents(false);
const sourcePos = sourceTopic.getPosition();
const strokeColor = Relationship.getStrokeColor();
var sourcePos = sourceTopic.getPosition();
var strokeColor = Relationship.getStrokeColor();
this._pivot = new web2d.CurvedLine();
this._pivot.setStyle(web2d.CurvedLine.SIMPLE_LINE);
this._pivot = new web2d.CurvedLine();
this._pivot.setStyle(web2d.CurvedLine.SIMPLE_LINE);
const fromPos = this._calculateFromPosition(sourcePos);
this._pivot.setFrom(fromPos.x, fromPos.y);
var fromPos = this._calculateFromPosition(sourcePos);
this._pivot.setFrom(fromPos.x, fromPos.y);
this._pivot.setTo(targetPos.x, targetPos.y);
this._pivot.setStroke(2, 'solid', strokeColor);
this._pivot.setDashed(4, 2);
this._pivot.setTo(targetPos.x, targetPos.y);
this._pivot.setStroke(2, 'solid', strokeColor);
this._pivot.setDashed(4, 2);
this._startArrow = new web2d.Arrow();
this._startArrow.setStrokeColor(strokeColor);
this._startArrow.setStrokeWidth(2);
this._startArrow.setFrom(sourcePos.x, sourcePos.y);
this._startArrow = new web2d.Arrow();
this._startArrow.setStrokeColor(strokeColor);
this._startArrow.setStrokeWidth(2);
this._startArrow.setFrom(sourcePos.x, sourcePos.y);
this._workspace.append(this._pivot);
this._workspace.append(this._startArrow);
this._workspace.append(this._pivot);
this._workspace.append(this._startArrow);
this._workspace.addEvent('mousemove', this._mouseMoveEvent);
this._workspace.addEvent('click', this._onClickEvent);
this._workspace.addEvent('mousemove', this._mouseMoveEvent);
this._workspace.addEvent('click', this._onClickEvent);
// Register focus events on all topics ...
var model = this._designer.getModel();
var topics = model.getTopics();
_.each(topics, function (topic) {
topic.addEvent('ontfocus', this._onTopicClick);
}.bind(this));
}
},
dispose: function () {
var workspace = this._workspace;
if (this._isActive()) {
workspace.removeEvent('mousemove', this._mouseMoveEvent);
workspace.removeEvent('click', this._onClickEvent);
var model = this._designer.getModel();
var topics = model.getTopics();
var me = this;
_.each(topics, function (topic) {
topic.removeEvent('ontfocus', me._onTopicClick);
});
workspace.removeChild(this._pivot);
workspace.removeChild(this._startArrow);
workspace.enableWorkspaceEvents(true);
this._sourceTopic = null;
this._pivot = null;
this._startArrow = null;
}
},
_mouseMove: function (event) {
var screen = this._workspace.getScreenManager();
var pos = screen.getWorkspaceMousePosition(event);
// Leave the arrow a couple of pixels away from the cursor.
var sourcePosition = this._sourceTopic.getPosition();
var gapDistance = Math.sign(pos.x - sourcePosition.x) * 5;
var sPos = this._calculateFromPosition(pos);
this._pivot.setFrom(sPos.x, sPos.y);
// Update target position ...
this._pivot.setTo(pos.x - gapDistance, pos.y);
var controlPoints = this._pivot.getControlPoints();
this._startArrow.setFrom(pos.x - gapDistance, pos.y);
this._startArrow.setControlPoint(controlPoints[1]);
event.stopPropagation();
return false;
},
_cleanOnMouseClick: function (event) {
// The user clicks on a desktop on in other element that is not a node.
this.dispose();
event.stopPropagation();
},
_calculateFromPosition: function (toPosition) {
// Calculate origin position ...
var sourcePosition = this._sourceTopic.getPosition();
if (this._sourceTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
sourcePosition = Shape.workoutIncomingConnectionPoint(this._sourceTopic, toPosition);
}
var controlPoint = Shape.calculateDefaultControlPoints(sourcePosition, toPosition);
var spoint = new core.Point();
spoint.x = parseInt(controlPoint[0].x) + parseInt(sourcePosition.x);
spoint.y = parseInt(controlPoint[0].y) + parseInt(sourcePosition.y);
return Shape.calculateRelationShipPointCoordinates(this._sourceTopic, spoint);
},
_connectOnFocus: function (event, targetTopic) {
var sourceTopic = this._sourceTopic;
var mindmap = this._designer.getMindmap();
// Avoid circular connections ...
if (targetTopic.getId() != sourceTopic.getId()) {
var relModel = mindmap.createRelationship(targetTopic.getId(), sourceTopic.getId());
this._designer._actionDispatcher.addRelationship(relModel);
}
this.dispose();
},
_isActive: function () {
return this._pivot != null;
// Register focus events on all topics ...
const model = this._designer.getModel();
const topics = model.getTopics();
_.each(topics, (topic) => {
topic.addEvent('ontfocus', this._onTopicClick);
});
}
},
dispose() {
const workspace = this._workspace;
if (this._isActive()) {
workspace.removeEvent('mousemove', this._mouseMoveEvent);
workspace.removeEvent('click', this._onClickEvent);
const model = this._designer.getModel();
const topics = model.getTopics();
const me = this;
_.each(topics, (topic) => {
topic.removeEvent('ontfocus', me._onTopicClick);
});
workspace.removeChild(this._pivot);
workspace.removeChild(this._startArrow);
workspace.enableWorkspaceEvents(true);
this._sourceTopic = null;
this._pivot = null;
this._startArrow = null;
}
},
_mouseMove(event) {
const screen = this._workspace.getScreenManager();
const pos = screen.getWorkspaceMousePosition(event);
// Leave the arrow a couple of pixels away from the cursor.
const sourcePosition = this._sourceTopic.getPosition();
const gapDistance = Math.sign(pos.x - sourcePosition.x) * 5;
const sPos = this._calculateFromPosition(pos);
this._pivot.setFrom(sPos.x, sPos.y);
// Update target position ...
this._pivot.setTo(pos.x - gapDistance, pos.y);
const controlPoints = this._pivot.getControlPoints();
this._startArrow.setFrom(pos.x - gapDistance, pos.y);
this._startArrow.setControlPoint(controlPoints[1]);
event.stopPropagation();
return false;
},
_cleanOnMouseClick(event) {
// The user clicks on a desktop on in other element that is not a node.
this.dispose();
event.stopPropagation();
},
_calculateFromPosition(toPosition) {
// Calculate origin position ...
let sourcePosition = this._sourceTopic.getPosition();
if (this._sourceTopic.getType() == INodeModel.CENTRAL_TOPIC_TYPE) {
sourcePosition = Shape.workoutIncomingConnectionPoint(this._sourceTopic, toPosition);
}
const controlPoint = Shape.calculateDefaultControlPoints(sourcePosition, toPosition);
const spoint = new core.Point();
spoint.x = parseInt(controlPoint[0].x) + parseInt(sourcePosition.x);
spoint.y = parseInt(controlPoint[0].y) + parseInt(sourcePosition.y);
return Shape.calculateRelationShipPointCoordinates(this._sourceTopic, spoint);
},
_connectOnFocus(event, targetTopic) {
const sourceTopic = this._sourceTopic;
const mindmap = this._designer.getMindmap();
// Avoid circular connections ...
if (targetTopic.getId() != sourceTopic.getId()) {
const relModel = mindmap.createRelationship(targetTopic.getId(), sourceTopic.getId());
this._designer._actionDispatcher.addRelationship(relModel);
}
this.dispose();
},
_isActive() {
return this._pivot != null;
},
});
export default RelationshipPivot;

269
packages/mindplot/lib/components/RestPersistenceManager.js
View File

@ -18,149 +18,142 @@
const PersistenceManager = require('./PersistenceManager').default;
const RESTPersistenceManager = new Class({
Extends: PersistenceManager,
initialize: function (options) {
this.parent();
$assert(options.documentUrl, "documentUrl can not be null");
$assert(options.revertUrl, "revertUrl can not be null");
$assert(options.lockUrl, "lockUrl can not be null");
$assert(options.session, "session can not be null");
$assert(options.timestamp, "timestamp can not be null");
Extends: PersistenceManager,
initialize(options) {
this.parent();
$assert(options.documentUrl, 'documentUrl can not be null');
$assert(options.revertUrl, 'revertUrl can not be null');
$assert(options.lockUrl, 'lockUrl can not be null');
$assert(options.session, 'session can not be null');
$assert(options.timestamp, 'timestamp can not be null');
this.documentUrl = options.documentUrl;
this.revertUrl = options.revertUrl;
this.lockUrl = options.lockUrl;
this.timestamp = options.timestamp;
this.session = options.session;
this.documentUrl = options.documentUrl;
this.revertUrl = options.revertUrl;
this.lockUrl = options.lockUrl;
this.timestamp = options.timestamp;
this.session = options.session;
},
saveMapXml(mapId, mapXml, pref, saveHistory, events, sync) {
const data = {
id: mapId,
xml: mapXml,
properties: pref,
};
const persistence = this;
let query = `minor=${!saveHistory}`;
query = `${query}&timestamp=${this.timestamp}`;
query = `${query}&session=${this.session}`;
if (!persistence.onSave) {
// Mark save in process and fire a event unlocking the save ...
persistence.onSave = true;
persistence.clearTimeout = setTimeout(() => {
persistence.clearTimeout = null;
persistence.onSave = false;
}, 10000);
$.ajax({
url: `${this.documentUrl.replace('{id}', mapId)}?${query}`,
type: 'put',
dataType: 'json',
data: JSON.stringify(data),
contentType: 'application/json; charset=utf-8',
async: !sync,
success(data, textStatus, jqXHRresponseText) {
persistence.timestamp = data;
events.onSuccess();
},
error(jqXHR, textStatus, errorThrown) {
events.onError(persistence._buildError());
},
complete() {
// Clear event timeout ...
if (persistence.clearTimeout) {
clearTimeout(persistence.clearTimeout);
}
persistence.onSave = false;
},
fail(xhr, textStatus) {
const { responseText } = xhr;
let userMsg = { severity: 'SEVERE', message: $msg('SAVE_COULD_NOT_BE_COMPLETED') };
saveMapXml: function (mapId, mapXml, pref, saveHistory, events, sync) {
var data = {
id: mapId,
xml: mapXml,
properties: pref
};
var persistence = this;
var query = "minor=" + !saveHistory;
query = query + "&timestamp=" + this.timestamp;
query = query + "&session=" + this.session;
if (!persistence.onSave) {
// Mark save in process and fire a event unlocking the save ...
persistence.onSave = true;
persistence.clearTimeout = setTimeout(function () {
persistence.clearTimeout = null;
persistence.onSave = false;
}, 10000);
$.ajax({
url: this.documentUrl.replace("{id}", mapId) + "?" + query,
type: 'put',
dataType: "json",
data: JSON.stringify(data),
contentType: "application/json; charset=utf-8",
async: !sync,
success: function (data, textStatus, jqXHRresponseText) {
persistence.timestamp = data;
events.onSuccess();
},
error: function (jqXHR, textStatus, errorThrown) {
events.onError(persistence._buildError());
},
complete: function () {
// Clear event timeout ...
if (persistence.clearTimeout) {
clearTimeout(persistence.clearTimeout);
}
persistence.onSave = false;
},
fail: function (xhr, textStatus) {
var responseText = xhr.responseText;
var userMsg = {severity: "SEVERE", message: $msg('SAVE_COULD_NOT_BE_COMPLETED')};
var contentType = xhr.getResponseHeader("Content-Type");
if (contentType != null && contentType.indexOf("application/json") != -1) {
var serverMsg = null;
try {
serverMsg = $.parseJSON(responseText);
serverMsg = serverMsg.globalSeverity ? serverMsg : null;
} catch (e) {
// Message could not be decoded ...
}
userMsg = persistence._buildError(serverMsg);
} else {
if (this.status == 405) {
userMsg = {severity: "SEVERE", message: $msg('SESSION_EXPIRED')};
}
}
events.onError(userMsg);
persistence.onSave = false;
}
});
const contentType = xhr.getResponseHeader('Content-Type');
if (contentType != null && contentType.indexOf('application/json') != -1) {
let serverMsg = null;
try {
serverMsg = $.parseJSON(responseText);
serverMsg = serverMsg.globalSeverity ? serverMsg : null;
} catch (e) {
// Message could not be decoded ...
}
userMsg = persistence._buildError(serverMsg);
} else if (this.status == 405) {
userMsg = { severity: 'SEVERE', message: $msg('SESSION_EXPIRED') };
}
events.onError(userMsg);
persistence.onSave = false;
},
discardChanges: function (mapId) {
$.ajax({
url: this.revertUrl.replace("{id}", mapId),
async: false,
method: 'post',
headers: {"Content-Type": "application/json; charset=utf-8", "Accept": "application/json"}
});
},
unlockMap: function (mindmap) {
var mapId = mindmap.getId();
$.ajax({
url: this.lockUrl.replace("{id}", mapId),
async: false,
method: 'put',
headers: {"Content-Type": "text/plain"},
data: "false"
});
},
_buildError: function (jsonSeverResponse) {
var message = jsonSeverResponse ? jsonSeverResponse.globalErrors[0] : null;
var severity = jsonSeverResponse ? jsonSeverResponse.globalSeverity : null;
if (!message) {
message = $msg('SAVE_COULD_NOT_BE_COMPLETED');
}
if (!severity) {
severity = "INFO";
}
return {severity: severity, message: message};
},
loadMapDom: function (mapId) {
// Let's try to open one from the local directory ...
var xml;
$.ajax({
url: this.documentUrl.replace("{id}", mapId) + "/xml",
method: 'get',
async: false,
headers: {"Content-Type": "text/plain", "Accept": "application/xml"},
success: function (responseText) {
xml = responseText;
}
});
// If I could not load it from a file, hard code one.
if (xml == null) {
throw new Error("Map could not be loaded");
}
return xml;
}
});
}
);
},
discardChanges(mapId) {
$.ajax({
url: this.revertUrl.replace('{id}', mapId),
async: false,
method: 'post',
headers: { 'Content-Type': 'application/json; charset=utf-8', Accept: 'application/json' },
});
},
unlockMap(mindmap) {
const mapId = mindmap.getId();
$.ajax({
url: this.lockUrl.replace('{id}', mapId),
async: false,
method: 'put',
headers: { 'Content-Type': 'text/plain' },
data: 'false',
});
},
_buildError(jsonSeverResponse) {
let message = jsonSeverResponse ? jsonSeverResponse.globalErrors[0] : null;
let severity = jsonSeverResponse ? jsonSeverResponse.globalSeverity : null;
if (!message) {
message = $msg('SAVE_COULD_NOT_BE_COMPLETED');
}
if (!severity) {
severity = 'INFO';
}
return { severity, message };
},
loadMapDom(mapId) {
// Let's try to open one from the local directory ...
let xml;
$.ajax({
url: `${this.documentUrl.replace('{id}', mapId)}/xml`,
method: 'get',
async: false,
headers: { 'Content-Type': 'text/plain', Accept: 'application/xml' },
success(responseText) {
xml = responseText;
},
});
// If I could not load it from a file, hard code one.
if (xml == null) {
throw new Error('Map could not be loaded');
}
return xml;
},
});
export default RESTPersistenceManager;

243
packages/mindplot/lib/components/ScreenManager.js
View File

@ -16,138 +16,135 @@
* limitations under the License.
*/
const Core = require('@wismapping/core-js');
const core = Core();
const ScreenManager = new Class({
initialize: function (divElement) {
$assert(divElement, "can not be null");
this._divContainer = divElement;
this._padding = {x: 0, y: 0};
initialize(divElement) {
$assert(divElement, 'can not be null');
this._divContainer = divElement;
this._padding = { x: 0, y: 0 };
// Ignore default click event propagation. Prevent 'click' event on drag.
this._clickEvents = [];
this._divContainer.bind('click', function (event) {
event.stopPropagation()
});
// Ignore default click event propagation. Prevent 'click' event on drag.
this._clickEvents = [];
this._divContainer.bind('click', (event) => {
event.stopPropagation();
});
this._divContainer.bind('dblclick', function (event) {
event.stopPropagation();
event.preventDefault();
});
},
this._divContainer.bind('dblclick', (event) => {
event.stopPropagation();
event.preventDefault();
});
},
setScale: function (scale) {
$assert(scale, 'Screen scale can not be null');
this._scale = scale;
},
setScale(scale) {
$assert(scale, 'Screen scale can not be null');
this._scale = scale;
},
addEvent: function (event, listener) {
if (event == 'click')
this._clickEvents.push(listener);
else
this._divContainer.bind(event, listener);
},
addEvent(event, listener) {
if (event == 'click') this._clickEvents.push(listener);
else this._divContainer.bind(event, listener);
},
removeEvent: function (event, listener) {
if (event == 'click') {
this._clickEvents.remove(listener);
}
else {
this._divContainer.unbind(event, listener);
}
},
fireEvent: function (type, event) {
if (type == 'click') {
_.each(this._clickEvents, function (listener) {
listener(type, event);
});
}
else {
this._divContainer.trigger(type, event);
}
},
_getElementPosition: function (elem) {
// Retrieve current element position.
var elementPosition = elem.getPosition();
var x = elementPosition.x;
var y = elementPosition.y;
// Add workspace offset.
x = x - this._padding.x;
y = y - this._padding.y;
// Scale coordinate in order to be relative to the workspace. That's coord/size;
x = x / this._scale;
y = y / this._scale;
// Remove decimal part..
return {x: x, y: y};
},
getWorkspaceIconPosition: function (e) {
// Retrieve current icon position.
var image = e.getImage();
var elementPosition = image.getPosition();
var imageSize = e.getSize();
//Add group offset
var iconGroup = e.getGroup();
var group = iconGroup.getNativeElement();
var coordOrigin = group.getCoordOrigin();
var groupSize = group.getSize();
var coordSize = group.getCoordSize();
var scale = {x: coordSize.width / parseInt(groupSize.width), y: coordSize.height / parseInt(groupSize.height)};
var x = (elementPosition.x - coordOrigin.x - (parseInt(imageSize.width) / 2)) / scale.x;
var y = (elementPosition.y - coordOrigin.y - (parseInt(imageSize.height) / 2)) / scale.y;
//Retrieve iconGroup Position
var groupPosition = iconGroup.getPosition();
x = x + groupPosition.x;
y = y + groupPosition.y;
//Retrieve topic Position
var topic = iconGroup.getTopic();
var topicPosition = this._getElementPosition(topic);
topicPosition.x = topicPosition.x - (parseInt(topic.getSize().width) / 2);
// Remove decimal part..
return {x: x + topicPosition.x, y: y + topicPosition.y};
},
getWorkspaceMousePosition: function (event) {
// Retrieve current mouse position.
var x = event.clientX;
var y = event.clientY;
//FIXME: paulo: why? Subtract div position.
/*var containerPosition = this.getContainer().position();
x = x - containerPosition.x;
y = y - containerPosition.y;*/
// Scale coordinate in order to be relative to the workspace. That's coordSize/size;
x = x * this._scale;
y = y * this._scale;
// Add workspace offset.
x = x + this._padding.x;
y = y + this._padding.y;
// Remove decimal part..
return new core.Point(x, y);
},
getContainer: function () {
return this._divContainer;
},
setOffset: function (x, y) {
this._padding.x = x;
this._padding.y = y;
removeEvent(event, listener) {
if (event == 'click') {
this._clickEvents.remove(listener);
} else {
this._divContainer.unbind(event, listener);
}
},
fireEvent(type, event) {
if (type == 'click') {
_.each(this._clickEvents, (listener) => {
listener(type, event);
});
} else {
this._divContainer.trigger(type, event);
}
},
_getElementPosition(elem) {
// Retrieve current element position.
const elementPosition = elem.getPosition();
let { x } = elementPosition;
let { y } = elementPosition;
// Add workspace offset.
x -= this._padding.x;
y -= this._padding.y;
// Scale coordinate in order to be relative to the workspace. That's coord/size;
x /= this._scale;
y /= this._scale;
// Remove decimal part..
return { x, y };
},
getWorkspaceIconPosition(e) {
// Retrieve current icon position.
const image = e.getImage();
const elementPosition = image.getPosition();
const imageSize = e.getSize();
// Add group offset
const iconGroup = e.getGroup();
const group = iconGroup.getNativeElement();
const coordOrigin = group.getCoordOrigin();
const groupSize = group.getSize();
const coordSize = group.getCoordSize();
const scale = { x: coordSize.width / parseInt(groupSize.width), y: coordSize.height / parseInt(groupSize.height) };
let x = (elementPosition.x - coordOrigin.x - (parseInt(imageSize.width) / 2)) / scale.x;
let y = (elementPosition.y - coordOrigin.y - (parseInt(imageSize.height) / 2)) / scale.y;
// Retrieve iconGroup Position
const groupPosition = iconGroup.getPosition();
x += groupPosition.x;
y += groupPosition.y;
// Retrieve topic Position
const topic = iconGroup.getTopic();
const topicPosition = this._getElementPosition(topic);
topicPosition.x -= (parseInt(topic.getSize().width) / 2);
// Remove decimal part..
return { x: x + topicPosition.x, y: y + topicPosition.y };
},
getWorkspaceMousePosition(event) {
// Retrieve current mouse position.
let x = event.clientX;
let y = event.clientY;
// FIXME: paulo: why? Subtract div position.
/* var containerPosition = this.getContainer().position();
x = x - containerPosition.x;
y = y - containerPosition.y; */
// Scale coordinate in order to be relative to the workspace. That's coordSize/size;
x *= this._scale;
y *= this._scale;
// Add workspace offset.
x += this._padding.x;
y += this._padding.y;
// Remove decimal part..
return new core.Point(x, y);
},
getContainer() {
return this._divContainer;
},
setOffset(x, y) {
this._padding.x = x;
this._padding.y = y;
},
});
export default ScreenManager;

157
packages/mindplot/lib/components/ShrinkConnector.js
View File

@ -15,100 +15,97 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const web2D = require('@wismapping/web2d')
const web2D = require('@wismapping/web2d');
const web2d = web2D();
const Topic = require('./Topic').default
const Topic = require('./Topic').default;
const ActionDispatcher = require('./ActionDispatcher').default;
const ShirinkConnector = new Class({
initialize: function (topic) {
initialize(topic) {
const ellipse = new web2D.Elipse(Topic.prototype.INNER_RECT_ATTRIBUTES);
this._ellipse = ellipse;
ellipse.setFill('rgb(62,118,179)');
var ellipse = new web2D.Elipse(Topic.prototype.INNER_RECT_ATTRIBUTES);
this._ellipse = ellipse;
ellipse.setFill('rgb(62,118,179)');
ellipse.setSize(Topic.CONNECTOR_WIDTH, Topic.CONNECTOR_WIDTH);
ellipse.addEvent('click', (event) => {
const model = topic.getModel();
const collapse = !model.areChildrenShrunken();
ellipse.setSize(Topic.CONNECTOR_WIDTH, Topic.CONNECTOR_WIDTH);
ellipse.addEvent('click', function (event) {
var model = topic.getModel();
var collapse = !model.areChildrenShrunken();
const topicId = topic.getId();
const actionDispatcher = ActionDispatcher.getInstance();
actionDispatcher.shrinkBranch([topicId], collapse);
var topicId = topic.getId();
var actionDispatcher = ActionDispatcher.getInstance();
actionDispatcher.shrinkBranch([topicId], collapse);
event.stopPropagation();
});
event.stopPropagation();
ellipse.addEvent('mousedown', (event) => {
// Avoid node creation ...
event.stopPropagation();
});
});
ellipse.addEvent('dblclick', (event) => {
// Avoid node creation ...
event.stopPropagation();
});
ellipse.addEvent('mousedown', function (event) {
// Avoid node creation ...
event.stopPropagation();
});
ellipse.addEvent('mouseover', (event) => {
ellipse.setFill('rgb(153, 0, 255)');
});
const me = this;
ellipse.addEvent('mouseout', (event) => {
const color = topic.getBackgroundColor();
me.setFill(color);
});
ellipse.addEvent('dblclick', function (event) {
// Avoid node creation ...
event.stopPropagation();
});
ellipse.setCursor('default');
this._fillColor = '#f7f7f7';
const model = topic.getModel();
this.changeRender(model.areChildrenShrunken());
},
ellipse.addEvent('mouseover', function (event) {
ellipse.setFill('rgb(153, 0, 255)');
});
var me = this;
ellipse.addEvent('mouseout', function (event) {
var color = topic.getBackgroundColor();
me.setFill(color);
});
ellipse.setCursor('default');
this._fillColor = '#f7f7f7';
var model = topic.getModel();
this.changeRender(model.areChildrenShrunken());
},
changeRender: function (isShrink) {
var elipse = this._ellipse;
if (isShrink) {
elipse.setStroke('2', 'solid');
} else {
elipse.setStroke('1', 'solid');
}
},
setVisibility: function (value) {
this._ellipse.setVisibility(value);
},
setOpacity: function (opacity) {
this._ellipse.setOpacity(opacity);
},
setFill: function (color) {
this._fillColor = color;
this._ellipse.setFill(color);
},
setAttribute: function (name, value) {
this._ellipse.setAttribute(name, value);
},
addToWorkspace: function (group) {
group.append(this._ellipse);
},
setPosition: function (x, y) {
this._ellipse.setPosition(x, y);
},
moveToBack: function () {
this._ellipse.moveToBack();
},
moveToFront: function () {
this._ellipse.moveToFront();
changeRender(isShrink) {
const elipse = this._ellipse;
if (isShrink) {
elipse.setStroke('2', 'solid');
} else {
elipse.setStroke('1', 'solid');
}
},
setVisibility(value) {
this._ellipse.setVisibility(value);
},
setOpacity(opacity) {
this._ellipse.setOpacity(opacity);
},
setFill(color) {
this._fillColor = color;
this._ellipse.setFill(color);
},
setAttribute(name, value) {
this._ellipse.setAttribute(name, value);
},
addToWorkspace(group) {
group.append(this._ellipse);
},
setPosition(x, y) {
this._ellipse.setPosition(x, y);
},
moveToBack() {
this._ellipse.moveToBack();
},
moveToFront() {
this._ellipse.moveToFront();
},
});
export default ShirinkConnector;

554
packages/mindplot/lib/components/StandaloneActionDispatcher.js
View File

@ -29,353 +29,347 @@ const ChangeFeatureToTopicCommand = require('./commands/ChangeFeatureToTopicComm
const NodeModel = require('./model/NodeModel').default;
const StandaloneActionDispatcher = new Class(
/** @lends StandaloneActionDispatcher */ {
Extends: ActionDispatcher,
/**
/** @lends StandaloneActionDispatcher */ {
Extends: ActionDispatcher,
/**
* @extends mindplot.ActionDispatcher
* @constructs
* @param {mindplot.CommandContext} commandContext
*/
initialize: function (commandContext) {
this.parent(commandContext);
this._actionRunner = new DesignerActionRunner(commandContext, this);
},
initialize(commandContext) {
this.parent(commandContext);
this._actionRunner = new DesignerActionRunner(commandContext, this);
},
/** */
addTopics: function (models, parentTopicsId) {
var command = new AddTopicCommand(models, parentTopicsId);
this.execute(command);
},
/** */
addTopics(models, parentTopicsId) {
const command = new AddTopicCommand(models, parentTopicsId);
this.execute(command);
},
/** */
addRelationship: function (model) {
var command = new AddRelationshipCommand(model);
this.execute(command);
},
/** */
addRelationship(model) {
const command = new AddRelationshipCommand(model);
this.execute(command);
},
/** */
deleteEntities: function (topicsIds, relIds) {
var command = new DeleteCommand(topicsIds, relIds);
this.execute(command);
},
/** */
deleteEntities(topicsIds, relIds) {
const command = new DeleteCommand(topicsIds, relIds);
this.execute(command);
},
/** */
dragTopic: function (topicId, position, order, parentTopic) {
var command = new DragTopicCommand(topicId, position, order, parentTopic);
this.execute(command);
},
/** */
dragTopic(topicId, position, order, parentTopic) {
const command = new DragTopicCommand(topicId, position, order, parentTopic);
this.execute(command);
},
/** */
moveTopic: function (topicId, position) {
$assert($defined(topicId), 'topicsId can not be null');
$assert($defined(position), 'position can not be null');
/** */
moveTopic(topicId, position) {
$assert($defined(topicId), 'topicsId can not be null');
$assert($defined(position), 'position can not be null');
var commandFunc = function (topic, value) {
var result = topic.getPosition();
EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
node: topic.getModel(),
position: value,
});
return result;
};
const commandFunc = function (topic, value) {
const result = topic.getPosition();
EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
node: topic.getModel(),
position: value,
});
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicId, position);
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicId, position);
this.execute(command);
},
/** */
moveControlPoint: function (ctrlPoint, point) {
var command = new MoveControlPointCommand(ctrlPoint, point);
this.execute(command);
},
/** */
moveControlPoint(ctrlPoint, point) {
const command = new MoveControlPointCommand(ctrlPoint, point);
this.execute(command);
},
/** */
changeFontStyleToTopic: function (topicsIds) {
var commandFunc = function (topic) {
var result = topic.getFontStyle();
var style = result == 'italic' ? 'normal' : 'italic';
topic.setFontStyle(style, true);
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicsIds);
this.execute(command);
},
/** */
changeFontStyleToTopic(topicsIds) {
const commandFunc = function (topic) {
const result = topic.getFontStyle();
const style = result == 'italic' ? 'normal' : 'italic';
topic.setFontStyle(style, true);
return result;
};
const command = new GenericFunctionCommand(commandFunc, topicsIds);
this.execute(command);
},
/** */
changeTextToTopic: function (topicsIds, text) {
$assert($defined(topicsIds), 'topicsIds can not be null');
/** */
changeTextToTopic(topicsIds, text) {
$assert($defined(topicsIds), 'topicsIds can not be null');
var commandFunc = function (topic, value) {
var result = topic.getText();
topic.setText(value);
return result;
};
commandFunc.commandType = 'changeTextToTopic';
const commandFunc = function (topic, value) {
const result = topic.getText();
topic.setText(value);
return result;
};
commandFunc.commandType = 'changeTextToTopic';
var command = new GenericFunctionCommand(commandFunc, topicsIds, text);
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicsIds, text);
this.execute(command);
},
/** */
changeFontFamilyToTopic: function (topicIds, fontFamily) {
$assert(topicIds, 'topicIds can not be null');
$assert(fontFamily, 'fontFamily can not be null');
/** */
changeFontFamilyToTopic(topicIds, fontFamily) {
$assert(topicIds, 'topicIds can not be null');
$assert(fontFamily, 'fontFamily can not be null');
var commandFunc = function (topic, fontFamily) {
var result = topic.getFontFamily();
topic.setFontFamily(fontFamily, true);
const commandFunc = function (topic, fontFamily) {
const result = topic.getFontFamily();
topic.setFontFamily(fontFamily, true);
topic._adjustShapes();
return result;
};
topic._adjustShapes();
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicIds, fontFamily);
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicIds, fontFamily);
this.execute(command);
},
/** */
changeFontColorToTopic: function (topicsIds, color) {
$assert(topicsIds, 'topicIds can not be null');
$assert(color, 'color can not be null');
/** */
changeFontColorToTopic(topicsIds, color) {
$assert(topicsIds, 'topicIds can not be null');
$assert(color, 'color can not be null');
var commandFunc = function (topic, color) {
var result = topic.getFontColor();
topic.setFontColor(color, true);
return result;
};
const commandFunc = function (topic, color) {
const result = topic.getFontColor();
topic.setFontColor(color, true);
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicsIds, color);
command.discardDuplicated = 'fontColorCommandId';
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
command.discardDuplicated = 'fontColorCommandId';
this.execute(command);
},
/** */
changeBackgroundColorToTopic: function (topicsIds, color) {
$assert(topicsIds, 'topicIds can not be null');
$assert(color, 'color can not be null');
/** */
changeBackgroundColorToTopic(topicsIds, color) {
$assert(topicsIds, 'topicIds can not be null');
$assert(color, 'color can not be null');
var commandFunc = function (topic, color) {
var result = topic.getBackgroundColor();
topic.setBackgroundColor(color);
return result;
};
const commandFunc = function (topic, color) {
const result = topic.getBackgroundColor();
topic.setBackgroundColor(color);
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicsIds, color);
command.discardDuplicated = 'backColor';
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
command.discardDuplicated = 'backColor';
this.execute(command);
},
/** */
changeBorderColorToTopic: function (topicsIds, color) {
$assert(topicsIds, 'topicIds can not be null');
$assert(color, 'topicIds can not be null');
/** */
changeBorderColorToTopic(topicsIds, color) {
$assert(topicsIds, 'topicIds can not be null');
$assert(color, 'topicIds can not be null');
var commandFunc = function (topic, color) {
var result = topic.getBorderColor();
topic.setBorderColor(color);
return result;
};
const commandFunc = function (topic, color) {
const result = topic.getBorderColor();
topic.setBorderColor(color);
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicsIds, color);
command.discardDuplicated = 'borderColorCommandId';
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
command.discardDuplicated = 'borderColorCommandId';
this.execute(command);
},
/** */
changeFontSizeToTopic: function (topicsIds, size) {
$assert(topicsIds, 'topicIds can not be null');
$assert(size, 'size can not be null');
/** */
changeFontSizeToTopic(topicsIds, size) {
$assert(topicsIds, 'topicIds can not be null');
$assert(size, 'size can not be null');
var commandFunc = function (topic, size) {
var result = topic.getFontSize();
topic.setFontSize(size, true);
const commandFunc = function (topic, size) {
const result = topic.getFontSize();
topic.setFontSize(size, true);
topic._adjustShapes();
return result;
};
topic._adjustShapes();
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicsIds, size);
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicsIds, size);
this.execute(command);
},
/** */
changeShapeTypeToTopic: function (topicsIds, shapeType) {
$assert(topicsIds, 'topicsIds can not be null');
$assert(shapeType, 'shapeType can not be null');
/** */
changeShapeTypeToTopic(topicsIds, shapeType) {
$assert(topicsIds, 'topicsIds can not be null');
$assert(shapeType, 'shapeType can not be null');
var commandFunc = function (topic, shapeType) {
var result = topic.getShapeType();
topic.setShapeType(shapeType, true);
return result;
};
const commandFunc = function (topic, shapeType) {
const result = topic.getShapeType();
topic.setShapeType(shapeType, true);
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicsIds, shapeType);
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicsIds, shapeType);
this.execute(command);
},
/** */
changeFontWeightToTopic: function (topicsIds) {
$assert(topicsIds, 'topicsIds can not be null');
/** */
changeFontWeightToTopic(topicsIds) {
$assert(topicsIds, 'topicsIds can not be null');
var commandFunc = function (topic) {
var result = topic.getFontWeight();
var weight = result == 'bold' ? 'normal' : 'bold';
topic.setFontWeight(weight, true);
const commandFunc = function (topic) {
const result = topic.getFontWeight();
const weight = result == 'bold' ? 'normal' : 'bold';
topic.setFontWeight(weight, true);
topic._adjustShapes();
return result;
};
topic._adjustShapes();
return result;
};
var command = new GenericFunctionCommand(commandFunc, topicsIds);
this.execute(command);
},
const command = new GenericFunctionCommand(commandFunc, topicsIds);
this.execute(command);
},
/** */
shrinkBranch: function (topicsIds, collapse) {
$assert(topicsIds, 'topicsIds can not be null');
/** */
shrinkBranch(topicsIds, collapse) {
$assert(topicsIds, 'topicsIds can not be null');
var commandFunc = function (topic, isShrink) {
topic.setChildrenShrunken(isShrink);
return !isShrink;
};
const commandFunc = function (topic, isShrink) {
topic.setChildrenShrunken(isShrink);
return !isShrink;
};
var command = new GenericFunctionCommand(commandFunc, topicsIds, collapse);
this.execute(command, false);
},
const command = new GenericFunctionCommand(commandFunc, topicsIds, collapse);
this.execute(command, false);
},
/** */
addFeatureToTopic: function (topicId, featureType, attributes) {
var command = new AddFeatureToTopicCommand(topicId, featureType, attributes);
this.execute(command);
},
/** */
addFeatureToTopic(topicId, featureType, attributes) {
const command = new AddFeatureToTopicCommand(topicId, featureType, attributes);
this.execute(command);
},
/** */
changeFeatureToTopic: function (topicId, featureId, attributes) {
var command = new ChangeFeatureToTopicCommand(topicId, featureId, attributes);
this.execute(command);
},
/** */
changeFeatureToTopic(topicId, featureId, attributes) {
const command = new ChangeFeatureToTopicCommand(topicId, featureId, attributes);
this.execute(command);
},
/** */
removeFeatureFromTopic: function (topicId, featureId) {
var command = new RemoveFeatureFromTopicCommand(topicId, featureId);
this.execute(command);
},
/** */
removeFeatureFromTopic(topicId, featureId) {
const command = new RemoveFeatureFromTopicCommand(topicId, featureId);
this.execute(command);
},
/** */
execute: function (command) {
this._actionRunner.execute(command);
},
}
/** */
execute(command) {
this._actionRunner.execute(command);
},
},
);
const CommandContext = new Class(
/** @lends CommandContext */ {
/**
/** @lends CommandContext */ {
/**
* @constructs
* @param {mindplot.Designer} designer
*/
initialize: function (designer) {
$assert(designer, 'designer can not be null');
this._designer = designer;
},
initialize(designer) {
$assert(designer, 'designer can not be null');
this._designer = designer;
},
/** */
findTopics: function (topicsIds) {
$assert($defined(topicsIds), 'topicsIds can not be null');
if (!(topicsIds instanceof Array)) {
topicsIds = [topicsIds];
}
/** */
findTopics(topicsIds) {
$assert($defined(topicsIds), 'topicsIds can not be null');
if (!(topicsIds instanceof Array)) {
topicsIds = [topicsIds];
}
var designerTopics = this._designer.getModel().getTopics();
var result = designerTopics.filter(function (topic) {
return topicsIds.contains(topic.getId());
});
const designerTopics = this._designer.getModel().getTopics();
const result = designerTopics.filter((topic) => topicsIds.contains(topic.getId()));
if (result.length != topicsIds.length) {
var ids = designerTopics.map(function (topic) {
return topic.getId();
});
$assert(
result.length == topicsIds.length,
'Could not find topic. Result:' +
result +
', Filter Criteria:' +
topicsIds +
', Current Topics: [' +
ids +
']'
);
}
return result;
},
if (result.length != topicsIds.length) {
const ids = designerTopics.map((topic) => topic.getId());
$assert(
result.length == topicsIds.length,
`Could not find topic. Result:${
result
}, Filter Criteria:${
topicsIds
}, Current Topics: [${
ids
}]`,
);
}
return result;
},
/** */
deleteTopic: function (topic) {
this._designer.removeTopic(topic);
},
/** */
deleteTopic(topic) {
this._designer.removeTopic(topic);
},
/** */
createTopic: function (model) {
$assert(model, 'model can not be null');
return this._designer.nodeModelToNodeGraph(model);
},
/** */
createTopic(model) {
$assert(model, 'model can not be null');
return this._designer.nodeModelToNodeGraph(model);
},
/** */
createModel: function () {
var mindmap = this._designer.getMindmap();
return mindmap.createNode(NodeModel.MAIN_TOPIC_TYPE);
},
/** */
createModel() {
const mindmap = this._designer.getMindmap();
return mindmap.createNode(NodeModel.MAIN_TOPIC_TYPE);
},
/** */
addTopic: function (topic) {
var mindmap = this._designer.getMindmap();
return mindmap.addBranch(topic.getModel());
},
/** */
addTopic(topic) {
const mindmap = this._designer.getMindmap();
return mindmap.addBranch(topic.getModel());
},
/** */
connect: function (childTopic, parentTopic) {
childTopic.connectTo(parentTopic, this._designer._workspace);
},
/** */
connect(childTopic, parentTopic) {
childTopic.connectTo(parentTopic, this._designer._workspace);
},
/** */
disconnect: function (topic) {
topic.disconnect(this._designer._workspace);
},
/** */
disconnect(topic) {
topic.disconnect(this._designer._workspace);
},
/** */
addRelationship: function (model) {
$assert(model, 'model cannot be null');
return this._designer.addRelationship(model);
},
/** */
addRelationship(model) {
$assert(model, 'model cannot be null');
return this._designer.addRelationship(model);
},
/** */
deleteRelationship: function (relationship) {
this._designer.deleteRelationship(relationship);
},
/** */
deleteRelationship(relationship) {
this._designer.deleteRelationship(relationship);
},
/** */
findRelationships: function (relIds) {
$assert($defined(relIds), 'relId can not be null');
if (!(relIds instanceof Array)) {
relIds = [relIds];
}
/** */
findRelationships(relIds) {
$assert($defined(relIds), 'relId can not be null');
if (!(relIds instanceof Array)) {
relIds = [relIds];
}
var designerRel = this._designer.getModel().getRelationships();
return designerRel.filter(function (rel) {
return relIds.contains(rel.getId());
});
},
const designerRel = this._designer.getModel().getRelationships();
return designerRel.filter((rel) => relIds.contains(rel.getId()));
},
/** */
moveTopic: function (topic, position) {
$assert(topic, 'topic cannot be null');
$assert(position, 'position cannot be null');
EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
node: topic.getModel(),
position: position,
});
},
}
/** */
moveTopic(topic, position) {
$assert(topic, 'topic cannot be null');
$assert(position, 'position cannot be null');
EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
node: topic.getModel(),
position,
});
},
},
);
export { StandaloneActionDispatcher, CommandContext };

530
packages/mindplot/lib/components/TextEditor.js
View File

@ -1,270 +1,260 @@
/*
* 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 web2D = require('@wismapping/web2d')
const web2d = web2D()
const ActionDispatcher = require('./ActionDispatcher').default
//FIXME: Not used!
const TextEditor = new Class({
initialize: function (topic) {
this._topic = topic;
},
_buildEditor: function () {
this._size = {width: 500, height: 100};
var result = new Element('div');
result.setStyles({
position: "absolute",
display: "none",
zIndex: "8",
width: "500px",
height: "100px"
}
);
var inputContainer = new Element('div');
inputContainer.setStyles({
border: "none",
overflow: "auto"
});
inputContainer.inject(result);
var inputText = new Element('input',
{
type: "text",
tabindex: '-1',
value: ""
}
);
inputText.setStyles({
border: "none",
background: "transparent"
});
inputText.inject(inputContainer);
var spanContainer = new Element('div');
spanContainer.setStyle('visibility', "hidden");
spanContainer.inject(result);
var spanElem = new Element('span', {tabindex: "-1"});
spanElem.setStyle('white-space', "nowrap");
spanElem.setStyle('nowrap', 'nowrap');
spanElem.inject(spanContainer);
return result;
},
_registerEvents: function (divElem) {
var inputElem = this._getTextareaElem();
var spanElem = this._getSpanElem();
var me = this;
divElem.addEvent('keydown', function (event) {
switch (event.key) {
case 'esc':
me.close(false);
break;
case 'enter':
me.close(true);
break;
default:
spanElem.innerHTML = inputElem.value;
var size = inputElem.value.length + 1;
inputElem.size = size;
if (spanElem.offsetWidth > (parseInt(divElem.style.width) - 100)) {
divElem.style.width = (spanElem.offsetWidth + 100) + "px";
}
break;
}
event.stopPropagation();
});
// If the user clicks on the input, all event must be ignored ...
divElem.addEvent('click', function (event) {
event.stopPropagation();
});
divElem.addEvent('dblclick', function (event) {
event.stopPropagation();
});
divElem.addEvent('mousedown', function (event) {
event.stopPropagation();
});
},
isVisible: function () {
return $defined(this._containerElem) && this._containerElem.getStyle('display') == 'block';
},
_updateModel: function () {
if (this._topic.getText() != this._getText()) {
var text = this._getText();
var topicId = this._topic.getId();
var actionDispatcher = ActionDispatcher.getInstance();
actionDispatcher.changeTextToTopic([topicId], text);
}
},
show: function (text) {
if (!this.isVisible()) {
//Create editor ui
var editorElem = this._buildEditor();
editorElem.inject($(document.body)[0]);
this._containerElem = editorElem;
this._registerEvents(editorElem);
this._showEditor(text);
}
},
_showEditor: function (defaultText) {
var topic = this._topic;
// Hide topic text ...
topic.getTextShape().setVisibility(false);
// Set Editor Style
var nodeText = topic.getTextShape();
var font = nodeText.getFont();
font.size = nodeText.getHtmlFontSize();
font.color = nodeText.getColor();
this._setStyle(font);
// Set editor's initial text
var text = $defined(defaultText) ? defaultText : topic.getText();
this._setText(text);
var me = this;
// Set editor's initial size
var displayFunc = function () {
// Position the editor and set the size...
var textShape = me._topic.getTextShape();
me._containerElem.css('display', 'block');
me._containerElem.offset(textShape.getNativePosition());
// Set size ...
var elemSize = topic.getSize();
me._setEditorSize(elemSize.width, elemSize.height);
var textareaElem = me._getTextareaElem();
textareaElem.focus();
me._positionCursor(textareaElem, !$defined(defaultText));
};
displayFunc.delay(10);
},
_setStyle: function (fontStyle) {
var inputField = this._getTextareaElem();
var spanField = this._getSpanElem();
if (!$defined(fontStyle.font)) {
fontStyle.font = "Arial";
}
if (!$defined(fontStyle.style)) {
fontStyle.style = "normal";
}
if (!$defined(fontStyle.weight)) {
fontStyle.weight = "normal";
}
if (!$defined(fontStyle.size)) {
fontStyle.size = 12;
}
inputField.style.fontSize = fontStyle.size + "px";
inputField.style.fontFamily = fontStyle.font;
inputField.style.fontStyle = fontStyle.style;
inputField.style.fontWeight = fontStyle.weight;
inputField.style.color = fontStyle.color;
spanField.style.fontFamily = fontStyle.font;
spanField.style.fontStyle = fontStyle.style;
spanField.style.fontWeight = fontStyle.weight;
spanField.style.fontSize = fontStyle.size + "px";
},
_setText: function (text) {
var inputField = this._getTextareaElem();
inputField.size = text.length + 1;
this._containerElem.style.width = (inputField.size * parseInt(inputField.style.fontSize) + 100) + "px";
var spanField = this._getSpanElem();
spanField.innerHTML = text;
inputField.value = text;
},
_getText: function () {
return this._getTextareaElem().value;
},
_getTextareaElem: function () {
return this._containerElem.getElement('input');
},
_getSpanElem: function () {
return this._containerElem.getElement('span');
},
_setEditorSize: function (width, height) {
var textShape = this._topic.getTextShape();
var scale = web2d.utils.TransformUtil.workoutScale(textShape._peer);
this._size = {width: width * scale.width, height: height * scale.height};
this._containerElem.style.width = this._size.width * 2 + "px";
this._containerElem.style.height = this._size.height + "px";
},
_positionCursor: function (inputElem, selectText) {
// Select text if it's required ...
if (inputElem.createTextRange) //ie
{
var range = inputElem.createTextRange();
var pos = inputElem.value.length;
if (!selectText) {
range.select();
range.move("character", pos);
}
else {
range.move("character", pos);
range.select();
}
}
else if (!selectText) {
inputElem.setSelectionRange(0, inputElem.value.length);
}
},
close: function (update) {
if (this.isVisible()) {
// Update changes ...
if (!$defined(update) || update) {
this._updateModel();
}
// Let make the visible text in the node visible again ...
this._topic.getTextShape().setVisibility(true);
// Remove it form the screen ...
this._containerElem.dispose();
this._containerElem = null;
}
}
});
export default TextEditor;
/*
* 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 web2D = require('@wismapping/web2d');
const web2d = web2D();
const ActionDispatcher = require('./ActionDispatcher').default;
// FIXME: Not used!
const TextEditor = new Class({
initialize(topic) {
this._topic = topic;
},
_buildEditor() {
this._size = { width: 500, height: 100 };
const result = new Element('div');
result.setStyles({
position: 'absolute',
display: 'none',
zIndex: '8',
width: '500px',
height: '100px',
});
const inputContainer = new Element('div');
inputContainer.setStyles({
border: 'none',
overflow: 'auto',
});
inputContainer.inject(result);
const inputText = new Element('input',
{
type: 'text',
tabindex: '-1',
value: '',
});
inputText.setStyles({
border: 'none',
background: 'transparent',
});
inputText.inject(inputContainer);
const spanContainer = new Element('div');
spanContainer.setStyle('visibility', 'hidden');
spanContainer.inject(result);
const spanElem = new Element('span', { tabindex: '-1' });
spanElem.setStyle('white-space', 'nowrap');
spanElem.setStyle('nowrap', 'nowrap');
spanElem.inject(spanContainer);
return result;
},
_registerEvents(divElem) {
const inputElem = this._getTextareaElem();
const spanElem = this._getSpanElem();
const me = this;
divElem.addEvent('keydown', (event) => {
switch (event.key) {
case 'esc':
me.close(false);
break;
case 'enter':
me.close(true);
break;
default:
spanElem.innerHTML = inputElem.value;
var size = inputElem.value.length + 1;
inputElem.size = size;
if (spanElem.offsetWidth > (parseInt(divElem.style.width) - 100)) {
divElem.style.width = `${spanElem.offsetWidth + 100}px`;
}
break;
}
event.stopPropagation();
});
// If the user clicks on the input, all event must be ignored ...
divElem.addEvent('click', (event) => {
event.stopPropagation();
});
divElem.addEvent('dblclick', (event) => {
event.stopPropagation();
});
divElem.addEvent('mousedown', (event) => {
event.stopPropagation();
});
},
isVisible() {
return $defined(this._containerElem) && this._containerElem.getStyle('display') == 'block';
},
_updateModel() {
if (this._topic.getText() != this._getText()) {
const text = this._getText();
const topicId = this._topic.getId();
const actionDispatcher = ActionDispatcher.getInstance();
actionDispatcher.changeTextToTopic([topicId], text);
}
},
show(text) {
if (!this.isVisible()) {
// Create editor ui
const editorElem = this._buildEditor();
editorElem.inject($(document.body)[0]);
this._containerElem = editorElem;
this._registerEvents(editorElem);
this._showEditor(text);
}
},
_showEditor(defaultText) {
const topic = this._topic;
// Hide topic text ...
topic.getTextShape().setVisibility(false);
// Set Editor Style
const nodeText = topic.getTextShape();
const font = nodeText.getFont();
font.size = nodeText.getHtmlFontSize();
font.color = nodeText.getColor();
this._setStyle(font);
// Set editor's initial text
const text = $defined(defaultText) ? defaultText : topic.getText();
this._setText(text);
const me = this;
// Set editor's initial size
const displayFunc = function () {
// Position the editor and set the size...
const textShape = me._topic.getTextShape();
me._containerElem.css('display', 'block');
me._containerElem.offset(textShape.getNativePosition());
// Set size ...
const elemSize = topic.getSize();
me._setEditorSize(elemSize.width, elemSize.height);
const textareaElem = me._getTextareaElem();
textareaElem.focus();
me._positionCursor(textareaElem, !$defined(defaultText));
};
displayFunc.delay(10);
},
_setStyle(fontStyle) {
const inputField = this._getTextareaElem();
const spanField = this._getSpanElem();
if (!$defined(fontStyle.font)) {
fontStyle.font = 'Arial';
}
if (!$defined(fontStyle.style)) {
fontStyle.style = 'normal';
}
if (!$defined(fontStyle.weight)) {
fontStyle.weight = 'normal';
}
if (!$defined(fontStyle.size)) {
fontStyle.size = 12;
}
inputField.style.fontSize = `${fontStyle.size}px`;
inputField.style.fontFamily = fontStyle.font;
inputField.style.fontStyle = fontStyle.style;
inputField.style.fontWeight = fontStyle.weight;
inputField.style.color = fontStyle.color;
spanField.style.fontFamily = fontStyle.font;
spanField.style.fontStyle = fontStyle.style;
spanField.style.fontWeight = fontStyle.weight;
spanField.style.fontSize = `${fontStyle.size}px`;
},
_setText(text) {
const inputField = this._getTextareaElem();
inputField.size = text.length + 1;
this._containerElem.style.width = `${inputField.size * parseInt(inputField.style.fontSize) + 100}px`;
const spanField = this._getSpanElem();
spanField.innerHTML = text;
inputField.value = text;
},
_getText() {
return this._getTextareaElem().value;
},
_getTextareaElem() {
return this._containerElem.getElement('input');
},
_getSpanElem() {
return this._containerElem.getElement('span');
},
_setEditorSize(width, height) {
const textShape = this._topic.getTextShape();
const scale = web2d.utils.TransformUtil.workoutScale(textShape._peer);
this._size = { width: width * scale.width, height: height * scale.height };
this._containerElem.style.width = `${this._size.width * 2}px`;
this._containerElem.style.height = `${this._size.height}px`;
},
_positionCursor(inputElem, selectText) {
// Select text if it's required ...
if (inputElem.createTextRange) // ie
{
const range = inputElem.createTextRange();
const pos = inputElem.value.length;
if (!selectText) {
range.select();
range.move('character', pos);
} else {
range.move('character', pos);
range.select();
}
} else if (!selectText) {
inputElem.setSelectionRange(0, inputElem.value.length);
}
},
close(update) {
if (this.isVisible()) {
// Update changes ...
if (!$defined(update) || update) {
this._updateModel();
}
// Let make the visible text in the node visible again ...
this._topic.getTextShape().setVisibility(true);
// Remove it form the screen ...
this._containerElem.dispose();
this._containerElem = null;
}
},
});
export default TextEditor;

14
packages/mindplot/lib/components/TextEditorFactory.js
View File

@ -20,11 +20,11 @@ const TextEditor = require('./TextEditor').default;
const TextEditorFactory = {};
TextEditorFactory.getTextEditorFromName = function (name) {
var editorClass = null;
if (name == 'RichTextEditor') {
editorClass = RichTextEditor;
} else {
editorClass = TextEditor;
}
return editorClass;
let editorClass = null;
if (name == 'RichTextEditor') {
editorClass = RichTextEditor;
} else {
editorClass = TextEditor;
}
return editorClass;
};

2454
packages/mindplot/lib/components/Topic.js
View File

File diff suppressed because it is too large Load Diff

94
packages/mindplot/lib/components/TopicEventDispatcher.js
View File

@ -20,66 +20,66 @@ const MultilineTextEditor = require('./MultilineTextEditor').default;
const { TopicShape } = require('./model/INodeModel');
const TopicEventDispatcher = new Class({
Extends: Events,
Static: {
_instance: null,
Extends: Events,
Static: {
_instance: null,
configure: function (readOnly) {
this._instance = new TopicEventDispatcher(readOnly);
},
getInstance: function () {
return this._instance;
},
configure(readOnly) {
this._instance = new TopicEventDispatcher(readOnly);
},
initialize: function (readOnly) {
this._readOnly = readOnly;
this._activeEditor = null;
this._multilineEditor = new MultilineTextEditor();
getInstance() {
return this._instance;
},
},
close: function (update) {
if (this.isVisible()) {
this._activeEditor.close(update);
this._activeEditor = null;
}
},
initialize(readOnly) {
this._readOnly = readOnly;
this._activeEditor = null;
this._multilineEditor = new MultilineTextEditor();
},
show: function (topic, options) {
this.process(TopicEvent.EDIT, topic, options);
},
close(update) {
if (this.isVisible()) {
this._activeEditor.close(update);
this._activeEditor = null;
}
},
process: function (eventType, topic, options) {
$assert(eventType, 'eventType can not be null');
show(topic, options) {
this.process(TopicEvent.EDIT, topic, options);
},
// Close all previous open editor ....
if (this.isVisible()) {
this.close();
}
process(eventType, topic, options) {
$assert(eventType, 'eventType can not be null');
// Open the new editor ...
var model = topic.getModel();
if (
model.getShapeType() != TopicShape.IMAGE &&
!this._readOnly &&
eventType == TopicEvent.EDIT
) {
this._multilineEditor.show(topic, options ? options.text : null);
this._activeEditor = this._multilineEditor;
} else {
this.fireEvent(eventType, { model: model, readOnly: this._readOnly });
}
},
// Close all previous open editor ....
if (this.isVisible()) {
this.close();
}
isVisible: function () {
return this._activeEditor != null && this._activeEditor.isVisible();
},
// Open the new editor ...
const model = topic.getModel();
if (
model.getShapeType() != TopicShape.IMAGE
&& !this._readOnly
&& eventType == TopicEvent.EDIT
) {
this._multilineEditor.show(topic, options ? options.text : null);
this._activeEditor = this._multilineEditor;
} else {
this.fireEvent(eventType, { model, readOnly: this._readOnly });
}
},
isVisible() {
return this._activeEditor != null && this._activeEditor.isVisible();
},
});
const TopicEvent = {
EDIT: 'editnode',
CLICK: 'clicknode',
EDIT: 'editnode',
CLICK: 'clicknode',
};
export { TopicEvent };

78
packages/mindplot/lib/components/TopicFeature.js
View File

@ -25,38 +25,36 @@ const NoteModel = require('./model/NoteModel').default;
const NoteIcon = require('./NoteIcon').default;
const TopicFeature = {
/** the icon object */
Icon: {
id: IconModel.FEATURE_TYPE,
model: IconModel,
icon: ImageIcon
},
/** the icon object */
Icon: {
id: IconModel.FEATURE_TYPE,
model: IconModel,
icon: ImageIcon,
},
/** the link object */
Link: {
id: LinkModel.FEATURE_TYPE,
model: LinkModel,
icon: LinkIcon
},
/** the link object */
Link: {
id: LinkModel.FEATURE_TYPE,
model: LinkModel,
icon: LinkIcon,
},
/** the note object */
Note: {
id: NoteModel.FEATURE_TYPE,
model: NoteModel,
icon: NoteIcon
},
/** the note object */
Note: {
id: NoteModel.FEATURE_TYPE,
model: NoteModel,
icon: NoteIcon,
},
/**
/**
* @param id the feature metadata id
* @return {Boolean} returns true if the given id is contained in the metadata array
*/
isSupported: function (id) {
return TopicFeature._featuresMetadataById.some(function (elem) {
return elem.id == id;
});
},
isSupported(id) {
return TopicFeature._featuresMetadataById.some((elem) => elem.id == id);
},
/**
/**
* @param type
* @param attributes
* @throws will throw an error if type is null or undefined
@ -64,17 +62,15 @@ const TopicFeature = {
* @return {mindplot.model.FeatureModel} a new instance of the feature model subclass matching
* the topic feature
*/
createModel: function (type, attributes) {
$assert(type, 'type can not be null');
$assert(attributes, 'attributes can not be null');
createModel(type, attributes) {
$assert(type, 'type can not be null');
$assert(attributes, 'attributes can not be null');
var model = TopicFeature._featuresMetadataById.filter(function (elem) {
return elem.id == type;
})[0].model;
return new model(attributes);
},
const { model } = TopicFeature._featuresMetadataById.filter((elem) => elem.id == type)[0];
return new model(attributes);
},
/**
/**
* @param {mindplot.Topic} topic
* @param {mindplot.model.FeatureModel} model
* @param {Boolean} readOnly true if the editor is running in read-only mode
@ -82,15 +78,13 @@ const TopicFeature = {
* @throws will throw an error if model is null or undefined
* @return {mindplot.Icon} a new instance of the icon subclass matching the topic feature
*/
createIcon: function (topic, model, readOnly) {
$assert(topic, 'topic can not be null');
$assert(model, 'model can not be null');
createIcon(topic, model, readOnly) {
$assert(topic, 'topic can not be null');
$assert(model, 'model can not be null');
var icon = TopicFeature._featuresMetadataById.filter(function (elem) {
return elem.id == model.getType();
})[0].icon;
return new icon(topic, model, readOnly);
}
const { icon } = TopicFeature._featuresMetadataById.filter((elem) => elem.id == model.getType())[0];
return new icon(topic, model, readOnly);
},
};
TopicFeature._featuresMetadataById = [TopicFeature.Icon, TopicFeature.Link, TopicFeature.Note];

194
packages/mindplot/lib/components/TopicStyle.js
View File

@ -18,115 +18,115 @@
const { TopicShape } = require('./model/INodeModel');
const TopicStyle = new Class({
Static: {
_getStyles: function (topic) {
$assert(topic, 'topic can not be null');
Static: {
_getStyles(topic) {
$assert(topic, 'topic can not be null');
var result;
if (topic.isCentralTopic()) {
result = TopicStyle.STYLES.CENTRAL_TOPIC;
} else {
var targetTopic = topic.getOutgoingConnectedTopic();
if ($defined(targetTopic)) {
if (targetTopic.isCentralTopic()) {
result = TopicStyle.STYLES.MAIN_TOPIC;
} else {
result = TopicStyle.STYLES.SUB_TOPIC;
}
} else {
result = TopicStyle.STYLES.ISOLATED_TOPIC;
}
}
return result;
},
defaultText: function (topic) {
var msgKey = this._getStyles(topic).msgKey;
return $msg(msgKey);
},
defaultFontStyle: function (topic) {
return this._getStyles(topic).fontStyle;
},
defaultBackgroundColor: function (topic) {
return this._getStyles(topic).backgroundColor;
},
defaultBorderColor: function (topic) {
return this._getStyles(topic).borderColor;
},
getInnerPadding: function (topic) {
return this._getStyles(topic).innerPadding;
},
defaultShapeType: function (topic) {
return this._getStyles(topic).shapeType;
},
let result;
if (topic.isCentralTopic()) {
result = TopicStyle.STYLES.CENTRAL_TOPIC;
} else {
const targetTopic = topic.getOutgoingConnectedTopic();
if ($defined(targetTopic)) {
if (targetTopic.isCentralTopic()) {
result = TopicStyle.STYLES.MAIN_TOPIC;
} else {
result = TopicStyle.STYLES.SUB_TOPIC;
}
} else {
result = TopicStyle.STYLES.ISOLATED_TOPIC;
}
}
return result;
},
defaultText(topic) {
const { msgKey } = this._getStyles(topic);
return $msg(msgKey);
},
defaultFontStyle(topic) {
return this._getStyles(topic).fontStyle;
},
defaultBackgroundColor(topic) {
return this._getStyles(topic).backgroundColor;
},
defaultBorderColor(topic) {
return this._getStyles(topic).borderColor;
},
getInnerPadding(topic) {
return this._getStyles(topic).innerPadding;
},
defaultShapeType(topic) {
return this._getStyles(topic).shapeType;
},
},
});
TopicStyle.STYLES = {
CENTRAL_TOPIC: {
borderColor: 'rgb(57,113,177)',
backgroundColor: 'rgb(80,157,192)',
fontStyle: {
font: 'Verdana',
size: 10,
style: 'normal',
weight: 'bold',
color: '#ffffff',
},
msgKey: 'CENTRAL_TOPIC',
innerPadding: 11,
shapeType: TopicShape.ROUNDED_RECT,
CENTRAL_TOPIC: {
borderColor: 'rgb(57,113,177)',
backgroundColor: 'rgb(80,157,192)',
fontStyle: {
font: 'Verdana',
size: 10,
style: 'normal',
weight: 'bold',
color: '#ffffff',
},
msgKey: 'CENTRAL_TOPIC',
innerPadding: 11,
shapeType: TopicShape.ROUNDED_RECT,
},
MAIN_TOPIC: {
borderColor: 'rgb(2,59,185)',
backgroundColor: 'rgb(224,229,239)',
fontStyle: {
font: 'Arial',
size: 8,
style: 'normal',
weight: 'normal',
color: 'rgb(82,92,97)',
},
msgKey: 'MAIN_TOPIC',
innerPadding: 3,
shapeType: TopicShape.LINE,
MAIN_TOPIC: {
borderColor: 'rgb(2,59,185)',
backgroundColor: 'rgb(224,229,239)',
fontStyle: {
font: 'Arial',
size: 8,
style: 'normal',
weight: 'normal',
color: 'rgb(82,92,97)',
},
msgKey: 'MAIN_TOPIC',
innerPadding: 3,
shapeType: TopicShape.LINE,
},
SUB_TOPIC: {
borderColor: 'rgb(2,59,185)',
backgroundColor: 'rgb(224,229,239)',
fontStyle: {
font: 'Arial',
size: 6,
style: 'normal',
weight: 'normal',
color: 'rgb(82,92,97)',
},
msgKey: 'SUB_TOPIC',
innerPadding: 3,
shapeType: TopicShape.LINE,
SUB_TOPIC: {
borderColor: 'rgb(2,59,185)',
backgroundColor: 'rgb(224,229,239)',
fontStyle: {
font: 'Arial',
size: 6,
style: 'normal',
weight: 'normal',
color: 'rgb(82,92,97)',
},
msgKey: 'SUB_TOPIC',
innerPadding: 3,
shapeType: TopicShape.LINE,
},
ISOLATED_TOPIC: {
borderColor: 'rgb(2,59,185)',
backgroundColor: 'rgb(224,229,239)',
fontStyle: {
font: 'Verdana',
size: 8,
style: 'normal',
weight: 'normal',
color: 'rgb(82,92,97)',
},
msgKey: 'ISOLATED_TOPIC',
innerPadding: 4,
shapeType: TopicShape.LINE,
ISOLATED_TOPIC: {
borderColor: 'rgb(2,59,185)',
backgroundColor: 'rgb(224,229,239)',
fontStyle: {
font: 'Verdana',
size: 8,
style: 'normal',
weight: 'normal',
color: 'rgb(82,92,97)',
},
msgKey: 'ISOLATED_TOPIC',
innerPadding: 4,
shapeType: TopicShape.LINE,
},
};
export default TopicStyle;

455
packages/mindplot/lib/components/Workspace.js
View File

@ -1,229 +1,226 @@
/*
* 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 web2D = require('@wismapping/web2d')
const web2d = web2D();
const Workspace = new Class({
initialize: function (screenManager, zoom) {
// Create a suitable container ...
$assert(screenManager, 'Div container can not be null');
$assert(zoom, 'zoom container can not be null');
this._zoom = zoom;
this._screenManager = screenManager;
var divContainer = screenManager.getContainer();
this._screenWidth = parseInt(divContainer.css('width'));
this._screenHeight = parseInt(divContainer.css('height'));
// Initialize web2d workspace.
var workspace = this._createWorkspace();
this._workspace = workspace;
// Append to the workspace...
workspace.addItAsChildTo(divContainer);
this.setZoom(zoom, true);
// Register drag events ...
this._registerDragEvents();
this._eventsEnabled = true;
},
_createWorkspace: function () {
// Initialize workspace ...
var coordOriginX = -(this._screenWidth / 2);
var coordOriginY = -(this._screenHeight / 2);
var workspaceProfile = {
width: this._screenWidth + "px",
height: this._screenHeight + "px",
coordSizeWidth: this._screenWidth,
coordSizeHeight: this._screenHeight,
coordOriginX: coordOriginX,
coordOriginY: coordOriginY,
fillColor: 'transparent',
strokeWidth: 0
};
web2d.Toolkit.init();
return new web2d.Workspace(workspaceProfile);
},
append: function (shape) {
if ($defined(shape.addToWorkspace)) {
shape.addToWorkspace(this);
} else {
this._workspace.append(shape);
}
},
removeChild: function (shape) {
// Element is a node, not a web2d element?
if ($defined(shape.removeFromWorkspace)) {
shape.removeFromWorkspace(this);
} else {
this._workspace.removeChild(shape);
}
},
addEvent: function (type, listener) {
this._workspace.addEvent(type, listener);
},
removeEvent: function (type, listener) {
$assert(type, 'type can not be null');
$assert(listener, 'listener can not be null');
this._workspace.removeEvent(type, listener);
},
getSize: function () {
return this._workspace.getCoordSize();
},
setZoom: function (zoom, center) {
this._zoom = zoom;
var workspace = this._workspace;
// Update coord scale...
var coordWidth = zoom * this._screenWidth;
var coordHeight = zoom * this._screenHeight;
workspace.setCoordSize(coordWidth, coordHeight);
// View port coords ...
if (this._viewPort) {
this._viewPort.width = this._viewPort.width * zoom;
this._viewPort.height = this._viewPort.height * zoom;
}
// Center topic....
var coordOriginX;
var coordOriginY;
if (center) {
if (this._viewPort) {
coordOriginX = -(this._viewPort.width / 2);
coordOriginY = -(this._viewPort.height / 2);
} else {
coordOriginX = -(coordWidth / 2);
coordOriginY = -(coordHeight / 2);
}
} else {
var coordOrigin = workspace.getCoordOrigin();
coordOriginX = coordOrigin.x;
coordOriginY = coordOrigin.y;
}
workspace.setCoordOrigin(coordOriginX, coordOriginY);
// Update screen.
this._screenManager.setOffset(coordOriginX, coordOriginY);
this._screenManager.setScale(zoom);
// Some changes in the screen. Let's fire an update event...
this._screenManager.fireEvent('update');
},
getScreenManager: function () {
return this._screenManager;
},
enableWorkspaceEvents: function (value) {
this._eventsEnabled = value;
},
isWorkspaceEventsEnabled: function () {
return this._eventsEnabled;
},
dumpNativeChart: function () {
return this._workspace.dumpNativeChart();
},
_registerDragEvents: function () {
var workspace = this._workspace;
var screenManager = this._screenManager;
var mWorkspace = this;
var mouseDownListener = function (event) {
if (!$defined(workspace._mouseMoveListener)) {
if (mWorkspace.isWorkspaceEventsEnabled()) {
mWorkspace.enableWorkspaceEvents(false);
var mouseDownPosition = screenManager.getWorkspaceMousePosition(event);
var originalCoordOrigin = workspace.getCoordOrigin();
var wasDragged = false;
workspace._mouseMoveListener = function (event) {
var currentMousePosition = screenManager.getWorkspaceMousePosition(event);
var offsetX = currentMousePosition.x - mouseDownPosition.x;
var coordOriginX = -offsetX + originalCoordOrigin.x;
var offsetY = currentMousePosition.y - mouseDownPosition.y;
var coordOriginY = -offsetY + originalCoordOrigin.y;
workspace.setCoordOrigin(coordOriginX, coordOriginY);
// Change cursor.
if (Browser.firefox) {
window.document.body.style.cursor = "-moz-grabbing";
} else {
window.document.body.style.cursor = "move";
}
event.preventDefault();
// Fire drag event ...
screenManager.fireEvent('update');
wasDragged = true;
};
screenManager.addEvent('mousemove', workspace._mouseMoveListener);
// Register mouse up listeners ...
workspace._mouseUpListener = function (event) {
screenManager.removeEvent('mousemove', workspace._mouseMoveListener);
screenManager.removeEvent('mouseup', workspace._mouseUpListener);
workspace._mouseUpListener = null;
workspace._mouseMoveListener = null;
window.document.body.style.cursor = 'default';
// Update screen manager offset.
var coordOrigin = workspace.getCoordOrigin();
screenManager.setOffset(coordOrigin.x, coordOrigin.y);
mWorkspace.enableWorkspaceEvents(true);
if (!wasDragged) {
screenManager.fireEvent('click');
}
};
screenManager.addEvent('mouseup', workspace._mouseUpListener);
}
} else {
workspace._mouseUpListener();
}
};
screenManager.addEvent('mousedown', mouseDownListener);
},
setViewPort: function (size) {
this._viewPort = size;
}
});
export default Workspace;
/*
* 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 web2D = require('@wismapping/web2d');
const web2d = web2D();
const Workspace = new Class({
initialize(screenManager, zoom) {
// Create a suitable container ...
$assert(screenManager, 'Div container can not be null');
$assert(zoom, 'zoom container can not be null');
this._zoom = zoom;
this._screenManager = screenManager;
const divContainer = screenManager.getContainer();
this._screenWidth = parseInt(divContainer.css('width'));
this._screenHeight = parseInt(divContainer.css('height'));
// Initialize web2d workspace.
const workspace = this._createWorkspace();
this._workspace = workspace;
// Append to the workspace...
workspace.addItAsChildTo(divContainer);
this.setZoom(zoom, true);
// Register drag events ...
this._registerDragEvents();
this._eventsEnabled = true;
},
_createWorkspace() {
// Initialize workspace ...
const coordOriginX = -(this._screenWidth / 2);
const coordOriginY = -(this._screenHeight / 2);
const workspaceProfile = {
width: `${this._screenWidth}px`,
height: `${this._screenHeight}px`,
coordSizeWidth: this._screenWidth,
coordSizeHeight: this._screenHeight,
coordOriginX,
coordOriginY,
fillColor: 'transparent',
strokeWidth: 0,
};
web2d.Toolkit.init();
return new web2d.Workspace(workspaceProfile);
},
append(shape) {
if ($defined(shape.addToWorkspace)) {
shape.addToWorkspace(this);
} else {
this._workspace.append(shape);
}
},
removeChild(shape) {
// Element is a node, not a web2d element?
if ($defined(shape.removeFromWorkspace)) {
shape.removeFromWorkspace(this);
} else {
this._workspace.removeChild(shape);
}
},
addEvent(type, listener) {
this._workspace.addEvent(type, listener);
},
removeEvent(type, listener) {
$assert(type, 'type can not be null');
$assert(listener, 'listener can not be null');
this._workspace.removeEvent(type, listener);
},
getSize() {
return this._workspace.getCoordSize();
},
setZoom(zoom, center) {
this._zoom = zoom;
const workspace = this._workspace;
// Update coord scale...
const coordWidth = zoom * this._screenWidth;
const coordHeight = zoom * this._screenHeight;
workspace.setCoordSize(coordWidth, coordHeight);
// View port coords ...
if (this._viewPort) {
this._viewPort.width = this._viewPort.width * zoom;
this._viewPort.height = this._viewPort.height * zoom;
}
// Center topic....
let coordOriginX;
let coordOriginY;
if (center) {
if (this._viewPort) {
coordOriginX = -(this._viewPort.width / 2);
coordOriginY = -(this._viewPort.height / 2);
} else {
coordOriginX = -(coordWidth / 2);
coordOriginY = -(coordHeight / 2);
}
} else {
const coordOrigin = workspace.getCoordOrigin();
coordOriginX = coordOrigin.x;
coordOriginY = coordOrigin.y;
}
workspace.setCoordOrigin(coordOriginX, coordOriginY);
// Update screen.
this._screenManager.setOffset(coordOriginX, coordOriginY);
this._screenManager.setScale(zoom);
// Some changes in the screen. Let's fire an update event...
this._screenManager.fireEvent('update');
},
getScreenManager() {
return this._screenManager;
},
enableWorkspaceEvents(value) {
this._eventsEnabled = value;
},
isWorkspaceEventsEnabled() {
return this._eventsEnabled;
},
dumpNativeChart() {
return this._workspace.dumpNativeChart();
},
_registerDragEvents() {
const workspace = this._workspace;
const screenManager = this._screenManager;
const mWorkspace = this;
const mouseDownListener = function (event) {
if (!$defined(workspace._mouseMoveListener)) {
if (mWorkspace.isWorkspaceEventsEnabled()) {
mWorkspace.enableWorkspaceEvents(false);
const mouseDownPosition = screenManager.getWorkspaceMousePosition(event);
const originalCoordOrigin = workspace.getCoordOrigin();
let wasDragged = false;
workspace._mouseMoveListener = function (event) {
const currentMousePosition = screenManager.getWorkspaceMousePosition(event);
const offsetX = currentMousePosition.x - mouseDownPosition.x;
const coordOriginX = -offsetX + originalCoordOrigin.x;
const offsetY = currentMousePosition.y - mouseDownPosition.y;
const coordOriginY = -offsetY + originalCoordOrigin.y;
workspace.setCoordOrigin(coordOriginX, coordOriginY);
// Change cursor.
if (Browser.firefox) {
window.document.body.style.cursor = '-moz-grabbing';
} else {
window.document.body.style.cursor = 'move';
}
event.preventDefault();
// Fire drag event ...
screenManager.fireEvent('update');
wasDragged = true;
};
screenManager.addEvent('mousemove', workspace._mouseMoveListener);
// Register mouse up listeners ...
workspace._mouseUpListener = function (event) {
screenManager.removeEvent('mousemove', workspace._mouseMoveListener);
screenManager.removeEvent('mouseup', workspace._mouseUpListener);
workspace._mouseUpListener = null;
workspace._mouseMoveListener = null;
window.document.body.style.cursor = 'default';
// Update screen manager offset.
const coordOrigin = workspace.getCoordOrigin();
screenManager.setOffset(coordOrigin.x, coordOrigin.y);
mWorkspace.enableWorkspaceEvents(true);
if (!wasDragged) {
screenManager.fireEvent('click');
}
};
screenManager.addEvent('mouseup', workspace._mouseUpListener);
}
} else {
workspace._mouseUpListener();
}
};
screenManager.addEvent('mousedown', mouseDownListener);
},
setViewPort(size) {
this._viewPort = size;
},
});
export default Workspace;

65
packages/mindplot/lib/components/commands/AddFeatureToTopicCommand.js
View File

@ -18,8 +18,8 @@
const Command = require('../Command').default;
const AddFeatureToTopicCommand = new Class(/** @lends AddFeatureToTopicCommand */{
Extends: Command,
/**
Extends: Command,
/**
* @classdesc This command class handles do/undo of adding features to topics, e.g. an
* icon or a note. For a reference of existing features, refer to {@link mindplot.TopicFeature}
* @constructs
@ -29,41 +29,40 @@ const AddFeatureToTopicCommand = new Class(/** @lends AddFeatureToTopicCommand *
* @extends mindplot.Command
* @see mindplot.model.FeatureModel and subclasses
*/
initialize:function (topicId, featureType, attributes) {
initialize(topicId, featureType, attributes) {
$assert($defined(topicId), 'topicId can not be null');
$assert(featureType, 'featureType can not be null');
$assert(attributes, 'attributes can not be null');
$assert($defined(topicId), 'topicId can not be null');
$assert(featureType, 'featureType can not be null');
$assert(attributes, 'attributes can not be null');
this.parent();
this._topicId = topicId;
this._featureType = featureType;
this._attributes = attributes;
this._featureModel = null;
},
this.parent();
this._topicId = topicId;
this._featureType = featureType;
this._attributes = attributes;
this._featureModel = null;
},
/**
* Overrides abstract parent method
*/
execute:function (commandContext) {
var topic = commandContext.findTopics(this._topicId)[0];
// Feature must be created only one time.
if (!this._featureModel) {
var model = topic.getModel();
this._featureModel = model.createFeature(this._featureType, this._attributes);
}
topic.addFeature(this._featureModel);
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute:function (commandContext) {
var topic = commandContext.findTopics(this._topicId)[0];
topic.removeFeature(this._featureModel);
execute(commandContext) {
const topic = commandContext.findTopics(this._topicId)[0];
// Feature must be created only one time.
if (!this._featureModel) {
const model = topic.getModel();
this._featureModel = model.createFeature(this._featureType, this._attributes);
}
topic.addFeature(this._featureModel);
},
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute(commandContext) {
const topic = commandContext.findTopics(this._topicId)[0];
topic.removeFeature(this._featureModel);
},
});
export default AddFeatureToTopicCommand
export default AddFeatureToTopicCommand;

44
packages/mindplot/lib/components/commands/AddRelationshipCommand.js
View File

@ -15,39 +15,39 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const Command = require('../Command').default
const Command = require('../Command').default;
const AddRelationshipCommand = new Class(/** @lends AddRelationshipCommand */{
Extends:Command,
/**
Extends: Command,
/**
* @classdesc This command class handles do/undo of adding a relationship to a topic.
* @constructs
* @param {XMLDOM} model
* @extends mindplot.Command
*/
initialize:function (model) {
$assert(model, 'Relationship model can not be null');
initialize(model) {
$assert(model, 'Relationship model can not be null');
this.parent();
this._model = model;
},
/**
* Overrides abstract parent method
*/
execute:function (commandContext) {
var relationship = commandContext.addRelationship(this._model);
relationship.setOnFocus(true);
},
this.parent();
this._model = model;
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute:function (commandContext) {
var rel = commandContext.findRelationships(this._model.getId());
commandContext.deleteRelationship(rel[0]);
}
execute(commandContext) {
const relationship = commandContext.addRelationship(this._model);
relationship.setOnFocus(true);
},
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute(commandContext) {
const rel = commandContext.findRelationships(this._model.getId());
commandContext.deleteRelationship(rel[0]);
},
});
export default AddRelationshipCommand;

106
packages/mindplot/lib/components/commands/AddTopicCommand.js
View File

@ -18,9 +18,9 @@
const Command = require('../Command').default;
const AddTopicCommand = new Class(
/** @lends AddTopicCommand */ {
Extends: Command,
/**
/** @lends AddTopicCommand */ {
Extends: Command,
/**
* @classdesc This command class handles do/undo of adding one or multiple topics to
* the mindmap.
* @constructs
@ -29,69 +29,69 @@ const AddTopicCommand = new Class(
* when attaching a dragged node or a node/branch from clipboard
* @extends mindplot.Command
*/
initialize: function (models, parentTopicsId) {
$assert(models, 'models can not be null');
$assert(
parentTopicsId == null || parentTopicsId.length == models.length,
'parents and models must have the same size'
);
initialize(models, parentTopicsId) {
$assert(models, 'models can not be null');
$assert(
parentTopicsId == null || parentTopicsId.length == models.length,
'parents and models must have the same size',
);
this.parent();
this._models = models;
this._parentsIds = parentTopicsId;
},
this.parent();
this._models = models;
this._parentsIds = parentTopicsId;
},
/**
/**
* Overrides abstract parent method
*/
execute: function (commandContext) {
var me = this;
_.each(this._models, function (model, index) {
// Add a new topic ...
var topic = commandContext.createTopic(model);
execute(commandContext) {
const me = this;
_.each(this._models, (model, index) => {
// Add a new topic ...
const topic = commandContext.createTopic(model);
// Connect to topic ...
if (me._parentsIds) {
var parentId = me._parentsIds[index];
if ($defined(parentId)) {
var parentTopic = commandContext.findTopics(parentId)[0];
commandContext.connect(topic, parentTopic);
}
} else {
commandContext.addTopic(topic);
}
// Connect to topic ...
if (me._parentsIds) {
const parentId = me._parentsIds[index];
if ($defined(parentId)) {
const parentTopic = commandContext.findTopics(parentId)[0];
commandContext.connect(topic, parentTopic);
}
} else {
commandContext.addTopic(topic);
}
// Select just created node ...
var designer = commandContext._designer;
designer.onObjectFocusEvent(topic);
topic.setOnFocus(true);
// Select just created node ...
const designer = commandContext._designer;
designer.onObjectFocusEvent(topic);
topic.setOnFocus(true);
// Render node ...
topic.setVisibility(true);
});
},
// Render node ...
topic.setVisibility(true);
});
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute: function (commandContext) {
// Delete disconnected the nodes. Create a copy of the topics ...
var clonedModel = [];
_.each(this._models, function (model) {
clonedModel.push(model.clone());
});
undoExecute(commandContext) {
// Delete disconnected the nodes. Create a copy of the topics ...
const clonedModel = [];
_.each(this._models, (model) => {
clonedModel.push(model.clone());
});
// Finally, remove the nodes ...
_.each(this._models, function (model) {
var topicId = model.getId();
var topic = commandContext.findTopics(topicId)[0];
commandContext.deleteTopic(topic);
});
// Finally, remove the nodes ...
_.each(this._models, (model) => {
const topicId = model.getId();
const topic = commandContext.findTopics(topicId)[0];
commandContext.deleteTopic(topic);
});
this._models = clonedModel;
},
}
this._models = clonedModel;
},
},
);
export default AddTopicCommand;

48
packages/mindplot/lib/components/commands/ChangeFeatureToTopicCommand.js
View File

@ -15,11 +15,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const Command = require('../Command').default
const Command = require('../Command').default;
const ChangeFeatureToTopicCommand = new Class(/** @lends ChangeFeatureToTopicCommand */{
Extends:Command,
/**
Extends: Command,
/**
* @extends mindplot.Command
* @constructs
* @param topicId
@ -29,36 +29,36 @@ const ChangeFeatureToTopicCommand = new Class(/** @lends ChangeFeatureToTopicCom
* @throws will throw an error if featureId is null or undefined
* @throws will throw an error if attributes is null or undefined
*/
initialize: function(topicId, featureId, attributes) {
$assert($defined(topicId), 'topicId can not be null');
$assert($defined(featureId), 'featureId can not be null');
$assert($defined(attributes), 'attributes can not be null');
initialize(topicId, featureId, attributes) {
$assert($defined(topicId), 'topicId can not be null');
$assert($defined(featureId), 'featureId can not be null');
$assert($defined(attributes), 'attributes can not be null');
this.parent();
this._topicId = topicId;
this._featureId = featureId;
this._attributes = attributes;
},
this.parent();
this._topicId = topicId;
this._featureId = featureId;
this._attributes = attributes;
},
/**
/**
* Overrides abstract parent method
*/
execute: function(commandContext) {
var topic = commandContext.findTopics(this._topicId)[0];
var feature = topic.findFeatureById(this._featureId);
execute(commandContext) {
const topic = commandContext.findTopics(this._topicId)[0];
const feature = topic.findFeatureById(this._featureId);
var oldAttributes = feature.getAttributes();
feature.setAttributes(this._attributes);
this._attributes = oldAttributes;
},
const oldAttributes = feature.getAttributes();
feature.setAttributes(this._attributes);
this._attributes = oldAttributes;
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute: function(commandContext) {
this.execute(commandContext);
}
undoExecute(commandContext) {
this.execute(commandContext);
},
});
export default ChangeFeatureToTopicCommand;

279
packages/mindplot/lib/components/commands/DeleteCommand.js
View File

@ -18,169 +18,162 @@
const Command = require('../Command').default;
const DeleteCommand = new Class(/** @lends mindplot.commands.DeleteCommand */{
Extends:Command,
/**
Extends: Command,
/**
* @classdesc This command class handles do/undo of deleting a topic.
* @constructs
* @param {Array<String>} topicIds ids of the topics to delete
* @param {Array<String>} relIds ids of the relationships connected to the topics
* @extends mindplot.Command
*/
initialize:function (topicIds, relIds) {
$assert($defined(relIds), 'topicIds can not be null');
initialize(topicIds, relIds) {
$assert($defined(relIds), 'topicIds can not be null');
this.parent();
this._relIds = relIds;
this._topicIds = topicIds;
this._deletedTopicModels = [];
this._deletedRelModel = [];
this._parentTopicIds = [];
},
this.parent();
this._relIds = relIds;
this._topicIds = topicIds;
this._deletedTopicModels = [];
this._deletedRelModel = [];
this._parentTopicIds = [];
},
/**
* Overrides abstract parent method
*/
execute:function (commandContext) {
// If a parent has been selected for deletion, the children must be excluded from the delete ...
var topics = this._filterChildren(this._topicIds, commandContext);
if (topics.length > 0) {
_.each(topics, function (topic) {
// In case that it's editing text node, force close without update ...
topic.closeEditors();
var model = topic.getModel();
// Delete relationships
var relationships = this._collectInDepthRelationships(topic);
this._deletedRelModel.append(relationships.map(function (rel) {
return rel.getModel().clone();
}));
_.each(relationships, function (relationship) {
commandContext.deleteRelationship(relationship);
});
// Store information for undo ...
var clonedModel = model.clone();
this._deletedTopicModels.push(clonedModel);
var outTopic = topic.getOutgoingConnectedTopic();
var outTopicId = null;
if (outTopic != null) {
outTopicId = outTopic.getId();
}
this._parentTopicIds.push(outTopicId);
// Finally, delete the topic from the workspace...
commandContext.deleteTopic(topic);
}, this);
}
var rels = commandContext.findRelationships(this._relIds);
if (rels.length > 0) {
_.each(rels, function (rel) {
this._deletedRelModel.push(rel.getModel().clone());
commandContext.deleteRelationship(rel);
}, this);
}
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute:function (commandContext) {
execute(commandContext) {
// If a parent has been selected for deletion, the children must be excluded from the delete ...
const topics = this._filterChildren(this._topicIds, commandContext);
// Add all the topics ...
_.each(this._deletedTopicModels, function (model) {
commandContext.createTopic(model);
}, this);
if (topics.length > 0) {
_.each(topics, function (topic) {
// In case that it's editing text node, force close without update ...
topic.closeEditors();
// Do they need to be connected ?
_.each(this._deletedTopicModels, function (topicModel, index) {
var topics = commandContext.findTopics(topicModel.getId());
const model = topic.getModel();
var parentId = this._parentTopicIds[index];
if (parentId) {
var parentTopics = commandContext.findTopics(parentId);
commandContext.connect(topics[0], parentTopics[0]);
}
}, this);
// Delete relationships
const relationships = this._collectInDepthRelationships(topic);
this._deletedRelModel.append(relationships.map((rel) => rel.getModel().clone()));
// Add rebuild relationships ...
_.each(this._deletedRelModel, function (model) {
commandContext.addRelationship(model);
_.each(relationships, (relationship) => {
commandContext.deleteRelationship(relationship);
});
// Finally display the topics ...
_.each(this._deletedTopicModels, function (topicModel) {
var topics = commandContext.findTopics(topicModel.getId());
topics[0].setBranchVisibility(true);
}, this);
// Focus on last recovered topic ..
if (this._deletedTopicModels.length > 0) {
var firstTopic = this._deletedTopicModels[0];
var topic = commandContext.findTopics(firstTopic.getId())[0];
topic.setOnFocus(true);
// Store information for undo ...
const clonedModel = model.clone();
this._deletedTopicModels.push(clonedModel);
const outTopic = topic.getOutgoingConnectedTopic();
let outTopicId = null;
if (outTopic != null) {
outTopicId = outTopic.getId();
}
this._parentTopicIds.push(outTopicId);
this._deletedTopicModels = [];
this._parentTopicIds = [];
this._deletedRelModel = [];
},
_filterChildren:function (topicIds, commandContext) {
var topics = commandContext.findTopics(topicIds);
var result = [];
_.each(topics, function (topic) {
var parent = topic.getParent();
var found = false;
while (parent != null && !found) {
found = topicIds.contains(parent.getId());
if (found) {
break;
}
parent = parent.getParent();
}
if (!found) {
result.push(topic);
}
});
return result;
},
_collectInDepthRelationships:function (topic) {
var result = [];
result.append(topic.getRelationships());
var children = topic.getChildren();
var rels = children.map(function (topic) {
return this._collectInDepthRelationships(topic);
}, this);
result.append(rels.flatten());
if (result.length > 0) {
// Filter for unique ...
result = result.sort(function (a, b) {
return a.getModel().getId() - b.getModel().getId();
});
var ret = [result[0]];
for (var i = 1; i < result.length; i++) { // start loop at 1 as element 0 can never be a duplicate
if (result[i - 1] !== result[i]) {
ret.push(result[i]);
}
}
result = ret;
}
return result;
// Finally, delete the topic from the workspace...
commandContext.deleteTopic(topic);
}, this);
}
const rels = commandContext.findRelationships(this._relIds);
if (rels.length > 0) {
_.each(rels, function (rel) {
this._deletedRelModel.push(rel.getModel().clone());
commandContext.deleteRelationship(rel);
}, this);
}
},
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute(commandContext) {
// Add all the topics ...
_.each(this._deletedTopicModels, (model) => {
commandContext.createTopic(model);
}, this);
// Do they need to be connected ?
_.each(this._deletedTopicModels, function (topicModel, index) {
const topics = commandContext.findTopics(topicModel.getId());
const parentId = this._parentTopicIds[index];
if (parentId) {
const parentTopics = commandContext.findTopics(parentId);
commandContext.connect(topics[0], parentTopics[0]);
}
}, this);
// Add rebuild relationships ...
_.each(this._deletedRelModel, (model) => {
commandContext.addRelationship(model);
});
// Finally display the topics ...
_.each(this._deletedTopicModels, (topicModel) => {
const topics = commandContext.findTopics(topicModel.getId());
topics[0].setBranchVisibility(true);
}, this);
// Focus on last recovered topic ..
if (this._deletedTopicModels.length > 0) {
const firstTopic = this._deletedTopicModels[0];
const topic = commandContext.findTopics(firstTopic.getId())[0];
topic.setOnFocus(true);
}
this._deletedTopicModels = [];
this._parentTopicIds = [];
this._deletedRelModel = [];
},
_filterChildren(topicIds, commandContext) {
const topics = commandContext.findTopics(topicIds);
const result = [];
_.each(topics, (topic) => {
let parent = topic.getParent();
let found = false;
while (parent != null && !found) {
found = topicIds.contains(parent.getId());
if (found) {
break;
}
parent = parent.getParent();
}
if (!found) {
result.push(topic);
}
});
return result;
},
_collectInDepthRelationships(topic) {
let result = [];
result.append(topic.getRelationships());
const children = topic.getChildren();
const rels = children.map(function (topic) {
return this._collectInDepthRelationships(topic);
}, this);
result.append(rels.flatten());
if (result.length > 0) {
// Filter for unique ...
result = result.sort((a, b) => a.getModel().getId() - b.getModel().getId());
const ret = [result[0]];
for (let i = 1; i < result.length; i++) { // start loop at 1 as element 0 can never be a duplicate
if (result[i - 1] !== result[i]) {
ret.push(result[i]);
}
}
result = ret;
}
return result;
},
});
export default DeleteCommand;

130
packages/mindplot/lib/components/commands/DragTopicCommand.js
View File

@ -15,11 +15,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const Command = require('../Command').default
const Command = require('../Command').default;
const DragTopicCommand = new Class(/** @lends DragTopicCommand */{
Extends:Command,
/**
Extends: Command,
/**
* @classdesc This command class handles do/undo of dragging a topic to a new position.
* @constructs
* @param {String} topicId id of the topic to drag
@ -28,76 +28,72 @@ const DragTopicCommand = new Class(/** @lends DragTopicCommand */{
* @param {mindplot.Topic} parentTopic the topic to be made the dragged topic's new parent
* @extends mindplot.Command
*/
initialize:function (topicId, position, order, parentTopic) {
$assert(topicId, "topicId must be defined");
initialize(topicId, position, order, parentTopic) {
$assert(topicId, 'topicId must be defined');
this._topicsId = topicId;
if ($defined(parentTopic))
this._parentId = parentTopic.getId();
this._topicsId = topicId;
if ($defined(parentTopic)) this._parentId = parentTopic.getId();
this.parent();
this._position = position;
this._order = order;
},
this.parent();
this._position = position;
this._order = order;
},
/**
* Overrides abstract parent method
*/
execute:function (commandContext) {
var topic = commandContext.findTopics(this._topicsId)[0];
topic.setVisibility(false);
// Save old position ...
var origParentTopic = topic.getOutgoingConnectedTopic();
// In this case, topics are positioned using order ...
var origOrder = topic.getOrder();
var origPosition = topic.getPosition();
// Disconnect topic ..
if ($defined(origParentTopic) && origParentTopic != this._parentId) {
commandContext.disconnect(topic);
}
// Set topic order ...
if (this._order != null) {
topic.setOrder(this._order);
} else if (this._position != null) {
commandContext.moveTopic(topic, this._position);
} else {
$assert("Illegal command state exception.");
}
// Finally, connect topic ...
if (origParentTopic != this._parentId) {
if ($defined(this._parentId)) {
var parentTopic = commandContext.findTopics(this._parentId)[0];
commandContext.connect(topic, parentTopic);
}
// Backup old parent id ...
this._parentId = null;
if ($defined(origParentTopic)) {
this._parentId = origParentTopic.getId();
}
}
topic.setVisibility(true);
// Store for undo ...
this._order = origOrder;
this._position = origPosition;
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute:function (commandContext) {
this.execute(commandContext);
execute(commandContext) {
const topic = commandContext.findTopics(this._topicsId)[0];
topic.setVisibility(false);
// Save old position ...
const origParentTopic = topic.getOutgoingConnectedTopic();
// In this case, topics are positioned using order ...
const origOrder = topic.getOrder();
const origPosition = topic.getPosition();
// Disconnect topic ..
if ($defined(origParentTopic) && origParentTopic != this._parentId) {
commandContext.disconnect(topic);
}
// Set topic order ...
if (this._order != null) {
topic.setOrder(this._order);
} else if (this._position != null) {
commandContext.moveTopic(topic, this._position);
} else {
$assert('Illegal command state exception.');
}
// Finally, connect topic ...
if (origParentTopic != this._parentId) {
if ($defined(this._parentId)) {
const parentTopic = commandContext.findTopics(this._parentId)[0];
commandContext.connect(topic, parentTopic);
}
// Backup old parent id ...
this._parentId = null;
if ($defined(origParentTopic)) {
this._parentId = origParentTopic.getId();
}
}
topic.setVisibility(true);
// Store for undo ...
this._order = origOrder;
this._position = origPosition;
},
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute(commandContext) {
this.execute(commandContext);
},
});
export default DragTopicCommand;

124
packages/mindplot/lib/components/commands/GenericFunctionCommand.js
View File

@ -15,13 +15,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const Command = require('../Command').default
const Command = require('../Command').default;
const GenericFunctionCommand = new Class(/** @lends GenericFunctionCommand */{
Extends:Command,
/**
* @classdesc This command handles do/undo of different actions, e.g. moving topics to
* a different position, changing text or font,... (for full reference check the
Extends: Command,
/**
* @classdesc This command handles do/undo of different actions, e.g. moving topics to
* a different position, changing text or font,... (for full reference check the
* StandaloneActionDispatcher i.e. the ActionDispatcher subclass in use)
* @constructs
* @param {Function} commandFunc the function the command shall execute
@ -30,70 +30,66 @@ const GenericFunctionCommand = new Class(/** @lends GenericFunctionCommand */{
* e.g. color, font family or text
* @extends mindplot.Command
*/
initialize:function (commandFunc, topicsIds, value) {
$assert(commandFunc, "commandFunc must be defined");
$assert($defined(topicsIds), "topicsIds must be defined");
initialize(commandFunc, topicsIds, value) {
$assert(commandFunc, 'commandFunc must be defined');
$assert($defined(topicsIds), 'topicsIds must be defined');
this.parent();
this._value = value;
this._topicsId = topicsIds;
this._commandFunc = commandFunc;
this._oldValues = [];
},
this.parent();
this._value = value;
this._topicsId = topicsIds;
this._commandFunc = commandFunc;
this._oldValues = [];
},
/**
* Overrides abstract parent method
*/
execute:function (commandContext) {
if (!this.applied) {
var topics = null;
try {
topics = commandContext.findTopics(this._topicsId);
} catch (e) {
if (this._commandFunc.commandType != "changeTextToTopic") {
// Workaround: For some reason, there is a combination of events that involves
// making some modification and firing out of focus event. This is causing
// that a remove node try to be removed. In some other life, I will come with the solution.
// Almost aways occurs with IE9. I could be related with some change of order in sets o something similar.
throw e;
}
}
if (topics != null) {
var me = this;
_.each(topics, function (topic) {
var oldValue = me._commandFunc(topic, me._value);
me._oldValues.push(oldValue);
});
}
this.applied = true;
} else {
throw "Command can not be applied two times in a row.";
}
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute:function (commandContext) {
if (this.applied) {
var topics = commandContext.findTopics(this._topicsId);
var me = this;
_.each(topics, function (topic, index) {
me._commandFunc(topic, me._oldValues[index]);
});
this.applied = false;
this._oldValues = [];
} else {
throw "undo can not be applied.";
execute(commandContext) {
if (!this.applied) {
let topics = null;
try {
topics = commandContext.findTopics(this._topicsId);
} catch (e) {
if (this._commandFunc.commandType != 'changeTextToTopic') {
// Workaround: For some reason, there is a combination of events that involves
// making some modification and firing out of focus event. This is causing
// that a remove node try to be removed. In some other life, I will come with the solution.
// Almost aways occurs with IE9. I could be related with some change of order in sets o something similar.
throw e;
}
}
if (topics != null) {
const me = this;
_.each(topics, (topic) => {
const oldValue = me._commandFunc(topic, me._value);
me._oldValues.push(oldValue);
});
}
this.applied = true;
} else {
throw 'Command can not be applied two times in a row.';
}
},
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute(commandContext) {
if (this.applied) {
const topics = commandContext.findTopics(this._topicsId);
const me = this;
_.each(topics, (topic, index) => {
me._commandFunc(topic, me._oldValues[index]);
});
this.applied = false;
this._oldValues = [];
} else {
throw 'undo can not be applied.';
}
},
});
export default GenericFunctionCommand
export default GenericFunctionCommand;

155
packages/mindplot/lib/components/commands/MoveControlPointCommand.js
View File

@ -18,9 +18,9 @@
const Command = require('../Command').default;
const MoveControlPointCommand = new Class(
/** @lends MoveControlPointCommand */ {
Extends: Command,
/**
/** @lends MoveControlPointCommand */ {
Extends: Command,
/**
* @classdesc This command handles do/undo of changing the control points of a relationship
* arrow. These are the two points that appear when the relationship is on focus. They
* influence how the arrow is drawn (not the source or the destination topic nor the arrow
@ -31,89 +31,88 @@ const MoveControlPointCommand = new Class(
* @param ctrlPointController {ControlPoint}
* @param point {Number} 0 for the destination control point, 1 for the source control point
*/
initialize: function (ctrlPointController, point) {
$assert(ctrlPointController, 'line can not be null');
$assert($defined(point), 'point can not be null');
initialize(ctrlPointController, point) {
$assert(ctrlPointController, 'line can not be null');
$assert($defined(point), 'point can not be null');
this.parent();
this._ctrlPointControler = ctrlPointController;
this._line = ctrlPointController._line;
this._controlPoint = this._ctrlPointControler.getControlPoint(point).clone();
this._oldControlPoint = this._ctrlPointControler.getOriginalCtrlPoint(point).clone();
this._originalEndPoint = this._ctrlPointControler.getOriginalEndPoint(point).clone();
switch (point) {
case 0:
this._wasCustom = this._line.getLine().isSrcControlPointCustom();
this._endPoint = this._line.getLine().getFrom().clone();
break;
case 1:
this._wasCustom = this._line.getLine().isDestControlPointCustom();
this._endPoint = this._line.getLine().getTo().clone();
break;
}
this._point = point;
},
this.parent();
this._ctrlPointControler = ctrlPointController;
this._line = ctrlPointController._line;
this._controlPoint = this._ctrlPointControler.getControlPoint(point).clone();
this._oldControlPoint = this._ctrlPointControler.getOriginalCtrlPoint(point).clone();
this._originalEndPoint = this._ctrlPointControler.getOriginalEndPoint(point).clone();
switch (point) {
case 0:
this._wasCustom = this._line.getLine().isSrcControlPointCustom();
this._endPoint = this._line.getLine().getFrom().clone();
break;
case 1:
this._wasCustom = this._line.getLine().isDestControlPointCustom();
this._endPoint = this._line.getLine().getTo().clone();
break;
}
this._point = point;
},
/**
/**
* Overrides abstract parent method
*/
execute: function (commandContext) {
var model = this._line.getModel();
switch (this._point) {
case 0:
model.setSrcCtrlPoint(this._controlPoint.clone());
this._line.setFrom(this._endPoint.x, this._endPoint.y);
this._line.setIsSrcControlPointCustom(true);
this._line.setSrcControlPoint(this._controlPoint.clone());
break;
case 1:
model.setDestCtrlPoint(this._controlPoint.clone());
this._wasCustom = this._line.getLine().isDestControlPointCustom();
this._line.setTo(this._endPoint.x, this._endPoint.y);
this._line.setIsDestControlPointCustom(true);
this._line.setDestControlPoint(this._controlPoint.clone());
break;
}
if (this._line.isOnFocus()) {
this._line._refreshShape();
this._ctrlPointControler.setLine(this._line);
}
this._line.getLine().updateLine(this._point);
},
execute(commandContext) {
const model = this._line.getModel();
switch (this._point) {
case 0:
model.setSrcCtrlPoint(this._controlPoint.clone());
this._line.setFrom(this._endPoint.x, this._endPoint.y);
this._line.setIsSrcControlPointCustom(true);
this._line.setSrcControlPoint(this._controlPoint.clone());
break;
case 1:
model.setDestCtrlPoint(this._controlPoint.clone());
this._wasCustom = this._line.getLine().isDestControlPointCustom();
this._line.setTo(this._endPoint.x, this._endPoint.y);
this._line.setIsDestControlPointCustom(true);
this._line.setDestControlPoint(this._controlPoint.clone());
break;
}
if (this._line.isOnFocus()) {
this._line._refreshShape();
this._ctrlPointControler.setLine(this._line);
}
this._line.getLine().updateLine(this._point);
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute: function (commandContext) {
var line = this._line;
var model = line.getModel();
switch (this._point) {
case 0:
if ($defined(this._oldControlPoint)) {
line.setFrom(this._originalEndPoint.x, this._originalEndPoint.y);
model.setSrcCtrlPoint(this._oldControlPoint.clone());
line.setSrcControlPoint(this._oldControlPoint.clone());
line.setIsSrcControlPointCustom(this._wasCustom);
}
break;
case 1:
if ($defined(this._oldControlPoint)) {
line.setTo(this._originalEndPoint.x, this._originalEndPoint.y);
model.setDestCtrlPoint(this._oldControlPoint.clone());
line.setDestControlPoint(this._oldControlPoint.clone());
line.setIsDestControlPointCustom(this._wasCustom);
}
break;
}
this._line.getLine().updateLine(this._point);
if (this._line.isOnFocus()) {
this._ctrlPointControler.setLine(line);
line._refreshShape();
}
},
}
undoExecute(commandContext) {
const line = this._line;
const model = line.getModel();
switch (this._point) {
case 0:
if ($defined(this._oldControlPoint)) {
line.setFrom(this._originalEndPoint.x, this._originalEndPoint.y);
model.setSrcCtrlPoint(this._oldControlPoint.clone());
line.setSrcControlPoint(this._oldControlPoint.clone());
line.setIsSrcControlPointCustom(this._wasCustom);
}
break;
case 1:
if ($defined(this._oldControlPoint)) {
line.setTo(this._originalEndPoint.x, this._originalEndPoint.y);
model.setDestCtrlPoint(this._oldControlPoint.clone());
line.setDestControlPoint(this._oldControlPoint.clone());
line.setIsDestControlPointCustom(this._wasCustom);
}
break;
}
this._line.getLine().updateLine(this._point);
if (this._line.isOnFocus()) {
this._ctrlPointControler.setLine(line);
line._refreshShape();
}
},
},
);
export default MoveControlPointCommand;

58
packages/mindplot/lib/components/commands/RemoveFeatureFromTopicCommand.js
View File

@ -17,45 +17,45 @@
*/
const Command = require('../Command').default;
const RemoveFeatureFromTopicCommand = new Class(/**@lends RemoveFeatureFromTopicCommand */{
Extends:Command,
/**
* @classdesc This command handles do/undo of removing a feature from a topic, e.g. an icon or
const RemoveFeatureFromTopicCommand = new Class(/** @lends RemoveFeatureFromTopicCommand */{
Extends: Command,
/**
* @classdesc This command handles do/undo of removing a feature from a topic, e.g. an icon or
* a note. For a reference of existing features, refer to {@link mindplot.TopicFeature}.
* @constructs
* @param {String} topicId id of the topic to remove the feature from
* @param {String} featureId id of the feature to remove
* @extends mindplot.Command
*/
initialize:function (topicId, featureId) {
$assert($defined(topicId), 'topicId can not be null');
$assert(featureId, 'iconModel can not be null');
initialize(topicId, featureId) {
$assert($defined(topicId), 'topicId can not be null');
$assert(featureId, 'iconModel can not be null');
this.parent();
this._topicId = topicId;
this._featureId = featureId;
this._oldFeature = null;
},
this.parent();
this._topicId = topicId;
this._featureId = featureId;
this._oldFeature = null;
},
/**
* Overrides abstract parent method
*/
execute:function (commandContext) {
var topic = commandContext.findTopics(this._topicId)[0];
var feature = topic.findFeatureById(this._featureId);
topic.removeFeature(feature);
this._oldFeature = feature;
},
/**
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute:function (commandContext) {
var topic = commandContext.findTopics(this._topicId)[0];
topic.addFeature(this._oldFeature);
this._oldFeature = null;
}
execute(commandContext) {
const topic = commandContext.findTopics(this._topicId)[0];
const feature = topic.findFeatureById(this._featureId);
topic.removeFeature(feature);
this._oldFeature = feature;
},
/**
* Overrides abstract parent method
* @see {@link mindplot.Command.undoExecute}
*/
undoExecute(commandContext) {
const topic = commandContext.findTopics(this._topicId)[0];
topic.addFeature(this._oldFeature);
this._oldFeature = null;
},
});
export default RemoveFeatureFromTopicCommand;

18
packages/mindplot/lib/components/commands/index.js
View File

@ -9,13 +9,13 @@ const moveControlPointCommand = require('./MoveControlPointCommand').default;
const removeFeatureFromTopicCommand = require('./RemoveFeatureFromTopicCommand').default;
export const Commands = {
AddFeatureToTopicCommand: addFeatureToTopicCommand,
AddRelationshipCommand: addRelationshipCommand,
AddTopicCommand: addTopicCommand,
ChangeFeatureToTopicCommand: changeFeatureToTopicCommand,
DeleteCommand: deleteCommand,
DragTopicCommand: dragTopicCommand,
GenericFunctionCommand: genericFunctionCommand,
MoveControlPointCommand: moveControlPointCommand,
RemoveFeatureFromTopicCommand: removeFeatureFromTopicCommand,
AddFeatureToTopicCommand: addFeatureToTopicCommand,
AddRelationshipCommand: addRelationshipCommand,
AddTopicCommand: addTopicCommand,
ChangeFeatureToTopicCommand: changeFeatureToTopicCommand,
DeleteCommand: deleteCommand,
DragTopicCommand: dragTopicCommand,
GenericFunctionCommand: genericFunctionCommand,
MoveControlPointCommand: moveControlPointCommand,
RemoveFeatureFromTopicCommand: removeFeatureFromTopicCommand,
};

4
packages/mindplot/lib/components/footer.js
View File

@ -1,5 +1,5 @@
try {
$(document).trigger('loadcomplete', 'mind');
$(document).trigger('loadcomplete', 'mind');
} catch (e) {
console.error(e.stack);
console.error(e.stack);
}

4
packages/mindplot/lib/components/header.js
View File

@ -16,7 +16,7 @@
* limitations under the License.
*/
var mindplot = {};
const mindplot = {};
mindplot.util = {};
mindplot.commands = {};
mindplot.layout = {};
@ -31,5 +31,5 @@ mindplot.persistence = {};
mindplot.layout = {};
Class.Mutators.Static = function (items) {
this.extend(items);
this.extend(items);
};

92
packages/mindplot/lib/components/index.js
View File

@ -50,59 +50,59 @@ const topicStyle = require('./TopicStyle').default;
const workspace = require('./Workspace').default;
export const Components = {
ActionDispatcher: actionDispatcher,
ActionDispatcher: actionDispatcher,
ActionIcon: actionIcon,
CentralTopic: centralTopic,
Command: command,
ConnectionLine: connectionLine,
ControlPoint: controlPoint,
Designer: designer,
ActionIcon: actionIcon,
CentralTopic: centralTopic,
Command: command,
ConnectionLine: connectionLine,
ControlPoint: controlPoint,
Designer: designer,
DesignerActionRunner: designerActionRunner,
DesignerKeyboard: designerKeyboard,
DesignerModel: designerModal,
DesignerUndoManager: designerUndoManager,
DesignerActionRunner: designerActionRunner,
DesignerKeyboard: designerKeyboard,
DesignerModel: designerModal,
DesignerUndoManager: designerUndoManager,
DragConnector: dragConnector,
DragManager: dragManager,
DragPivot: dragPivot,
DragTopic: dragTopic,
EditorOptions: editorOptions,
EditorProperties: editorProperties,
Events: events,
DragConnector: dragConnector,
DragManager: dragManager,
DragPivot: dragPivot,
DragTopic: dragTopic,
EditorOptions: editorOptions,
EditorProperties: editorProperties,
Events: events,
footer: footer,
header: header,
footer,
header,
Icon: icon,
IconGroup: iconGroup,
ImageIcon: imageIcon,
Keyboard: keyboard,
LinkIcon: linkIcon,
Icon: icon,
IconGroup: iconGroup,
ImageIcon: imageIcon,
Keyboard: keyboard,
LinkIcon: linkIcon,
localSorageManager: localSorageManager,
MainTopic: mainTopic,
localSorageManager,
MainTopic: mainTopic,
Messages: messages,
MultilineTextEditor: multilineTextEditor,
NodeGraph: nodeGraph,
NoteIcon: noteIcon,
Options: options,
Messages: messages,
MultilineTextEditor: multilineTextEditor,
NodeGraph: nodeGraph,
NoteIcon: noteIcon,
Options: options,
PersistenceManager: persistenceManager,
Relationship: relationship,
RelationshipPivot: relationshipPivot,
RestPersistenceManager: resetPersistenceManager,
ScreenManager: screenManager,
ShrinkConnector: shrinkConnector,
StandaloneActionDispatcher: standaloneActionDispatcher,
TextEditor: textEditor,
TextEditorFactory: textEditorFactory,
PersistenceManager: persistenceManager,
Relationship: relationship,
RelationshipPivot: relationshipPivot,
RestPersistenceManager: resetPersistenceManager,
ScreenManager: screenManager,
ShrinkConnector: shrinkConnector,
StandaloneActionDispatcher: standaloneActionDispatcher,
TextEditor: textEditor,
TextEditorFactory: textEditorFactory,
Topic: topic,
TopicEventDispatcher: topicEventDispatcher,
TopicFeature: topicFeature,
TopicStyle: topicStyle,
Workspace: workspace,
Topic: topic,
TopicEventDispatcher: topicEventDispatcher,
TopicFeature: topicFeature,
TopicStyle: topicStyle,
Workspace: workspace,
};

88
packages/mindplot/lib/components/layout/AbstractBasicSorter.js
View File

@ -22,64 +22,62 @@ const ChildrenSorterStrategy = require('./ChildrenSorterStrategy').default;
* @extends mindplot.layout.ChildrenSorterStrategy
*/
const AbstractBasicSorter = new Class(
/** @lends AbstractBasicSorter */ {
Extends: ChildrenSorterStrategy,
/** @lends AbstractBasicSorter */ {
Extends: ChildrenSorterStrategy,
/**
/**
* @param {} treeSet
* @param {} node
* @return the height of a node and its children if existing and not shrunken
*/
computeChildrenIdByHeights: function (treeSet, node) {
var result = {};
this._computeChildrenHeight(treeSet, node, result);
return result;
},
computeChildrenIdByHeights(treeSet, node) {
const result = {};
this._computeChildrenHeight(treeSet, node, result);
return result;
},
_getVerticalPadding: function () {
return AbstractBasicSorter.INTERNODE_VERTICAL_PADDING;
},
_getVerticalPadding() {
return AbstractBasicSorter.INTERNODE_VERTICAL_PADDING;
},
_computeChildrenHeight: function (treeSet, node, heightCache) {
var height = node.getSize().height + this._getVerticalPadding() * 2; // 2* Top and down padding;
_computeChildrenHeight(treeSet, node, heightCache) {
const height = node.getSize().height + this._getVerticalPadding() * 2; // 2* Top and down padding;
var result;
var children = treeSet.getChildren(node);
if (children.length == 0 || node.areChildrenShrunken()) {
result = height;
} else {
var childrenHeight = 0;
_.each(
children,
function (child) {
childrenHeight += this._computeChildrenHeight(treeSet, child, heightCache);
},
this
);
let result;
const children = treeSet.getChildren(node);
if (children.length == 0 || node.areChildrenShrunken()) {
result = height;
} else {
let childrenHeight = 0;
_.each(
children,
function (child) {
childrenHeight += this._computeChildrenHeight(treeSet, child, heightCache);
},
this,
);
result = Math.max(height, childrenHeight);
}
result = Math.max(height, childrenHeight);
}
if (heightCache) {
heightCache[node.getId()] = result;
}
if (heightCache) {
heightCache[node.getId()] = result;
}
return result;
},
return result;
},
_getSortedChildren: function (treeSet, node) {
var result = treeSet.getChildren(node);
result.sort(function (a, b) {
return a.getOrder() - b.getOrder();
});
return result;
},
_getSortedChildren(treeSet, node) {
const result = treeSet.getChildren(node);
result.sort((a, b) => a.getOrder() - b.getOrder());
return result;
},
_getRelativeDirection: function (reference, position) {
var offset = position.x - reference.x;
return offset >= 0 ? 1 : -1;
},
}
_getRelativeDirection(reference, position) {
const offset = position.x - reference.x;
return offset >= 0 ? 1 : -1;
},
},
);
/**

464
packages/mindplot/lib/components/layout/BalancedSorter.js
View File

@ -18,15 +18,15 @@
const AbstractBasicSorter = require('./AbstractBasicSorter').default;
const BalancedSorter = new Class(
/** @lends BalancedSorter */ {
Extends: AbstractBasicSorter,
/**
/** @lends BalancedSorter */ {
Extends: AbstractBasicSorter,
/**
* @constructs
* @extends mindplot.layout.AbstractBasicSorter
*/
initialize: function () {},
initialize() {},
/**
/**
* @param {} graph
* @param {} parent
* @param {} node
@ -34,294 +34,286 @@ const BalancedSorter = new Class(
* @param {Boolean} free
* @return an array with order and position
*/
predict: function (graph, parent, node, position, free) {
// If its a free node...
if (free) {
$assert(
$defined(position),
'position cannot be null for predict in free positioning'
);
$assert($defined(node), 'node cannot be null for predict in free positioning');
predict(graph, parent, node, position, free) {
// If its a free node...
if (free) {
$assert(
$defined(position),
'position cannot be null for predict in free positioning',
);
$assert($defined(node), 'node cannot be null for predict in free positioning');
var rootNode = graph.getRootNode(parent);
var direction = this._getRelativeDirection(
rootNode.getPosition(),
node.getPosition()
);
var rootNode = graph.getRootNode(parent);
var direction = this._getRelativeDirection(
rootNode.getPosition(),
node.getPosition(),
);
var limitXPos =
parent.getPosition().x +
direction *
(parent.getSize().width / 2 +
node.getSize().width / 2 +
BalancedSorter.INTERNODE_HORIZONTAL_PADDING);
const limitXPos = parent.getPosition().x
+ direction
* (parent.getSize().width / 2
+ node.getSize().width / 2
+ BalancedSorter.INTERNODE_HORIZONTAL_PADDING);
var xPos =
direction > 0
? position.x >= limitXPos
? position.x
: limitXPos
: position.x <= limitXPos
? position.x
: limitXPos;
const xPos = direction > 0
? position.x >= limitXPos
? position.x
: limitXPos
: position.x <= limitXPos
? position.x
: limitXPos;
return [0, { x: xPos, y: position.y }];
}
return [0, { x: xPos, y: position.y }];
}
var rootNode = graph.getRootNode(parent);
var rootNode = graph.getRootNode(parent);
// If it is a dragged node...
if (node) {
$assert($defined(position), 'position cannot be null for predict in dragging');
var nodeDirection = this._getRelativeDirection(
rootNode.getPosition(),
node.getPosition()
);
var positionDirection = this._getRelativeDirection(
rootNode.getPosition(),
position
);
var siblings = graph.getSiblings(node);
// If it is a dragged node...
if (node) {
$assert($defined(position), 'position cannot be null for predict in dragging');
const nodeDirection = this._getRelativeDirection(
rootNode.getPosition(),
node.getPosition(),
);
const positionDirection = this._getRelativeDirection(
rootNode.getPosition(),
position,
);
const siblings = graph.getSiblings(node);
var sameParent = parent == graph.getParent(node);
if (siblings.length == 0 && nodeDirection == positionDirection && sameParent) {
return [node.getOrder(), node.getPosition()];
}
}
const sameParent = parent == graph.getParent(node);
if (siblings.length == 0 && nodeDirection == positionDirection && sameParent) {
return [node.getOrder(), node.getPosition()];
}
}
if (!position) {
var right = this._getChildrenForOrder(parent, graph, 0);
var left = this._getChildrenForOrder(parent, graph, 1);
}
// Filter nodes on one side..
var order = position
? position.x > rootNode.getPosition().x
? 0
: 1
: right.length - left.length > 0
? 1
: 0;
var direction = order % 2 == 0 ? 1 : -1;
if (!position) {
var right = this._getChildrenForOrder(parent, graph, 0);
var left = this._getChildrenForOrder(parent, graph, 1);
}
// Filter nodes on one side..
const order = position
? position.x > rootNode.getPosition().x
? 0
: 1
: right.length - left.length > 0
? 1
: 0;
var direction = order % 2 == 0 ? 1 : -1;
// Exclude the dragged node (if set)
var children = this._getChildrenForOrder(parent, graph, order).filter(function (child) {
return child != node;
});
// Exclude the dragged node (if set)
const children = this._getChildrenForOrder(parent, graph, order).filter((child) => child != node);
// No children?
if (children.length == 0) {
return [
order,
{
x:
parent.getPosition().x +
direction *
(parent.getSize().width / 2 +
BalancedSorter.INTERNODE_HORIZONTAL_PADDING * 2),
y: parent.getPosition().y,
},
];
}
// No children?
if (children.length == 0) {
return [
order,
{
x:
parent.getPosition().x
+ direction
* (parent.getSize().width / 2
+ BalancedSorter.INTERNODE_HORIZONTAL_PADDING * 2),
y: parent.getPosition().y,
},
];
}
// Try to fit within ...
var result = null;
var last = children.getLast();
position = position || { x: last.getPosition().x, y: last.getPosition().y + 1 };
_.each(children, function (child, index) {
var cpos = child.getPosition();
if (position.y > cpos.y) {
let yOffset =
child == last
? child.getSize().height + BalancedSorter.INTERNODE_VERTICAL_PADDING * 2
: (children[index + 1].getPosition().y - child.getPosition().y) / 2;
result = [child.getOrder() + 2, { x: cpos.x, y: cpos.y + yOffset }];
}
});
// Try to fit within ...
let result = null;
const last = children.getLast();
position = position || { x: last.getPosition().x, y: last.getPosition().y + 1 };
_.each(children, (child, index) => {
const cpos = child.getPosition();
if (position.y > cpos.y) {
const yOffset = child == last
? child.getSize().height + BalancedSorter.INTERNODE_VERTICAL_PADDING * 2
: (children[index + 1].getPosition().y - child.getPosition().y) / 2;
result = [child.getOrder() + 2, { x: cpos.x, y: cpos.y + yOffset }];
}
});
// Position wasn't below any node, so it must be inserted above
if (!result) {
var first = children[0];
result = [
position.x > 0 ? 0 : 1,
{
x: first.getPosition().x,
y:
first.getPosition().y -
first.getSize().height -
BalancedSorter.INTERNODE_VERTICAL_PADDING * 2,
},
];
}
// Position wasn't below any node, so it must be inserted above
if (!result) {
const first = children[0];
result = [
position.x > 0 ? 0 : 1,
{
x: first.getPosition().x,
y:
first.getPosition().y
- first.getSize().height
- BalancedSorter.INTERNODE_VERTICAL_PADDING * 2,
},
];
}
return result;
},
return result;
},
/**
/**
* @param {} treeSet
* @param {} parent
* @param {} child
* @param {} order
*/
insert: function (treeSet, parent, child, order) {
var children = this._getChildrenForOrder(parent, treeSet, order);
insert(treeSet, parent, child, order) {
const children = this._getChildrenForOrder(parent, treeSet, order);
// If no children, return 0 or 1 depending on the side
if (children.length == 0) {
child.setOrder(order % 2);
return;
}
// If no children, return 0 or 1 depending on the side
if (children.length == 0) {
child.setOrder(order % 2);
return;
}
// Shift all the elements by two, so side is the same.
// In case of balanced sorter, order don't need to be continuous...
var max = 0;
for (var i = 0; i < children.length; i++) {
var node = children[i];
max = Math.max(max, node.getOrder());
if (node.getOrder() >= order) {
max = Math.max(max, node.getOrder() + 2);
node.setOrder(node.getOrder() + 2);
}
}
// Shift all the elements by two, so side is the same.
// In case of balanced sorter, order don't need to be continuous...
let max = 0;
for (let i = 0; i < children.length; i++) {
const node = children[i];
max = Math.max(max, node.getOrder());
if (node.getOrder() >= order) {
max = Math.max(max, node.getOrder() + 2);
node.setOrder(node.getOrder() + 2);
}
}
var newOrder = order > max + 1 ? max + 2 : order;
child.setOrder(newOrder);
},
const newOrder = order > max + 1 ? max + 2 : order;
child.setOrder(newOrder);
},
/**
/**
* @param {} treeSet
* @param {} node
*/
detach: function (treeSet, node) {
var parent = treeSet.getParent(node);
// Filter nodes on one side..
var children = this._getChildrenForOrder(parent, treeSet, node.getOrder());
detach(treeSet, node) {
const parent = treeSet.getParent(node);
// Filter nodes on one side..
const children = this._getChildrenForOrder(parent, treeSet, node.getOrder());
_.each(children, function (child, index) {
if (child.getOrder() > node.getOrder()) {
child.setOrder(child.getOrder() - 2);
}
});
node.setOrder(node.getOrder() % 2 == 0 ? 0 : 1);
},
_.each(children, (child, index) => {
if (child.getOrder() > node.getOrder()) {
child.setOrder(child.getOrder() - 2);
}
});
node.setOrder(node.getOrder() % 2 == 0 ? 0 : 1);
},
/**
/**
* @param {} treeSet
* @param {} node
* @return offsets
*/
computeOffsets: function (treeSet, node) {
$assert(treeSet, 'treeSet can no be null.');
$assert(node, 'node can no be null.');
computeOffsets(treeSet, node) {
$assert(treeSet, 'treeSet can no be null.');
$assert(node, 'node can no be null.');
var children = this._getSortedChildren(treeSet, node);
const children = this._getSortedChildren(treeSet, node);
// Compute heights ...
var heights = children
.map(function (child) {
return {
id: child.getId(),
order: child.getOrder(),
width: child.getSize().width,
height: this._computeChildrenHeight(treeSet, child),
};
}, this)
.reverse();
// Compute heights ...
const heights = children
.map(function (child) {
return {
id: child.getId(),
order: child.getOrder(),
width: child.getSize().width,
height: this._computeChildrenHeight(treeSet, child),
};
}, this)
.reverse();
// Compute the center of the branch ...
var totalPHeight = 0;
var totalNHeight = 0;
// Compute the center of the branch ...
let totalPHeight = 0;
let totalNHeight = 0;
_.each(heights, function (elem) {
if (elem.order % 2 == 0) {
totalPHeight += elem.height;
} else {
totalNHeight += elem.height;
}
});
var psum = totalPHeight / 2;
var nsum = totalNHeight / 2;
var ysum = 0;
_.each(heights, (elem) => {
if (elem.order % 2 == 0) {
totalPHeight += elem.height;
} else {
totalNHeight += elem.height;
}
});
let psum = totalPHeight / 2;
let nsum = totalNHeight / 2;
let ysum = 0;
// Calculate the offsets ...
var result = {};
for (var i = 0; i < heights.length; i++) {
var direction = heights[i].order % 2 ? -1 : 1;
// Calculate the offsets ...
const result = {};
for (let i = 0; i < heights.length; i++) {
const direction = heights[i].order % 2 ? -1 : 1;
if (direction > 0) {
psum = psum - heights[i].height;
ysum = psum;
} else {
nsum = nsum - heights[i].height;
ysum = nsum;
}
if (direction > 0) {
psum -= heights[i].height;
ysum = psum;
} else {
nsum -= heights[i].height;
ysum = nsum;
}
var yOffset = ysum + heights[i].height / 2;
var xOffset =
direction *
(node.getSize().width / 2 +
heights[i].width / 2 +
+BalancedSorter.INTERNODE_HORIZONTAL_PADDING);
const yOffset = ysum + heights[i].height / 2;
const xOffset = direction
* (node.getSize().width / 2
+ heights[i].width / 2
+ +BalancedSorter.INTERNODE_HORIZONTAL_PADDING);
$assert(!isNaN(xOffset), 'xOffset can not be null');
$assert(!isNaN(yOffset), 'yOffset can not be null');
$assert(!isNaN(xOffset), 'xOffset can not be null');
$assert(!isNaN(yOffset), 'yOffset can not be null');
result[heights[i].id] = { x: xOffset, y: yOffset };
}
return result;
},
result[heights[i].id] = { x: xOffset, y: yOffset };
}
return result;
},
/**
/**
* @param {} treeSet
* @param {} node
* @throw will throw an error if order elements are missing
*/
verify: function (treeSet, node) {
// Check that all is consistent ...
var children = this._getChildrenForOrder(node, treeSet, node.getOrder());
verify(treeSet, node) {
// Check that all is consistent ...
const children = this._getChildrenForOrder(node, treeSet, node.getOrder());
// All odd ordered nodes should be "continuous" by themselves
// All even numbered nodes should be "continuous" by themselves
var factor = node.getOrder() % 2 == 0 ? 2 : 1;
for (var i = 0; i < children.length; i++) {
var order = i == 0 && factor == 1 ? 1 : factor * i;
$assert(
children[i].getOrder() == order,
'Missing order elements. Missing order: ' +
i * factor +
'. Parent:' +
node.getId() +
',Node:' +
children[i].getId()
);
}
},
// All odd ordered nodes should be "continuous" by themselves
// All even numbered nodes should be "continuous" by themselves
const factor = node.getOrder() % 2 == 0 ? 2 : 1;
for (let i = 0; i < children.length; i++) {
const order = i == 0 && factor == 1 ? 1 : factor * i;
$assert(
children[i].getOrder() == order,
`Missing order elements. Missing order: ${
i * factor
}. Parent:${
node.getId()
},Node:${
children[i].getId()}`,
);
}
},
/**
/**
* @param {} treeSet
* @param {} child
* @return the direction of the child within the treeSet
*/
getChildDirection: function (treeSet, child) {
return child.getOrder() % 2 == 0 ? 1 : -1;
},
getChildDirection(treeSet, child) {
return child.getOrder() % 2 == 0 ? 1 : -1;
},
/**
/**
* @return {String} the print name of this class
*/
toString: function () {
return 'Balanced Sorter';
},
toString() {
return 'Balanced Sorter';
},
_getChildrenForOrder: function (parent, graph, order) {
return this._getSortedChildren(graph, parent).filter(function (child) {
return child.getOrder() % 2 == order % 2;
});
},
_getChildrenForOrder(parent, graph, order) {
return this._getSortedChildren(graph, parent).filter((child) => child.getOrder() % 2 == order % 2);
},
_getVerticalPadding: function () {
return BalancedSorter.INTERNODE_VERTICAL_PADDING;
},
}
_getVerticalPadding() {
return BalancedSorter.INTERNODE_VERTICAL_PADDING;
},
},
);
/**

70
packages/mindplot/lib/components/layout/ChangeEvent.js
View File

@ -17,54 +17,54 @@
*/
const ChangeEvent = new Class(/** @lends ChangeEvent */{
/**
/**
* @constructs
* @param {} id
* @throws will throw an error if the given id is not/cannot be converted to a numerical value
*/
initialize:function(id) {
$assert(!isNaN(id), "id can not be null");
this._id = id;
this._position = null;
this._order = null;
},
initialize(id) {
$assert(!isNaN(id), 'id can not be null');
this._id = id;
this._position = null;
this._order = null;
},
/** @return id */
getId:function() {
return this._id;
},
/** @return id */
getId() {
return this._id;
},
/** @return order */
getOrder: function() {
return this._order;
},
/** @return order */
getOrder() {
return this._order;
},
/** @return position */
getPosition: function() {
return this._position;
},
/** @return position */
getPosition() {
return this._position;
},
/**
* @param {} value the order to set
/**
* @param {} value the order to set
* @throws will throw an error if the given parameter is not/cannot be converted to a numerical
* value
*/
setOrder: function(value) {
$assert(!isNaN(value), "value can not be null");
this._order = value;
},
setOrder(value) {
$assert(!isNaN(value), 'value can not be null');
this._order = value;
},
/** @param {} value
* @throws will throw an error if the value is null or undefined*/
setPosition: function(value) {
$assert(value, "value can not be null");
this._position = value;
},
/** @param {} value
* @throws will throw an error if the value is null or undefined */
setPosition(value) {
$assert(value, 'value can not be null');
this._position = value;
},
/** @return {String} order and position */
toString: function() {
return "[order:" + this.getOrder() + ", position: {" + this.getPosition().x + "," + this.getPosition().y + "}]";
}
/** @return {String} order and position */
toString() {
return `[order:${this.getOrder()}, position: {${this.getPosition().x},${this.getPosition().y}}]`;
},
});
export default ChangeEvent;

72
packages/mindplot/lib/components/layout/ChildrenSorterStrategy.js
View File

@ -17,53 +17,53 @@
*/
const ChildrenSorterStrategy = new Class(/** @lends ChildrenSorterStrategy */{
/**
/**
* @constructs
*/
initialize:function() {
initialize() {
},
},
/** @abstract */
computeChildrenIdByHeights: function(treeSet, node) {
throw "Method must be implemented";
},
/** @abstract */
computeChildrenIdByHeights(treeSet, node) {
throw 'Method must be implemented';
},
/** @abstract */
computeOffsets:function(treeSet, node) {
throw "Method must be implemented";
},
/** @abstract */
computeOffsets(treeSet, node) {
throw 'Method must be implemented';
},
/** @abstract */
insert: function(treeSet, parent, child, order) {
throw "Method must be implemented";
},
/** @abstract */
insert(treeSet, parent, child, order) {
throw 'Method must be implemented';
},
/** @abstract */
detach:function(treeSet, node) {
throw "Method must be implemented";
},
/** @abstract */
detach(treeSet, node) {
throw 'Method must be implemented';
},
/** @abstract */
predict:function(treeSet, parent, node, position, free) {
throw "Method must be implemented";
},
/** @abstract */
predict(treeSet, parent, node, position, free) {
throw 'Method must be implemented';
},
/** @abstract */
verify:function(treeSet, node) {
throw "Method must be implemented";
},
/** @abstract */
verify(treeSet, node) {
throw 'Method must be implemented';
},
/** @abstract */
getChildDirection: function(treeSet, node) {
throw "Method must be implemented";
},
/** @abstract */
getChildDirection(treeSet, node) {
throw 'Method must be implemented';
},
/** @abstract */
toString:function() {
throw "Method must be implemented: print name";
}
/** @abstract */
toString() {
throw 'Method must be implemented: print name';
},
});
export default ChildrenSorterStrategy
export default ChildrenSorterStrategy;

24
packages/mindplot/lib/components/layout/EventBus.js
View File

@ -18,13 +18,13 @@
const Events = require('../Events').default;
const EventBus = new Class(/** @lends EventBus */{
Implements: Events,
/**
Implements: Events,
/**
* @constructs
* @implements mindplot.Events
*/
initialize: function() {
}
initialize() {
},
});
/**
@ -32,14 +32,14 @@ const EventBus = new Class(/** @lends EventBus */{
* @enum {String}
*/
EventBus.events = {
NodeResizeEvent:'NodeResizeEvent',
NodeMoveEvent:'NodeMoveEvent',
NodeShrinkEvent:'NodeShrinkEvent',
NodeConnectEvent:'NodeConnectEvent',
NodeDisconnectEvent:'NodeDisconnectEvent',
NodeAdded:'NodeAdded',
NodeRemoved:'NodeRemoved',
DoLayout:'DoLayout'
NodeResizeEvent: 'NodeResizeEvent',
NodeMoveEvent: 'NodeMoveEvent',
NodeShrinkEvent: 'NodeShrinkEvent',
NodeConnectEvent: 'NodeConnectEvent',
NodeDisconnectEvent: 'NodeDisconnectEvent',
NodeAdded: 'NodeAdded',
NodeRemoved: 'NodeRemoved',
DoLayout: 'DoLayout',
};
/** instance */

123
packages/mindplot/lib/components/layout/EventBusDispatcher.js
View File

@ -15,85 +15,84 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const EventBus = require('./EventBus').default
const EventBus = require('./EventBus').default;
const EventBusDispatcher = new Class(/** @lends EventBusDispatcher */{
/**
/**
* @constructs
*/
initialize:function() {
this.registerBusEvents();
},
initialize() {
this.registerBusEvents();
},
/**
/**
* @param {mindplot.layout.LayoutManager} layoutManager
*/
setLayoutManager : function(layoutManager) {
this._layoutManager = layoutManager;
},
setLayoutManager(layoutManager) {
this._layoutManager = layoutManager;
},
/**
/**
* register bus events
*/
registerBusEvents:function () {
EventBus.instance.addEvent(EventBus.events.NodeAdded, this._nodeAdded.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeRemoved, this._nodeRemoved.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeResizeEvent, this._nodeResizeEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeMoveEvent, this._nodeMoveEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeDisconnectEvent, this._nodeDisconnectEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeConnectEvent, this._nodeConnectEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeShrinkEvent, this._nodeShrinkEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.DoLayout, this._doLayout.bind(this));
},
registerBusEvents() {
EventBus.instance.addEvent(EventBus.events.NodeAdded, this._nodeAdded.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeRemoved, this._nodeRemoved.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeResizeEvent, this._nodeResizeEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeMoveEvent, this._nodeMoveEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeDisconnectEvent, this._nodeDisconnectEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeConnectEvent, this._nodeConnectEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.NodeShrinkEvent, this._nodeShrinkEvent.bind(this));
EventBus.instance.addEvent(EventBus.events.DoLayout, this._doLayout.bind(this));
},
_nodeResizeEvent: function(args) {
this._layoutManager.updateNodeSize(args.node.getId(), args.size);
},
_nodeResizeEvent(args) {
this._layoutManager.updateNodeSize(args.node.getId(), args.size);
},
_nodeMoveEvent: function(args) {
this._layoutManager.moveNode(args.node.getId(), args.position);
},
_nodeMoveEvent(args) {
this._layoutManager.moveNode(args.node.getId(), args.position);
},
_nodeDisconnectEvent: function(node) {
this._layoutManager.disconnectNode(node.getId());
},
_nodeDisconnectEvent(node) {
this._layoutManager.disconnectNode(node.getId());
},
_nodeConnectEvent: function(args) {
this._layoutManager.connectNode(args.parentNode.getId(), args.childNode.getId(), args.childNode.getOrder());
_nodeConnectEvent(args) {
this._layoutManager.connectNode(args.parentNode.getId(), args.childNode.getId(), args.childNode.getOrder());
},
},
_nodeShrinkEvent(node) {
this._layoutManager.updateShrinkState(node.getId(), node.areChildrenShrunken());
},
_nodeShrinkEvent: function(node) {
this._layoutManager.updateShrinkState(node.getId(), node.areChildrenShrunken());
},
_nodeAdded: function(node) {
// Central topic must not be added twice ...
if (node.getId() != 0) {
this._layoutManager.addNode(node.getId(), {width:10,height:10}, node.getPosition());
this._layoutManager.updateShrinkState(node.getId(), node.areChildrenShrunken());
}
},
_nodeRemoved: function(node) {
this._layoutManager.removeNode(node.getId());
},
_doLayout: function() {
// (function() {
this._layoutManager.layout(true);
// console.log("---------");
// this._layoutManager.dump();
// console.log("---------");
// console.log("---------");
// }).delay(0, this);
},
/** @return layout manager */
getLayoutManager: function() {
return this._layoutManager;
_nodeAdded(node) {
// Central topic must not be added twice ...
if (node.getId() != 0) {
this._layoutManager.addNode(node.getId(), { width: 10, height: 10 }, node.getPosition());
this._layoutManager.updateShrinkState(node.getId(), node.areChildrenShrunken());
}
},
_nodeRemoved(node) {
this._layoutManager.removeNode(node.getId());
},
_doLayout() {
// (function() {
this._layoutManager.layout(true);
// console.log("---------");
// this._layoutManager.dump();
// console.log("---------");
// console.log("---------");
// }).delay(0, this);
},
/** @return layout manager */
getLayoutManager() {
return this._layoutManager;
},
});
export default EventBusDispatcher
export default EventBusDispatcher;

75
packages/mindplot/lib/components/layout/GridSorter.js
View File

@ -15,66 +15,63 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const AbstractBasicSorter = require('./AbstractBasicSorter').default
const AbstractBasicSorter = require('./AbstractBasicSorter').default;
/**
* @class
* @extends mindplot.layout.AbstractBasicSorter
*/
const GridSorter = new Class(/** @lends GridSorter */{
Extends: AbstractBasicSorter,
Extends: AbstractBasicSorter,
/**
/**
* @param {} treeSet
* @param {} node
* @return offsets
*/
computeOffsets: function(treeSet, node) {
$assert(treeSet, "treeSet can no be null.");
$assert(node, "node can no be null.");
$assert("order can no be null.");
computeOffsets(treeSet, node) {
$assert(treeSet, 'treeSet can no be null.');
$assert(node, 'node can no be null.');
$assert('order can no be null.');
var children = this._getSortedChildren(treeSet, node);
const children = this._getSortedChildren(treeSet, node);
// Compute heights ...
var me = this;
var heights = children.map(function(child) {
return {
id: child.getId(),
height: me._computeChildrenHeight(treeSet, child)
};
});
// Compute heights ...
const me = this;
const heights = children.map((child) => ({
id: child.getId(),
height: me._computeChildrenHeight(treeSet, child),
}));
// Calculate the offsets ...
var result = {};
for (var i = 0; i < heights.length; i++) {
var even = i%2 == 0 ? 1 : -1;
// Calculate the offsets ...
const result = {};
for (let i = 0; i < heights.length; i++) {
const even = i % 2 == 0 ? 1 : -1;
var zeroHeight = i == 0 ? 0 : heights[0].height/2 * even;
var middleHeight = 0;
for (var j=i-2; j>0; j=j-2) {
middleHeight += heights[j].height * even;
}
var finalHeight = i == 0 ? 0 : heights[i].height/2 * even;
const zeroHeight = i == 0 ? 0 : heights[0].height / 2 * even;
let middleHeight = 0;
for (let j = i - 2; j > 0; j -= 2) {
middleHeight += heights[j].height * even;
}
const finalHeight = i == 0 ? 0 : heights[i].height / 2 * even;
var yOffset = zeroHeight + middleHeight +finalHeight;
var xOffset = node.getSize().width + GridSorter.GRID_HORIZONTAR_SIZE;
const yOffset = zeroHeight + middleHeight + finalHeight;
const xOffset = node.getSize().width + GridSorter.GRID_HORIZONTAR_SIZE;
$assert(!isNaN(xOffset), "xOffset can not be null");
$assert(!isNaN(yOffset), "yOffset can not be null");
$assert(!isNaN(xOffset), 'xOffset can not be null');
$assert(!isNaN(yOffset), 'yOffset can not be null');
result[heights[i].id] = {x:xOffset,y:yOffset};
result[heights[i].id] = { x: xOffset, y: yOffset };
}
return result;
},
}
return result;
},
/**
/**
* @return {String} the print name of this class
*/
toString:function() {
return "Grid Sorter";
}
toString() {
return 'Grid Sorter';
},
});

314
packages/mindplot/lib/components/layout/LayoutManager.js
View File

@ -21,9 +21,9 @@ const OriginalLayout = require('./OriginalLayout').default;
const ChangeEvent = require('./ChangeEvent').default;
const LayoutManager = new Class(
/** @lends LayoutManager */ {
Extends: Events,
/**
/** @lends LayoutManager */ {
Extends: Events,
/**
* @constructs
* @extends mindplot.Events
* @param {} rootNodeId
@ -31,57 +31,57 @@ const LayoutManager = new Class(
* @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 };
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);
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 = [];
},
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: function (id, size) {
$assert($defined(id), 'id can not be null');
updateNodeSize(id, size) {
$assert($defined(id), 'id can not be null');
var node = this._treeSet.find(id);
node.setSize(size);
},
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: function (id, value) {
$assert($defined(id), 'id can not be null');
$assert($defined(value), 'value can not be null');
updateShrinkState(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);
const node = this._treeSet.find(id);
node.setShrunken(value);
return this;
},
return this;
},
/**
/**
* @param id
* @return {@link RootedTreeSet}.find(id)
*/
find: function (id) {
return this._treeSet.find(id);
},
find(id) {
return this._treeSet.find(id);
},
/**
/**
* @param id
* @param position
* @throws will throw an error if id is null or undefined
@ -89,20 +89,20 @@ const LayoutManager = new Class(
* @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');
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');
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);
},
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
@ -111,65 +111,65 @@ const LayoutManager = new Class(
* @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');
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);
this._layout.connectNode(parentId, childId, order);
return this;
},
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);
disconnectNode(id) {
$assert($defined(id), 'id can not be null');
this._layout.disconnectNode(id);
return this;
},
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);
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;
},
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);
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);
}
// Is It connected ?
if (this._treeSet.getParent(node)) {
this.disconnectNode(id);
}
// Remove the all the branch ...
this._treeSet.remove(id);
// Remove the all the branch ...
this._treeSet.remove(id);
return this;
},
return this;
},
/**
/**
* @param {Number} parentId
* @param {Number=} nodeId
* @param {String=} position the position to use as mindplot.layout.Node.properties position
@ -177,109 +177,107 @@ const LayoutManager = new Class(
* @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');
predict(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();
const parent = this._treeSet.find(parentId);
const node = nodeId ? this._treeSet.find(nodeId) : null;
const sorter = parent.getSorter();
var result = sorter.predict(this._treeSet, parent, node, position, free);
return { order: result[0], position: result[1] };
},
const 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());
},
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: 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);
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;
},
return canvas;
},
/**
/**
* initializes the layout to be updated
* @param fireEvents
* @return this
*/
layout: function (fireEvents) {
// File repositioning ...
this._layout.layout();
layout(fireEvents) {
// File repositioning ...
this._layout.layout();
// Collect changes ...
this._collectChanges();
// Collect changes ...
this._collectChanges();
if ($(fireEvents).length > 0 || fireEvents) {
this._flushEvents();
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);
}
return this;
// 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));
},
_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
);
},
}
this,
);
},
},
);
export default LayoutManager;

369
packages/mindplot/lib/components/layout/Node.js
View File

@ -17,8 +17,8 @@
*/
const Node = new Class(
/** @lends Node */ {
/**
/** @lends Node */ {
/**
* @constructs
* @param id
* @param size
@ -29,221 +29,220 @@ const Node = new Class(
* @throws will throw an error if position is null or undefined
* @throws will throw an error if sorter is null or undefined
*/
initialize: function (id, size, position, sorter) {
$assert(typeof id === 'number' && isFinite(id), 'id can not be null');
$assert(size, 'size can not be null');
$assert(position, 'position can not be null');
$assert(sorter, 'sorter can not be null');
initialize(id, size, position, sorter) {
$assert(typeof id === 'number' && isFinite(id), 'id can not be null');
$assert(size, 'size can not be null');
$assert(position, 'position can not be null');
$assert(sorter, 'sorter can not be null');
this._id = id;
this._sorter = sorter;
this._properties = {};
this._id = id;
this._sorter = sorter;
this._properties = {};
this.setSize(size);
this.setPosition(position);
this.setShrunken(false);
},
this.setSize(size);
this.setPosition(position);
this.setShrunken(false);
},
/** */
getId: function () {
return this._id;
},
/** */
getId() {
return this._id;
},
/** */
setFree: function (value) {
this._setProperty('free', value);
},
/** */
setFree(value) {
this._setProperty('free', value);
},
/** */
isFree: function () {
return this._getProperty('free');
},
/** */
isFree() {
return this._getProperty('free');
},
/** */
hasFreeChanged: function () {
return this._isPropertyChanged('free');
},
/** */
hasFreeChanged() {
return this._isPropertyChanged('free');
},
/** */
hasFreeDisplacementChanged: function () {
return this._isPropertyChanged('freeDisplacement');
},
/** */
hasFreeDisplacementChanged() {
return this._isPropertyChanged('freeDisplacement');
},
/** */
setShrunken: function (value) {
this._setProperty('shrink', value);
},
/** */
setShrunken(value) {
this._setProperty('shrink', value);
},
/** */
areChildrenShrunken: function () {
return this._getProperty('shrink');
},
/** */
areChildrenShrunken() {
return this._getProperty('shrink');
},
/** */
setOrder: function (order) {
$assert(
typeof order === 'number' && isFinite(order),
'Order can not be null. Value:' + order
);
this._setProperty('order', order);
},
/** */
setOrder(order) {
$assert(
typeof order === 'number' && isFinite(order),
`Order can not be null. Value:${order}`,
);
this._setProperty('order', order);
},
/** */
resetPositionState: function () {
var prop = this._properties['position'];
if (prop) {
prop.hasChanged = false;
}
},
/** */
resetPositionState() {
const prop = this._properties.position;
if (prop) {
prop.hasChanged = false;
}
},
/** */
resetOrderState: function () {
var prop = this._properties['order'];
if (prop) {
prop.hasChanged = false;
}
},
/** */
resetOrderState() {
const prop = this._properties.order;
if (prop) {
prop.hasChanged = false;
}
},
/** */
resetFreeState: function () {
var prop = this._properties['freeDisplacement'];
if (prop) {
prop.hasChanged = false;
}
},
/** */
resetFreeState() {
const prop = this._properties.freeDisplacement;
if (prop) {
prop.hasChanged = false;
}
},
/** */
getOrder: function () {
return this._getProperty('order');
},
/** */
getOrder() {
return this._getProperty('order');
},
/** */
hasOrderChanged: function () {
return this._isPropertyChanged('order');
},
/** */
hasOrderChanged() {
return this._isPropertyChanged('order');
},
/** */
hasPositionChanged: function () {
return this._isPropertyChanged('position');
},
/** */
hasPositionChanged() {
return this._isPropertyChanged('position');
},
/** */
hasSizeChanged: function () {
return this._isPropertyChanged('size');
},
/** */
hasSizeChanged() {
return this._isPropertyChanged('size');
},
/** */
getPosition: function () {
return this._getProperty('position');
},
/** */
getPosition() {
return this._getProperty('position');
},
/** */
setSize: function (size) {
$assert($defined(size), 'Size can not be null');
this._setProperty('size', Object.clone(size));
},
/** */
setSize(size) {
$assert($defined(size), 'Size can not be null');
this._setProperty('size', Object.clone(size));
},
/** */
getSize: function () {
return this._getProperty('size');
},
/** */
getSize() {
return this._getProperty('size');
},
/** */
setFreeDisplacement: function (displacement) {
$assert($defined(displacement), 'Position can not be null');
$assert($defined(displacement.x), 'x can not be null');
$assert($defined(displacement.y), 'y can not be null');
var oldDisplacement = this.getFreeDisplacement();
var newDisplacement = {
x: oldDisplacement.x + displacement.x,
y: oldDisplacement.y + displacement.y,
};
/** */
setFreeDisplacement(displacement) {
$assert($defined(displacement), 'Position can not be null');
$assert($defined(displacement.x), 'x can not be null');
$assert($defined(displacement.y), 'y can not be null');
const oldDisplacement = this.getFreeDisplacement();
const newDisplacement = {
x: oldDisplacement.x + displacement.x,
y: oldDisplacement.y + displacement.y,
};
this._setProperty('freeDisplacement', Object.clone(newDisplacement));
},
this._setProperty('freeDisplacement', Object.clone(newDisplacement));
},
/** */
resetFreeDisplacement: function () {
this._setProperty('freeDisplacement', { x: 0, y: 0 });
},
/** */
resetFreeDisplacement() {
this._setProperty('freeDisplacement', { x: 0, y: 0 });
},
/** */
getFreeDisplacement: function () {
var freeDisplacement = this._getProperty('freeDisplacement');
return freeDisplacement || { x: 0, y: 0 };
},
/** */
getFreeDisplacement() {
const freeDisplacement = this._getProperty('freeDisplacement');
return freeDisplacement || { x: 0, y: 0 };
},
/** */
setPosition: function (position) {
$assert($defined(position), 'Position can not be null');
$assert($defined(position.x), 'x can not be null');
$assert($defined(position.y), 'y can not be null');
/** */
setPosition(position) {
$assert($defined(position), 'Position can not be null');
$assert($defined(position.x), 'x can not be null');
$assert($defined(position.y), 'y can not be null');
// This is a performance improvement to avoid movements that really could be avoided.
var currentPos = this.getPosition();
if (
currentPos == null ||
Math.abs(currentPos.x - position.x) > 2 ||
Math.abs(currentPos.y - position.y) > 2
)
this._setProperty('position', position);
},
// This is a performance improvement to avoid movements that really could be avoided.
const currentPos = this.getPosition();
if (
currentPos == null
|| Math.abs(currentPos.x - position.x) > 2
|| Math.abs(currentPos.y - position.y) > 2
) this._setProperty('position', position);
},
_setProperty: function (key, value) {
var prop = this._properties[key];
if (!prop) {
prop = {
hasChanged: false,
value: null,
oldValue: null,
};
}
_setProperty(key, value) {
let prop = this._properties[key];
if (!prop) {
prop = {
hasChanged: false,
value: null,
oldValue: null,
};
}
// Only update if the property has changed ...
if (JSON.stringify(prop.value) != JSON.stringify(value)) {
prop.oldValue = prop.value;
prop.value = value;
prop.hasChanged = true;
}
this._properties[key] = prop;
},
// Only update if the property has changed ...
if (JSON.stringify(prop.value) != JSON.stringify(value)) {
prop.oldValue = prop.value;
prop.value = value;
prop.hasChanged = true;
}
this._properties[key] = prop;
},
_getProperty: function (key) {
var prop = this._properties[key];
return $defined(prop) ? prop.value : null;
},
_getProperty(key) {
const prop = this._properties[key];
return $defined(prop) ? prop.value : null;
},
_isPropertyChanged: function (key) {
var prop = this._properties[key];
return prop ? prop.hasChanged : false;
},
_isPropertyChanged(key) {
const prop = this._properties[key];
return prop ? prop.hasChanged : false;
},
/** */
getSorter: function () {
return this._sorter;
},
/** */
getSorter() {
return this._sorter;
},
/** @return {String} returns id, order, position, size and shrink information*/
toString: function () {
return (
'[id:' +
this.getId() +
', order:' +
this.getOrder() +
', position: {' +
this.getPosition().x +
',' +
this.getPosition().y +
'}, size: {' +
this.getSize().width +
',' +
this.getSize().height +
'}, shrink:' +
this.areChildrenShrunken() +
']'
);
},
}
/** @return {String} returns id, order, position, size and shrink information */
toString() {
return (
`[id:${
this.getId()
}, order:${
this.getOrder()
}, position: {${
this.getPosition().x
},${
this.getPosition().y
}}, size: {${
this.getSize().width
},${
this.getSize().height
}}, shrink:${
this.areChildrenShrunken()
}]`
);
},
},
);
export default Node;

452
packages/mindplot/lib/components/layout/OriginalLayout.js
View File

@ -21,267 +21,259 @@ const SymmetricSorter = require('./SymmetricSorter').default;
const BalancedSorter = require('./BalancedSorter').default;
const OriginalLayout = new Class(
/** @lends OriginalLayout */ {
/**
/** @lends OriginalLayout */ {
/**
* @constructs
* @param treeSet
*/
initialize: function (treeSet) {
this._treeSet = treeSet;
initialize(treeSet) {
this._treeSet = treeSet;
},
/** */
createNode(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');
const strategy = type === 'root' ? OriginalLayout.BALANCED_SORTER : OriginalLayout.SYMMETRIC_SORTER;
return new Node(id, size, position, strategy);
},
/** */
connectNode(parentId, childId, order) {
const parent = this._treeSet.find(parentId);
const child = this._treeSet.find(childId);
// Insert the new node ...
const 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(nodeId) {
const node = this._treeSet.find(nodeId);
const parent = this._treeSet.getParent(node);
$assert(parent, 'Node already disconnected');
// Make it fixed
node.setFree(false);
node.resetFreeDisplacement();
// Remove from children list.
const 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() {
const roots = this._treeSet.getTreeRoots();
_.each(
roots,
function (node) {
// Calculate all node heights ...
const sorter = node.getSorter();
const heightById = sorter.computeChildrenIdByHeights(this._treeSet, node);
this._layoutChildren(node, heightById);
this._fixOverlapping(node, heightById);
},
this,
);
},
/** */
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');
_layoutChildren(node, heightById) {
const nodeId = node.getId();
const children = this._treeSet.getChildren(node);
const parent = this._treeSet.getParent(node);
const childrenOrderMoved = children.some((child) => child.hasOrderChanged());
const childrenSizeChanged = children.some((child) => child.hasSizeChanged());
var strategy =
type === 'root' ? OriginalLayout.BALANCED_SORTER : OriginalLayout.SYMMETRIC_SORTER;
return new Node(id, size, position, strategy);
},
// 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 ....
const newBranchHeight = heightById[nodeId];
/** */
connectNode: function (parentId, childId, order) {
var parent = this._treeSet.find(parentId);
var child = this._treeSet.find(childId);
const parentHeightChanged = $defined(parent) ? parent._heightChanged : false;
const heightChanged = node._branchHeight != newBranchHeight;
node._heightChanged = heightChanged || parentHeightChanged;
// Insert the new node ...
var sorter = parent.getSorter();
sorter.insert(this._treeSet, parent, child, order);
if (childrenOrderMoved || childrenSizeChanged || heightChanged || parentHeightChanged) {
const sorter = node.getSorter();
const offsetById = sorter.computeOffsets(this._treeSet, node);
const parentPosition = node.getPosition();
const me = this;
_.each(children, (child) => {
const offset = offsetById[child.getId()];
// Connect the new node ...
this._treeSet.connect(parentId, childId);
const childFreeDisplacement = child.getFreeDisplacement();
const direction = node.getSorter().getChildDirection(me._treeSet, child);
// 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 (
(direction > 0 && childFreeDisplacement.x < 0)
|| (direction < 0 && childFreeDisplacement.x > 0)
) {
child.resetFreeDisplacement();
child.setFreeDisplacement({
x: -childFreeDisplacement.x,
y: childFreeDisplacement.y,
});
}
// 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];
offset.x += child.getFreeDisplacement().x;
offset.y += child.getFreeDisplacement().y;
var parentHeightChanged = $defined(parent) ? parent._heightChanged : false;
var heightChanged = node._branchHeight != newBranchHeight;
node._heightChanged = heightChanged || parentHeightChanged;
const parentX = parentPosition.x;
const parentY = parentPosition.y;
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()];
const newPos = {
x: parentX + offset.x,
y: parentY + offset.y + me._calculateAlignOffset(node, child, heightById),
};
me._treeSet.updateBranchPosition(child, newPos);
});
var childFreeDisplacement = child.getFreeDisplacement();
var direction = node.getSorter().getChildDirection(me._treeSet, child);
node._branchHeight = newBranchHeight;
}
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
);
// Continue reordering the children nodes ...
_.each(
children,
function (child) {
this._layoutChildren(child, heightById);
},
this,
);
},
_calculateAlignOffset: function (node, child, heightById) {
if (child.isFree()) {
return 0;
}
_calculateAlignOffset(node, child, heightById) {
if (child.isFree()) {
return 0;
}
var offset = 0;
let offset = 0;
var nodeHeight = node.getSize().height;
var childHeight = child.getSize().height;
const nodeHeight = node.getSize().height;
const 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);
}
}
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;
return offset;
},
_branchIsTaller(node, heightById) {
return (
heightById[node.getId()]
> node.getSize().height + node.getSorter()._getVerticalPadding() * 2
);
},
_fixOverlapping(node, heightById) {
const children = this._treeSet.getChildren(node);
if (node.isFree()) {
this._shiftBranches(node, heightById);
}
_.each(
children,
function (child) {
this._fixOverlapping(child, heightById);
},
this,
);
},
_branchIsTaller: function (node, heightById) {
return (
heightById[node.getId()] >
node.getSize().height + node.getSorter()._getVerticalPadding() * 2
);
_shiftBranches(node, heightById) {
const shiftedBranches = [node];
const siblingsToShift = this._treeSet.getSiblingsInVerticalDirection(
node,
node.getFreeDisplacement().y,
);
let last = node;
_.each(
siblingsToShift,
function (sibling) {
const overlappingOccurs = shiftedBranches.some(function (shiftedBranch) {
return this._branchesOverlap(shiftedBranch, sibling, heightById);
}, this);
if (!sibling.isFree() || overlappingOccurs) {
const sAmount = node.getFreeDisplacement().y;
this._treeSet.shiftBranchPosition(sibling, 0, sAmount);
shiftedBranches.push(sibling);
}
},
this,
);
_fixOverlapping: function (node, heightById) {
var children = this._treeSet.getChildren(node);
const branchesToShift = this._treeSet
.getBranchesInVerticalDirection(node, node.getFreeDisplacement().y)
.filter((branch) => !shiftedBranches.contains(branch));
if (node.isFree()) {
this._shiftBranches(node, heightById);
}
_.each(
children,
function (child) {
this._fixOverlapping(child, heightById);
},
this
);
_.each(
branchesToShift,
function (branch) {
const bAmount = node.getFreeDisplacement().y;
this._treeSet.shiftBranchPosition(branch, 0, bAmount);
shiftedBranches.push(branch);
last = branch;
},
this,
);
},
_shiftBranches: function (node, heightById) {
var shiftedBranches = [node];
_branchesOverlap(branchA, branchB, heightById) {
// a branch doesn't really overlap with itself
if (branchA == branchB) {
return false;
}
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);
const topA = branchA.getPosition().y - heightById[branchA.getId()] / 2;
const bottomA = branchA.getPosition().y + heightById[branchA.getId()] / 2;
const topB = branchB.getPosition().y - heightById[branchB.getId()] / 2;
const bottomB = branchB.getPosition().y + heightById[branchB.getId()] / 2;
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);
},
}
return !(topA >= bottomB || bottomA <= topB);
},
},
);
/**

628
packages/mindplot/lib/components/layout/RootedTreeSet.js
View File

@ -17,443 +17,437 @@
*/
const RootedTreeSet = new Class(
/** @lends RootedTreeSet */ {
/** @constructs */
initialize: function () {
this._rootNodes = [];
},
/** @lends RootedTreeSet */ {
/** @constructs */
initialize() {
this._rootNodes = [];
},
/**
/**
* @param root
* @throws will throw an error if root is null or undefined
*/
setRoot: function (root) {
$assert(root, 'root can not be null');
this._rootNodes.push(this._decodate(root));
},
setRoot(root) {
$assert(root, 'root can not be null');
this._rootNodes.push(this._decodate(root));
},
/** getter */
getTreeRoots: function () {
return this._rootNodes;
},
/** getter */
getTreeRoots() {
return this._rootNodes;
},
_decodate: function (node) {
node._children = [];
return node;
},
_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: function (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));
},
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: function (nodeId) {
$assert($defined(nodeId), 'nodeId can not be null');
var node = this.find(nodeId);
this._rootNodes.erase(node);
},
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: function (parentId, childId) {
$assert($defined(parentId), 'parent can not be null');
$assert($defined(childId), 'child can not be null');
connect(parentId, childId) {
$assert($defined(parentId), 'parent can not be null');
$assert($defined(childId), 'child can not be null');
var parent = this.find(parentId);
var child = this.find(childId, true);
$assert(
!child._parent,
'node already connected. Id:' + child.getId() + ',previous:' + child._parent
);
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);
},
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: function (nodeId) {
$assert($defined(nodeId), 'nodeId can not be null');
var node = this.find(nodeId);
$assert(node._parent, '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;
},
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: function (id, validate) {
$assert($defined(id), 'id can not be null');
find(id, validate) {
$assert($defined(id), 'id can not be null');
var graphs = this._rootNodes;
var result = null;
for (var i = 0; i < graphs.length; i++) {
var 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;
},
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: function (id, parent) {
if (parent.getId() == id) {
return parent;
}
_find(id, parent) {
if (parent.getId() == id) {
return parent;
}
var result = null;
var children = parent._children;
for (var i = 0; i < children.length; i++) {
var child = children[i];
result = this._find(id, child);
if (result) break;
}
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;
},
return result;
},
/**
/**
* @param node
* @throws will throw an error if nodeId is null or undefined
* @return children
*/
getChildren: function (node) {
$assert(node, 'node cannot be null');
return node._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: function (node) {
$assert(node, 'node cannot be null');
var parent = this.getParent(node);
if ($defined(parent)) {
return this.getRootNode(parent);
}
getRootNode(node) {
$assert(node, 'node cannot be null');
const parent = this.getParent(node);
if ($defined(parent)) {
return this.getRootNode(parent);
}
return node;
},
return node;
},
/**
/**
* @param node
* @throws will throw an error if node is null or undefined
* @return {Array} ancestors*/
getAncestors: function (node) {
$assert(node, 'node cannot be null');
return this._getAncestors(this.getParent(node), []);
},
* @return {Array} ancestors */
getAncestors(node) {
$assert(node, 'node cannot be null');
return this._getAncestors(this.getParent(node), []);
},
_getAncestors: function (node, ancestors) {
var result = ancestors;
if (node) {
result.push(node);
this._getAncestors(this.getParent(node), result);
}
return result;
},
_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: function (node) {
$assert(node, 'node cannot be null');
if (!$defined(node._parent)) {
return [];
}
var siblings = node._parent._children.filter(function (child) {
return child != node;
});
return 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: function (node) {
$assert(node, 'node cannot be null');
return this._hasSinglePathToSingleLeaf(node);
},
hasSinglePathToSingleLeaf(node) {
$assert(node, 'node cannot be null');
return this._hasSinglePathToSingleLeaf(node);
},
_hasSinglePathToSingleLeaf: function (node) {
var children = this.getChildren(node);
_hasSinglePathToSingleLeaf(node) {
const children = this.getChildren(node);
if (children.length == 1) {
return this._hasSinglePathToSingleLeaf(children[0]);
}
if (children.length == 1) {
return this._hasSinglePathToSingleLeaf(children[0]);
}
return children.length == 0;
},
return children.length == 0;
},
/**
/**
* @param node
* @return {Boolean} whether the node is the start of a subbranch*/
isStartOfSubBranch: function (node) {
return this.getSiblings(node).length > 0 && this.getChildren(node).length == 1;
},
* @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: function (node) {
$assert(node, 'node cannot be null');
return this.getChildren(node).length == 0;
},
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: function (node) {
$assert(node, 'node cannot be null');
return node._parent;
},
getParent(node) {
$assert(node, 'node cannot be null');
return node._parent;
},
/**
/**
* @return result
*/
dump: function () {
var branches = this._rootNodes;
var result = '';
for (var i = 0; i < branches.length; i++) {
var branch = branches[i];
result += this._dump(branch, '');
}
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: function (node, indent) {
var result = indent + node + '\n';
var children = this.getChildren(node);
for (var i = 0; i < children.length; i++) {
var child = children[i];
result += this._dump(child, indent + ' ');
}
_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;
},
return result;
},
/**
/**
* @param canvas
*/
plot: function (canvas) {
var branches = this._rootNodes;
for (var i = 0; i < branches.length; i++) {
var branch = branches[i];
this._plot(canvas, branch);
}
},
plot(canvas) {
const branches = this._rootNodes;
for (let i = 0; i < branches.length; i++) {
const branch = branches[i];
this._plot(canvas, branch);
}
},
_plot: function (canvas, node, root) {
var children = this.getChildren(node);
var cx = node.getPosition().x + canvas.width / 2 - node.getSize().width / 2;
var cy = node.getPosition().y + canvas.height / 2 - node.getSize().height / 2;
var rect = canvas.rect(cx, cy, node.getSize().width, node.getSize().height);
var order = node.getOrder() == null ? 'r' : node.getOrder();
var text = canvas.text(
node.getPosition().x + canvas.width / 2,
node.getPosition().y + canvas.height / 2,
node.getId() + '[' + order + ']'
);
text.attr('fill', '#FFF');
var fillColor = this._rootNodes.contains(node)
? '#000'
: node.isFree()
? '#abc'
: '#c00';
rect.attr('fill', fillColor);
_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);
var rectPosition = {
x: rect.attr('x') - canvas.width / 2 + rect.attr('width') / 2,
y: rect.attr('y') - canvas.height / 2 + rect.attr('height') / 2,
};
var rectSize = { width: rect.attr('width'), height: rect.attr('height') };
rect.click(function () {
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(function () {
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 +
')]'
);
});
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 (var i = 0; i < children.length; i++) {
var child = children[i];
this._plot(canvas, child);
}
},
for (let i = 0; i < children.length; i++) {
const child = children[i];
this._plot(canvas, child);
}
},
/**
/**
* @param node
* @param position
*/
updateBranchPosition: function (node, position) {
var oldPos = node.getPosition();
node.setPosition(position);
updateBranchPosition(node, position) {
const oldPos = node.getPosition();
node.setPosition(position);
var xOffset = oldPos.x - position.x;
var yOffset = oldPos.y - position.y;
const xOffset = oldPos.x - position.x;
const yOffset = oldPos.y - position.y;
var children = this.getChildren(node);
var me = this;
_.each(children, function (child) {
me.shiftBranchPosition(child, xOffset, yOffset);
});
},
const children = this.getChildren(node);
const me = this;
_.each(children, (child) => {
me.shiftBranchPosition(child, xOffset, yOffset);
});
},
/**
/**
* @param node
* @param xOffset
* @param yOffset
*/
shiftBranchPosition: function (node, xOffset, yOffset) {
var position = node.getPosition();
node.setPosition({ x: position.x + xOffset, y: position.y + yOffset });
shiftBranchPosition(node, xOffset, yOffset) {
const position = node.getPosition();
node.setPosition({ x: position.x + xOffset, y: position.y + yOffset });
var children = this.getChildren(node);
var me = this;
_.each(children, function (child) {
me.shiftBranchPosition(child, xOffset, 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: function (node, yOffset) {
// siblings with lower or higher order, depending on the direction of the offset and on the same side as their parent
var parent = this.getParent(node);
var siblings = this.getSiblings(node).filter(function (sibling) {
var sameSide =
node.getPosition().x > parent.getPosition().x
? sibling.getPosition().x > parent.getPosition().x
: sibling.getPosition().x < parent.getPosition().x;
var orderOK =
yOffset < 0
? sibling.getOrder() < node.getOrder()
: sibling.getOrder() > node.getOrder();
return orderOK && sameSide;
});
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();
}
if (yOffset < 0) {
siblings.reverse();
}
return siblings;
},
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: function (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
var rootNode = this.getRootNode(node);
var branches = this.getChildren(rootNode).filter(function (child) {
return this._find(node.getId(), child);
}, this);
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);
var branch = branches[0];
var rootDescendants = this.getSiblings(branch).filter(function (sibling) {
var sameSide =
node.getPosition().x > rootNode.getPosition().x
? sibling.getPosition().x > rootNode.getPosition().x
: sibling.getPosition().x < rootNode.getPosition().x;
var sameDirection =
yOffset < 0
? sibling.getOrder() < branch.getOrder()
: sibling.getOrder() > branch.getOrder();
return sameSide && sameDirection;
}, 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;
},
}
return rootDescendants;
},
},
);
export default RootedTreeSet;

469
packages/mindplot/lib/components/layout/SymmetricSorter.js
View File

@ -18,15 +18,15 @@
const AbstractBasicSorter = require('./AbstractBasicSorter').default;
const SymmetricSorter = new Class(
/** @lends SymmetricSorter */ {
Extends: AbstractBasicSorter,
/**
/** @lends SymmetricSorter */ {
Extends: AbstractBasicSorter,
/**
* @constructs
* @extends mindplot.layout.AbstractBasicSorter
*/
initialize: function () {},
initialize() {},
/**
/**
* Predict the order and position of a dragged node.
*
* @param graph The tree set
@ -36,190 +36,184 @@ const SymmetricSorter = new Class(
* @param free Free drag or not
* @return {*}
*/
predict: function (graph, parent, node, position, free) {
var self = this;
var rootNode = graph.getRootNode(parent);
predict(graph, parent, node, position, free) {
const self = this;
const rootNode = graph.getRootNode(parent);
// If its a free node...
if (free) {
$assert(
$defined(position),
'position cannot be null for predict in free positioning'
);
$assert($defined(node), 'node cannot be null for predict in free positioning');
// If its a free node...
if (free) {
$assert(
$defined(position),
'position cannot be null for predict in free positioning',
);
$assert($defined(node), 'node cannot be null for predict in free positioning');
var direction = this._getRelativeDirection(
rootNode.getPosition(),
parent.getPosition()
);
var limitXPos =
parent.getPosition().x +
direction *
(parent.getSize().width / 2 +
node.getSize().width / 2 +
SymmetricSorter.INTERNODE_HORIZONTAL_PADDING);
const direction = this._getRelativeDirection(
rootNode.getPosition(),
parent.getPosition(),
);
const limitXPos = parent.getPosition().x
+ direction
* (parent.getSize().width / 2
+ node.getSize().width / 2
+ SymmetricSorter.INTERNODE_HORIZONTAL_PADDING);
var xPos =
direction > 0
? position.x >= limitXPos
? position.x
: limitXPos
: position.x <= limitXPos
? position.x
: limitXPos;
const xPos = direction > 0
? position.x >= limitXPos
? position.x
: limitXPos
: position.x <= limitXPos
? position.x
: limitXPos;
return [0, { x: xPos, y: position.y }];
}
return [0, { x: xPos, y: position.y }];
}
// Its not a dragged node (it is being added)
if (!node) {
var parentDirection = self._getRelativeDirection(
rootNode.getPosition(),
parent.getPosition()
);
// Its not a dragged node (it is being added)
if (!node) {
const parentDirection = self._getRelativeDirection(
rootNode.getPosition(),
parent.getPosition(),
);
var position = {
x:
parent.getPosition().x +
parentDirection *
(parent.getSize().width + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING),
y: parent.getPosition().y,
};
return [graph.getChildren(parent).length, position];
}
var position = {
x:
parent.getPosition().x
+ parentDirection
* (parent.getSize().width + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING),
y: parent.getPosition().y,
};
return [graph.getChildren(parent).length, position];
}
// If it is a dragged node...
$assert($defined(position), 'position cannot be null for predict in dragging');
var nodeDirection = this._getRelativeDirection(
rootNode.getPosition(),
node.getPosition()
);
var positionDirection = this._getRelativeDirection(rootNode.getPosition(), position);
var siblings = graph.getSiblings(node);
// If it is a dragged node...
$assert($defined(position), 'position cannot be null for predict in dragging');
const nodeDirection = this._getRelativeDirection(
rootNode.getPosition(),
node.getPosition(),
);
const positionDirection = this._getRelativeDirection(rootNode.getPosition(), position);
const siblings = graph.getSiblings(node);
// node has no siblings and its trying to reconnect to its own parent
var sameParent = parent == graph.getParent(node);
if (siblings.length == 0 && nodeDirection == positionDirection && sameParent) {
return [node.getOrder(), node.getPosition()];
}
// node has no siblings and its trying to reconnect to its own parent
const sameParent = parent == graph.getParent(node);
if (siblings.length == 0 && nodeDirection == positionDirection && sameParent) {
return [node.getOrder(), node.getPosition()];
}
var parentChildren = graph.getChildren(parent);
const parentChildren = graph.getChildren(parent);
if (parentChildren.length == 0) {
// Fit as a child of the parent node...
var position = {
x:
parent.getPosition().x +
positionDirection *
(parent.getSize().width + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING),
y: parent.getPosition().y,
};
return [0, position];
} else {
// Try to fit within ...
var result = null;
var last = parentChildren.getLast();
for (var i = 0; i < parentChildren.length; i++) {
var parentChild = parentChildren[i];
var nodeAfter = i + 1 == parentChild.length ? null : parentChildren[i + 1];
if (parentChildren.length == 0) {
// Fit as a child of the parent node...
var position = {
x:
parent.getPosition().x
+ positionDirection
* (parent.getSize().width + SymmetricSorter.INTERNODE_HORIZONTAL_PADDING),
y: parent.getPosition().y,
};
return [0, position];
}
// Try to fit within ...
const result = null;
const last = parentChildren.getLast();
for (let i = 0; i < parentChildren.length; i++) {
const parentChild = parentChildren[i];
const nodeAfter = i + 1 == parentChild.length ? null : parentChildren[i + 1];
// Fit at the bottom
if (!nodeAfter && position.y > parentChild.getPosition().y) {
var order =
graph.getParent(node) && graph.getParent(node).getId() == parent.getId()
? last.getOrder()
: last.getOrder() + 1;
var position = {
x: parentChild.getPosition().x,
y:
parentChild.getPosition().y +
parentChild.getSize().height +
SymmetricSorter.INTERNODE_VERTICAL_PADDING * 2,
};
return [order, position];
}
// Fit at the bottom
if (!nodeAfter && position.y > parentChild.getPosition().y) {
var order = graph.getParent(node) && graph.getParent(node).getId() == parent.getId()
? last.getOrder()
: last.getOrder() + 1;
var position = {
x: parentChild.getPosition().x,
y:
parentChild.getPosition().y
+ parentChild.getSize().height
+ SymmetricSorter.INTERNODE_VERTICAL_PADDING * 2,
};
return [order, position];
}
// Fit after this node
if (
nodeAfter &&
position.y > parentChild.getPosition().y &&
position.y < nodeAfter.getPosition().y
) {
if (
nodeAfter.getId() == node.getId() ||
parentChild.getId() == node.getId()
) {
return [node.getOrder(), node.getPosition()];
} else {
var order =
position.y > node.getPosition().y
? nodeAfter.getOrder() - 1
: parentChild.getOrder() + 1;
var position = {
x: parentChild.getPosition().x,
y:
parentChild.getPosition().y +
(nodeAfter.getPosition().y - parentChild.getPosition().y) / 2,
};
return [order, position];
}
}
}
}
// Fit after this node
if (
nodeAfter
&& position.y > parentChild.getPosition().y
&& position.y < nodeAfter.getPosition().y
) {
if (
nodeAfter.getId() == node.getId()
|| parentChild.getId() == node.getId()
) {
return [node.getOrder(), node.getPosition()];
}
var order = position.y > node.getPosition().y
? nodeAfter.getOrder() - 1
: parentChild.getOrder() + 1;
var position = {
x: parentChild.getPosition().x,
y:
parentChild.getPosition().y
+ (nodeAfter.getPosition().y - parentChild.getPosition().y) / 2,
};
return [order, position];
}
}
// Position wasn't below any node, so it must be fitted above the first
var first = parentChildren[0];
var position = {
x: first.getPosition().x,
y:
first.getPosition().y -
first.getSize().height -
SymmetricSorter.INTERNODE_VERTICAL_PADDING * 2,
};
return [0, position];
},
// Position wasn't below any node, so it must be fitted above the first
const first = parentChildren[0];
var position = {
x: first.getPosition().x,
y:
first.getPosition().y
- first.getSize().height
- SymmetricSorter.INTERNODE_VERTICAL_PADDING * 2,
};
return [0, position];
},
/**
/**
* @param treeSet
* @param parent
* @param child
* @param order
* @throws will throw an error if the order is not strictly continuous
*/
insert: function (treeSet, parent, child, order) {
var children = this._getSortedChildren(treeSet, parent);
$assert(
order <= children.length,
'Order must be continues and can not have holes. Order:' + order
);
insert(treeSet, parent, child, order) {
const children = this._getSortedChildren(treeSet, parent);
$assert(
order <= children.length,
`Order must be continues and can not have holes. Order:${order}`,
);
// Shift all the elements in one .
for (var i = order; i < children.length; i++) {
var node = children[i];
node.setOrder(i + 1);
}
child.setOrder(order);
},
// Shift all the elements in one .
for (let i = order; i < children.length; i++) {
const node = children[i];
node.setOrder(i + 1);
}
child.setOrder(order);
},
/**
/**
* @param treeSet
* @param node
* @throws will throw an error if the node is in the wrong position*/
detach: function (treeSet, node) {
var parent = treeSet.getParent(node);
var children = this._getSortedChildren(treeSet, parent);
var order = node.getOrder();
$assert(children[order] === node, 'Node seems not to be in the right position');
* @throws will throw an error if the node is in the wrong position */
detach(treeSet, node) {
const parent = treeSet.getParent(node);
const children = this._getSortedChildren(treeSet, parent);
const order = node.getOrder();
$assert(children[order] === node, 'Node seems not to be in the right position');
// Shift all the nodes ...
for (var i = node.getOrder() + 1; i < children.length; i++) {
var child = children[i];
child.setOrder(child.getOrder() - 1);
}
node.setOrder(0);
},
// Shift all the nodes ...
for (let i = node.getOrder() + 1; i < children.length; i++) {
const child = children[i];
child.setOrder(child.getOrder() - 1);
}
node.setOrder(0);
},
/**
/**
* @param treeSet
* @param node
* @throws will throw an error if treeSet is null or undefined
@ -230,100 +224,99 @@ const SymmetricSorter = new Class(
* value, is null or undefined
* @return offsets
*/
computeOffsets: function (treeSet, node) {
$assert(treeSet, 'treeSet can no be null.');
$assert(node, 'node can no be null.');
computeOffsets(treeSet, node) {
$assert(treeSet, 'treeSet can no be null.');
$assert(node, 'node can no be null.');
var children = this._getSortedChildren(treeSet, node);
const children = this._getSortedChildren(treeSet, node);
// Compute heights ...
var heights = children
.map(function (child) {
return {
id: child.getId(),
order: child.getOrder(),
position: child.getPosition(),
width: child.getSize().width,
height: this._computeChildrenHeight(treeSet, child),
};
}, this)
.reverse();
// Compute heights ...
const heights = children
.map(function (child) {
return {
id: child.getId(),
order: child.getOrder(),
position: child.getPosition(),
width: child.getSize().width,
height: this._computeChildrenHeight(treeSet, child),
};
}, this)
.reverse();
// Compute the center of the branch ...
var totalHeight = 0;
_.each(heights, function (elem) {
totalHeight += elem.height;
});
var ysum = totalHeight / 2;
// Compute the center of the branch ...
let totalHeight = 0;
_.each(heights, (elem) => {
totalHeight += elem.height;
});
let ysum = totalHeight / 2;
// Calculate the offsets ...
var result = {};
for (var i = 0; i < heights.length; i++) {
ysum = ysum - heights[i].height;
var childNode = treeSet.find(heights[i].id);
var direction = this.getChildDirection(treeSet, childNode);
// Calculate the offsets ...
const result = {};
for (let i = 0; i < heights.length; i++) {
ysum -= heights[i].height;
const childNode = treeSet.find(heights[i].id);
const direction = this.getChildDirection(treeSet, childNode);
var yOffset = ysum + heights[i].height / 2;
var xOffset =
direction *
(heights[i].width / 2 +
node.getSize().width / 2 +
SymmetricSorter.INTERNODE_HORIZONTAL_PADDING);
const yOffset = ysum + heights[i].height / 2;
const xOffset = direction
* (heights[i].width / 2
+ node.getSize().width / 2
+ SymmetricSorter.INTERNODE_HORIZONTAL_PADDING);
$assert(!isNaN(xOffset), 'xOffset can not be null');
$assert(!isNaN(yOffset), 'yOffset can not be null');
$assert(!isNaN(xOffset), 'xOffset can not be null');
$assert(!isNaN(yOffset), 'yOffset can not be null');
result[heights[i].id] = { x: xOffset, y: yOffset };
}
return result;
},
result[heights[i].id] = { x: xOffset, y: yOffset };
}
return result;
},
/**
/**
* @param treeSet
* @param node
* @throws will throw an error if order elements are missing
*/
verify: function (treeSet, node) {
// Check that all is consistent ...
var children = this._getSortedChildren(treeSet, node);
verify(treeSet, node) {
// Check that all is consistent ...
const children = this._getSortedChildren(treeSet, node);
for (var i = 0; i < children.length; i++) {
$assert(children[i].getOrder() == i, 'missing order elements');
}
},
for (let i = 0; i < children.length; i++) {
$assert(children[i].getOrder() == i, 'missing order elements');
}
},
/**
/**
* @param treeSet
* @param child
* @return direction of the given child from its parent or from the root node, if isolated*/
getChildDirection: function (treeSet, child) {
$assert(treeSet, 'treeSet can no be null.');
$assert(treeSet.getParent(child), 'This should not happen');
* @return direction of the given child from its parent or from the root node, if isolated */
getChildDirection(treeSet, child) {
$assert(treeSet, 'treeSet can no be null.');
$assert(treeSet.getParent(child), 'This should not happen');
var result;
var rootNode = treeSet.getRootNode(child);
if (treeSet.getParent(child) == rootNode) {
// This is the case of a isolated child ... In this case, the directions is based on the root.
result = Math.sign(rootNode.getPosition().x);
} else {
// if this is not the case, honor the direction of the parent ...
var parent = treeSet.getParent(child);
var grandParent = treeSet.getParent(parent);
var sorter = grandParent.getSorter();
result = sorter.getChildDirection(treeSet, parent);
}
return result;
},
let result;
const rootNode = treeSet.getRootNode(child);
if (treeSet.getParent(child) == rootNode) {
// This is the case of a isolated child ... In this case, the directions is based on the root.
result = Math.sign(rootNode.getPosition().x);
} else {
// if this is not the case, honor the direction of the parent ...
const parent = treeSet.getParent(child);
const grandParent = treeSet.getParent(parent);
const sorter = grandParent.getSorter();
result = sorter.getChildDirection(treeSet, parent);
}
return result;
},
/** @return {String} the print name of this class */
toString: function () {
return 'Symmetric Sorter';
},
/** @return {String} the print name of this class */
toString() {
return 'Symmetric Sorter';
},
_getVerticalPadding: function () {
return SymmetricSorter.INTERNODE_VERTICAL_PADDING;
},
}
_getVerticalPadding() {
return SymmetricSorter.INTERNODE_VERTICAL_PADDING;
},
},
);
/**

24
packages/mindplot/lib/components/layout/index.js
View File

@ -12,16 +12,16 @@ const rootedTreeSet = require('./RootedTreeSet').default;
const symmetricSorter = require('./SymmetricSorter').default;
export const Layout = {
AbstractBasicSorter: abstractBasicSorter,
BalancedSorter: balancedSorter,
ChangeEvent: changeEvent,
ChildrenSorterStrategy: childrenSorterStrategy,
EventBus: eventBus,
EventBusDispatcher: eventBusDispatcher,
GridSorter: gridSorter,
LayoutManager: layoutManager,
Node: node,
OriginalLayout: originalLayout,
RootedTreeSet: rootedTreeSet,
SymmetricSorter: symmetricSorter,
AbstractBasicSorter: abstractBasicSorter,
BalancedSorter: balancedSorter,
ChangeEvent: changeEvent,
ChildrenSorterStrategy: childrenSorterStrategy,
EventBus: eventBus,
EventBusDispatcher: eventBusDispatcher,
GridSorter: gridSorter,
LayoutManager: layoutManager,
Node: node,
OriginalLayout: originalLayout,
RootedTreeSet: rootedTreeSet,
SymmetricSorter: symmetricSorter,
};

81
packages/mindplot/lib/components/libraries/bootstrap/BootstrapDialog.Request.js
View File

@ -1,51 +1,50 @@
const BootstrapDialog = require('./BootstrapDialog').default
const BootstrapDialog = require('./BootstrapDialog').default;
BootstrapDialog.Request = new Class({
Extends: BootstrapDialog,
Extends: BootstrapDialog,
initialize: function(url, title, options) {
this.parent(title, options);
this.requestOptions = {};
this.requestOptions.cache = false;
var me = this;
this.requestOptions.fail = function(xhr) {
// Intercept form requests ...
console.log("Failure:");
console.log(xhr);
};
initialize(url, title, options) {
this.parent(title, options);
this.requestOptions = {};
this.requestOptions.cache = false;
const me = this;
this.requestOptions.fail = function (xhr) {
// Intercept form requests ...
console.log('Failure:');
console.log(xhr);
};
this.requestOptions.success = function() {
// Intercept form requests ...
var forms = me._native.find('form');
_.each(forms, function(form) {
$(form).on('submit', function(event) {
// Intercept form ...
me.requestOptions.url = form.action;
me.requestOptions.method = form.method ? form.method : 'post';
$.ajax(me.requestOptions);
event.stopPropagation();
return false;
});
});
};
this._native.find('.modal-body').load(url, function () {
me.acceptButton.unbind('click').click(function () {
submitDialogForm();
});
me._native.on('hidden.bs.modal', function () {
$(this).remove();
});
me.show();
this.requestOptions.success = function () {
// Intercept form requests ...
const forms = me._native.find('form');
_.each(forms, (form) => {
$(form).on('submit', (event) => {
// Intercept form ...
me.requestOptions.url = form.action;
me.requestOptions.method = form.method ? form.method : 'post';
$.ajax(me.requestOptions);
event.stopPropagation();
return false;
});
},
});
};
onDialogShown: function() {
if (typeof(onDialogShown) == "function") {
onDialogShown();
}
this._native.find('.modal-body').load(url, () => {
me.acceptButton.unbind('click').click(() => {
submitDialogForm();
});
me._native.on('hidden.bs.modal', function () {
$(this).remove();
});
me.show();
});
},
onDialogShown() {
if (typeof (onDialogShown) === 'function') {
onDialogShown();
}
},
});

212
packages/mindplot/lib/components/libraries/bootstrap/BootstrapDialog.js
View File

@ -1,115 +1,115 @@
const Options = require('../../Options').default;
const BootstrapDialog = new Class({
Implements: Options,
Implements: Options,
options: {
cancelButton: false,
closeButton: false,
acceptButton: true,
removeButton:false,
errorMessage: false,
onEventData:{}
},
options: {
cancelButton: false,
closeButton: false,
acceptButton: true,
removeButton: false,
errorMessage: false,
onEventData: {},
},
initialize: function (title, options) {
this.setOptions(options);
this.options.onEventData.dialog = this;
this._native = $('<div class="modal fade" tabindex="-1"></div>').append('<div class="modal-dialog"></div>');
var content = $('<div class="modal-content"></div>');
var header = this._buildHeader(title);
if (header) {
content.append(header);
}
var body = $('<div class="modal-body"></div>');
if(this.options.errorMessage){
var error = $('<div class="alert alert-danger"></div>');
error.hide();
body.append(error);
}
content.append(body);
var footer = this._buildFooter();
if (footer) {
content.append(footer);
}
this._native.find(".modal-dialog").append(content);
this._native.on('hidden.bs.modal', function() {
$(this).remove();
});
this._native.on('shown.bs.modal', this.onDialogShown);
},
_buildFooter: function() {
var footer = null;
if (this.options.acceptButton || this.options.removeButton || this.options.cancelButton) {
footer = $('<div class="modal-footer" style="paddingTop:5;textAlign:center">');
}
if (this.options.acceptButton) {
this.acceptButton = $('<button type="button" class="btn btn-primary" id="acceptBtn" data-dismiss="modal">'+ $msg('ACCEPT') + '</button>');
footer.append(this.acceptButton);
this.acceptButton.unbind('click').on("click",this.options.onEventData, this.onAcceptClick)
}
if (this.options.removeButton) {
this.removeButton = $('<button type="button" class="btn btn-secondary" id="removeBtn" data-dismiss="modal">'+ $msg('REMOVE') +'</button>');
footer.append(this.removeButton);
this.removeButton.on('click', this.options.onEventData, this.onRemoveClick);
}
if (this.options.cancelButton) {
footer.append('<button type="button" class="btn btn-secondary" data-dismiss="modal">'+ $msg('CANCEL') +'</button>');
}
return footer;
},
_buildHeader: function(title) {
var header = null;
if (this.options.closeButton || title) {
header = $('<div class="modal-header"></div>');
}
if (this.options.closeButton) {
header.append(
'<button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>'
);
}
if (title) {
header.append('<h2 class="modal-title">' + title + '</h2>');
}
return header;
},
onAcceptClick: function(event) {
throw "Unsupported operation";
},
onDialogShown: function() {},
onRemoveClick: function(event) {
throw "Unsupported operation";
},
show: function () {
this._native.modal();
},
setContent: function(content) {
var modalBody = this._native.find('.modal-body');
modalBody.append(content);
},
css: function(options){
this._native.find('.modal-dialog').css(options);
},
close: function() {
this._native.modal('hide');
},
alertError: function(message){
this._native.find('.alert-danger').text(message);
this._native.find('.alert-danger').show();
},
cleanError: function(){
this._native.find('.alert-danger').hide();
initialize(title, options) {
this.setOptions(options);
this.options.onEventData.dialog = this;
this._native = $('<div class="modal fade" tabindex="-1"></div>').append('<div class="modal-dialog"></div>');
const content = $('<div class="modal-content"></div>');
const header = this._buildHeader(title);
if (header) {
content.append(header);
}
const body = $('<div class="modal-body"></div>');
if (this.options.errorMessage) {
const error = $('<div class="alert alert-danger"></div>');
error.hide();
body.append(error);
}
content.append(body);
const footer = this._buildFooter();
if (footer) {
content.append(footer);
}
this._native.find('.modal-dialog').append(content);
this._native.on('hidden.bs.modal', function () {
$(this).remove();
});
this._native.on('shown.bs.modal', this.onDialogShown);
},
_buildFooter() {
let footer = null;
if (this.options.acceptButton || this.options.removeButton || this.options.cancelButton) {
footer = $('<div class="modal-footer" style="paddingTop:5;textAlign:center">');
}
if (this.options.acceptButton) {
this.acceptButton = $(`<button type="button" class="btn btn-primary" id="acceptBtn" data-dismiss="modal">${$msg('ACCEPT')}</button>`);
footer.append(this.acceptButton);
this.acceptButton.unbind('click').on('click', this.options.onEventData, this.onAcceptClick);
}
if (this.options.removeButton) {
this.removeButton = $(`<button type="button" class="btn btn-secondary" id="removeBtn" data-dismiss="modal">${$msg('REMOVE')}</button>`);
footer.append(this.removeButton);
this.removeButton.on('click', this.options.onEventData, this.onRemoveClick);
}
if (this.options.cancelButton) {
footer.append(`<button type="button" class="btn btn-secondary" data-dismiss="modal">${$msg('CANCEL')}</button>`);
}
return footer;
},
_buildHeader(title) {
let header = null;
if (this.options.closeButton || title) {
header = $('<div class="modal-header"></div>');
}
if (this.options.closeButton) {
header.append(
'<button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>',
);
}
if (title) {
header.append(`<h2 class="modal-title">${title}</h2>`);
}
return header;
},
onAcceptClick(event) {
throw 'Unsupported operation';
},
onDialogShown() {},
onRemoveClick(event) {
throw 'Unsupported operation';
},
show() {
this._native.modal();
},
setContent(content) {
const modalBody = this._native.find('.modal-body');
modalBody.append(content);
},
css(options) {
this._native.find('.modal-dialog').css(options);
},
close() {
this._native.modal('hide');
},
alertError(message) {
this._native.find('.alert-danger').text(message);
this._native.find('.alert-danger').show();
},
cleanError() {
this._native.find('.alert-danger').hide();
},
});
export default BootstrapDialog;

1842
packages/mindplot/lib/components/libraries/bootstrap/js/bootstrap-colorpicker.js vendored
View File

File diff suppressed because it is too large Load Diff

104
packages/mindplot/lib/components/libraries/bootstrap/js/bootstrap-colorpicker.min.js vendored
View File

File diff suppressed because one or more lines are too long

1903
packages/mindplot/lib/components/libraries/bootstrap/js/bootstrap.js vendored
View File

File diff suppressed because it is too large Load Diff

35
packages/mindplot/lib/components/libraries/bootstrap/js/bootstrap.min.js vendored
View File

File diff suppressed because one or more lines are too long

220
packages/mindplot/lib/components/libraries/hotkeys/jquery.hotkeys.js
View File

@ -15,96 +15,158 @@
* Might be useful, when you want to pass some other data to your handler
*/
(function(jQuery){
jQuery.hotkeys = {
version: "0.8",
(function (jQuery) {
jQuery.hotkeys = {
version: '0.8',
specialKeys: {
8: "backspace", 9: "tab", 10: "return", 13: "enter", 16: "shift", 17: "ctrl", 18: "alt", 19: "pause",
20: "capslock", 27: "esc", 32: "space", 33: "pageup", 34: "pagedown", 35: "end", 36: "home",
37: "left", 38: "up", 39: "right", 40: "down", 45: "insert", 46: "del",
96: "0", 97: "1", 98: "2", 99: "3", 100: "4", 101: "5", 102: "6", 103: "7",
104: "8", 105: "9", 106: "*", 107: "+", 109: "-", 110: ".", 111 : "/",
112: "f1", 113: "f2", 114: "f3", 115: "f4", 116: "f5", 117: "f6", 118: "f7", 119: "f8",
120: "f9", 121: "f10", 122: "f11", 123: "f12", 144: "numlock", 145: "scroll", 186: ";", 191: "/",
220: "\\", 222: "'", 224: "meta"
},
shiftNums: {
"`": "~", "1": "!", "2": "@", "3": "#", "4": "$", "5": "%", "6": "^", "7": "&",
"8": "*", "9": "(", "0": ")", "-": "_", "=": "+", ";": ": ", "'": "\"", ",": "<",
".": ">", "/": "?", "\\": "|"
}
};
specialKeys: {
8: 'backspace',
9: 'tab',
10: 'return',
13: 'enter',
16: 'shift',
17: 'ctrl',
18: 'alt',
19: 'pause',
20: 'capslock',
27: 'esc',
32: 'space',
33: 'pageup',
34: 'pagedown',
35: 'end',
36: 'home',
37: 'left',
38: 'up',
39: 'right',
40: 'down',
45: 'insert',
46: 'del',
96: '0',
97: '1',
98: '2',
99: '3',
100: '4',
101: '5',
102: '6',
103: '7',
104: '8',
105: '9',
106: '*',
107: '+',
109: '-',
110: '.',
111: '/',
112: 'f1',
113: 'f2',
114: 'f3',
115: 'f4',
116: 'f5',
117: 'f6',
118: 'f7',
119: 'f8',
120: 'f9',
121: 'f10',
122: 'f11',
123: 'f12',
144: 'numlock',
145: 'scroll',
186: ';',
191: '/',
220: '\\',
222: "'",
224: 'meta',
},
function keyHandler( handleObj ) {
if ( typeof handleObj.data === "string" ) {
handleObj.data = { keys: handleObj.data };
}
shiftNums: {
'`': '~',
1: '!',
2: '@',
3: '#',
4: '$',
5: '%',
6: '^',
7: '&',
8: '*',
9: '(',
0: ')',
'-': '_',
'=': '+',
';': ': ',
"'": '"',
',': '<',
'.': '>',
'/': '?',
'\\': '|',
},
};
// Only care when a possible input has been specified
if ( !handleObj.data || !handleObj.data.keys || typeof handleObj.data.keys !== "string" ) {
return;
}
function keyHandler(handleObj) {
if (typeof handleObj.data === 'string') {
handleObj.data = { keys: handleObj.data };
}
var origHandler = handleObj.handler,
keys = handleObj.data.keys.toLowerCase().split(" "),
textAcceptingInputTypes = ["text", "password", "number", "email", "url", "range", "date", "month", "week", "time", "datetime", "datetime-local", "search", "color", "tel"];
handleObj.handler = function( event ) {
// Don't fire in text-accepting inputs that we didn't directly bind to
if ( this !== event.target && (/textarea|select/i.test( event.target.nodeName ) ||
jQuery.inArray(event.target.type, textAcceptingInputTypes) > -1 ) ) {
return;
}
// Only care when a possible input has been specified
if (!handleObj.data || !handleObj.data.keys || typeof handleObj.data.keys !== 'string') {
return;
}
var special = jQuery.hotkeys.specialKeys[ event.keyCode ],
character = String.fromCharCode( event.which ).toLowerCase(),
modif = "", possible = {};
const origHandler = handleObj.handler;
const keys = handleObj.data.keys.toLowerCase().split(' ');
const textAcceptingInputTypes = ['text', 'password', 'number', 'email', 'url', 'range', 'date', 'month', 'week', 'time', 'datetime', 'datetime-local', 'search', 'color', 'tel'];
// check combinations (alt|ctrl|shift+anything)
if ( event.altKey && special !== "alt" ) {
modif += "alt+";
}
handleObj.handler = function (event) {
// Don't fire in text-accepting inputs that we didn't directly bind to
if (this !== event.target && (/textarea|select/i.test(event.target.nodeName)
|| jQuery.inArray(event.target.type, textAcceptingInputTypes) > -1)) {
return;
}
if ( event.ctrlKey && special !== "ctrl" ) {
modif += "ctrl+";
}
// TODO: Need to make sure this works consistently across platforms
if ( event.metaKey && !event.ctrlKey && special !== "meta" ) {
modif += "meta+";
}
const special = jQuery.hotkeys.specialKeys[event.keyCode];
const character = String.fromCharCode(event.which).toLowerCase();
let modif = ''; const
possible = {};
if ( event.shiftKey && special !== "shift" ) {
modif += "shift+";
}
// check combinations (alt|ctrl|shift+anything)
if (event.altKey && special !== 'alt') {
modif += 'alt+';
}
if ( special ) {
possible[ modif + special ] = true;
}
if (event.ctrlKey && special !== 'ctrl') {
modif += 'ctrl+';
}
if ( character ) {
possible[ modif + character ] = true;
possible[ modif + jQuery.hotkeys.shiftNums[ character ] ] = true;
// TODO: Need to make sure this works consistently across platforms
if (event.metaKey && !event.ctrlKey && special !== 'meta') {
modif += 'meta+';
}
// "$" can be triggered as "Shift+4" or "Shift+$" or just "$"
if ( modif === "shift+" ) {
possible[ jQuery.hotkeys.shiftNums[ character ] ] = true;
}
}
if (event.shiftKey && special !== 'shift') {
modif += 'shift+';
}
for ( var i = 0, l = keys.length; i < l; i++ ) {
if ( possible[ keys[i] ] ) {
return origHandler.apply( this, arguments );
}
}
};
}
if (special) {
possible[modif + special] = true;
}
jQuery.each([ "keydown", "keyup", "keypress" ], function() {
jQuery.event.special[ this ] = { add: keyHandler };
});
if (character) {
possible[modif + character] = true;
possible[modif + jQuery.hotkeys.shiftNums[character]] = true;
})( this.jQuery );
// "$" can be triggered as "Shift+4" or "Shift+$" or just "$"
if (modif === 'shift+') {
possible[jQuery.hotkeys.shiftNums[character]] = true;
}
}
for (let i = 0, l = keys.length; i < l; i++) {
if (possible[keys[i]]) {
return origHandler.apply(this, arguments);
}
}
};
}
jQuery.each(['keydown', 'keyup', 'keypress'], function () {
jQuery.event.special[this] = { add: keyHandler };
});
}(this.jQuery));

16712
packages/mindplot/lib/components/libraries/jquery/jquery-2.1.0.js vendored
View File

File diff suppressed because it is too large Load Diff

187
packages/mindplot/lib/components/libraries/jquery/jquery-2.1.0.min.js vendored
View File

File diff suppressed because one or more lines are too long

6
packages/mindplot/lib/components/libraries/jquery/jquery.mousewheel.min.js vendored
View File

@ -5,4 +5,8 @@
*
* Requires: jQuery 1.2.2+
*/
!function(a){"function"==typeof define&&define.amd?define(["jquery"],a):"object"==typeof exports?module.exports=a:a(jQuery)}(function(a){function b(b){var g=b||window.event,h=i.call(arguments,1),j=0,l=0,m=0,n=0,o=0,p=0;if(b=a.event.fix(g),b.type="mousewheel","detail"in g&&(m=-1*g.detail),"wheelDelta"in g&&(m=g.wheelDelta),"wheelDeltaY"in g&&(m=g.wheelDeltaY),"wheelDeltaX"in g&&(l=-1*g.wheelDeltaX),"axis"in g&&g.axis===g.HORIZONTAL_AXIS&&(l=-1*m,m=0),j=0===m?l:m,"deltaY"in g&&(m=-1*g.deltaY,j=m),"deltaX"in g&&(l=g.deltaX,0===m&&(j=-1*l)),0!==m||0!==l){if(1===g.deltaMode){var q=a.data(this,"mousewheel-line-height");j*=q,m*=q,l*=q}else if(2===g.deltaMode){var r=a.data(this,"mousewheel-page-height");j*=r,m*=r,l*=r}if(n=Math.max(Math.abs(m),Math.abs(l)),(!f||f>n)&&(f=n,d(g,n)&&(f/=40)),d(g,n)&&(j/=40,l/=40,m/=40),j=Math[j>=1?"floor":"ceil"](j/f),l=Math[l>=1?"floor":"ceil"](l/f),m=Math[m>=1?"floor":"ceil"](m/f),k.settings.normalizeOffset&&this.getBoundingClientRect){var s=this.getBoundingClientRect();o=b.clientX-s.left,p=b.clientY-s.top}return b.deltaX=l,b.deltaY=m,b.deltaFactor=f,b.offsetX=o,b.offsetY=p,b.deltaMode=0,h.unshift(b,j,l,m),e&&clearTimeout(e),e=setTimeout(c,200),(a.event.dispatch||a.event.handle).apply(this,h)}}function c(){f=null}function d(a,b){return k.settings.adjustOldDeltas&&"mousewheel"===a.type&&b%120===0}var e,f,g=["wheel","mousewheel","DOMMouseScroll","MozMousePixelScroll"],h="onwheel"in document||document.documentMode>=9?["wheel"]:["mousewheel","DomMouseScroll","MozMousePixelScroll"],i=Array.prototype.slice;if(a.event.fixHooks)for(var j=g.length;j;)a.event.fixHooks[g[--j]]=a.event.mouseHooks;var k=a.event.special.mousewheel={version:"3.1.11",setup:function(){if(this.addEventListener)for(var c=h.length;c;)this.addEventListener(h[--c],b,!1);else this.onmousewheel=b;a.data(this,"mousewheel-line-height",k.getLineHeight(this)),a.data(this,"mousewheel-page-height",k.getPageHeight(this))},teardown:function(){if(this.removeEventListener)for(var c=h.length;c;)this.removeEventListener(h[--c],b,!1);else this.onmousewheel=null;a.removeData(this,"mousewheel-line-height"),a.removeData(this,"mousewheel-page-height")},getLineHeight:function(b){var c=a(b)["offsetParent"in a.fn?"offsetParent":"parent"]();return c.length||(c=a("body")),parseInt(c.css("fontSize"),10)},getPageHeight:function(b){return a(b).height()},settings:{adjustOldDeltas:!0,normalizeOffset:!0}};a.fn.extend({mousewheel:function(a){return a?this.bind("mousewheel",a):this.trigger("mousewheel")},unmousewheel:function(a){return this.unbind("mousewheel",a)}})});
!(function (a) { typeof define === 'function' && define.amd ? define(['jquery'], a) : typeof exports === 'object' ? module.exports = a : a(jQuery); }((a) => {
function b(b) { const g = b || window.event; const h = i.call(arguments, 1); let j = 0; let l = 0; let m = 0; let n = 0; let o = 0; let p = 0; if (b = a.event.fix(g), b.type = 'mousewheel', 'detail' in g && (m = -1 * g.detail), 'wheelDelta' in g && (m = g.wheelDelta), 'wheelDeltaY' in g && (m = g.wheelDeltaY), 'wheelDeltaX' in g && (l = -1 * g.wheelDeltaX), 'axis' in g && g.axis === g.HORIZONTAL_AXIS && (l = -1 * m, m = 0), j = m === 0 ? l : m, 'deltaY' in g && (m = -1 * g.deltaY, j = m), 'deltaX' in g && (l = g.deltaX, m === 0 && (j = -1 * l)), m !== 0 || l !== 0) { if (g.deltaMode === 1) { const q = a.data(this, 'mousewheel-line-height'); j *= q, m *= q, l *= q; } else if (g.deltaMode === 2) { const r = a.data(this, 'mousewheel-page-height'); j *= r, m *= r, l *= r; } if (n = Math.max(Math.abs(m), Math.abs(l)), (!f || f > n) && (f = n, d(g, n) && (f /= 40)), d(g, n) && (j /= 40, l /= 40, m /= 40), j = Math[j >= 1 ? 'floor' : 'ceil'](j / f), l = Math[l >= 1 ? 'floor' : 'ceil'](l / f), m = Math[m >= 1 ? 'floor' : 'ceil'](m / f), k.settings.normalizeOffset && this.getBoundingClientRect) { const s = this.getBoundingClientRect(); o = b.clientX - s.left, p = b.clientY - s.top; } return b.deltaX = l, b.deltaY = m, b.deltaFactor = f, b.offsetX = o, b.offsetY = p, b.deltaMode = 0, h.unshift(b, j, l, m), e && clearTimeout(e), e = setTimeout(c, 200), (a.event.dispatch || a.event.handle).apply(this, h); } } function c() { f = null; } function d(a, b) { return k.settings.adjustOldDeltas && a.type === 'mousewheel' && b % 120 === 0; } let e; let f; const g = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll']; const h = 'onwheel' in document || document.documentMode >= 9 ? ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll']; var i = Array.prototype.slice; if (a.event.fixHooks) for (let j = g.length; j;)a.event.fixHooks[g[--j]] = a.event.mouseHooks; var k = a.event.special.mousewheel = {
version: '3.1.11', setup() { if (this.addEventListener) for (let c = h.length; c;) this.addEventListener(h[--c], b, !1); else this.onmousewheel = b; a.data(this, 'mousewheel-line-height', k.getLineHeight(this)), a.data(this, 'mousewheel-page-height', k.getPageHeight(this)); }, teardown() { if (this.removeEventListener) for (let c = h.length; c;) this.removeEventListener(h[--c], b, !1); else this.onmousewheel = null; a.removeData(this, 'mousewheel-line-height'), a.removeData(this, 'mousewheel-page-height'); }, getLineHeight(b) { let c = a(b)['offsetParent' in a.fn ? 'offsetParent' : 'parent'](); return c.length || (c = a('body')), parseInt(c.css('fontSize'), 10); }, getPageHeight(b) { return a(b).height(); }, settings: { adjustOldDeltas: !0, normalizeOffset: !0 },
}; a.fn.extend({ mousewheel(a) { return a ? this.bind('mousewheel', a) : this.trigger('mousewheel'); }, unmousewheel(a) { return this.unbind('mousewheel', a); } });
}));

366
packages/mindplot/lib/components/libraries/less/less-1.4.2.min.js vendored
View File

File diff suppressed because one or more lines are too long

427
packages/mindplot/lib/components/libraries/less/less-1.6.2.min.js vendored
View File

File diff suppressed because one or more lines are too long

1086
packages/mindplot/lib/components/libraries/mootools/mootools-core-1.4.5-full-nocompat-yc.js vendored
View File

File diff suppressed because it is too large Load Diff

311
packages/mindplot/lib/components/libraries/mootools/mootools-core-1.4.5.js vendored
View File

@ -16,61 +16,256 @@
...
*/
(function(){this.MooTools={version:"1.4.5",build:"ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0"};var o=this.typeOf=function(i){if(i==null){return"null";}if(i.$family!=null){return i.$family();
}if(i.nodeName){if(i.nodeType==1){return"element";}if(i.nodeType==3){return(/\S/).test(i.nodeValue)?"textnode":"whitespace";}}else{if(typeof i.length=="number"){if(i.callee){return"arguments";
}if("item" in i){return"collection";}}}return typeof i;};var j=this.instanceOf=function(t,i){if(t==null){return false;}var s=t.$constructor||t.constructor;
while(s){if(s===i){return true;}s=s.parent;}if(!t.hasOwnProperty){return false;}return t instanceof i;};var f=this.Function;var p=true;for(var k in {toString:1}){p=null;
}if(p){p=["hasOwnProperty","valueOf","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","constructor"];}f.prototype.overloadSetter=function(s){var i=this;
return function(u,t){if(u==null){return this;}if(s||typeof u!="string"){for(var v in u){i.call(this,v,u[v]);}if(p){for(var w=p.length;w--;){v=p[w];if(u.hasOwnProperty(v)){i.call(this,v,u[v]);
}}}}else{i.call(this,u,t);}return this;};};f.prototype.overloadGetter=function(s){var i=this;return function(u){var v,t;if(typeof u!="string"){v=u;}else{if(arguments.length>1){v=arguments;
}else{if(s){v=[u];}}}if(v){t={};for(var w=0;w<v.length;w++){t[v[w]]=i.call(this,v[w]);}}else{t=i.call(this,u);}return t;};};f.prototype.extend=function(i,s){this[i]=s;
}.overloadSetter();f.prototype.implement=function(i,s){this.prototype[i]=s;}.overloadSetter();var n=Array.prototype.slice;f.from=function(i){return(o(i)=="function")?i:function(){return i;
};};Array.from=function(i){if(i==null){return[];}return(a.isEnumerable(i)&&typeof i!="string")?(o(i)=="array")?i:n.call(i):[i];};Number.from=function(s){var i=parseFloat(s);
return isFinite(i)?i:null;};String.from=function(i){return i+"";};f.implement({hide:function(){this.$hidden=true;return this;},protect:function(){this.$protected=true;
return this;}});var a=this.Type=function(u,t){if(u){var s=u.toLowerCase();var i=function(v){return(o(v)==s);};a["is"+u]=i;if(t!=null){t.prototype.$family=(function(){return s;
}).hide();}}if(t==null){return null;}t.extend(this);t.$constructor=a;t.prototype.$constructor=t;return t;};var e=Object.prototype.toString;a.isEnumerable=function(i){return(i!=null&&typeof i.length=="number"&&e.call(i)!="[object Function]");
};var q={};var r=function(i){var s=o(i.prototype);return q[s]||(q[s]=[]);};var b=function(t,x){if(x&&x.$hidden){return;}var s=r(this);for(var u=0;u<s.length;
u++){var w=s[u];if(o(w)=="type"){b.call(w,t,x);}else{w.call(this,t,x);}}var v=this.prototype[t];if(v==null||!v.$protected){this.prototype[t]=x;}if(this[t]==null&&o(x)=="function"){m.call(this,t,function(i){return x.apply(i,n.call(arguments,1));
});}};var m=function(i,t){if(t&&t.$hidden){return;}var s=this[i];if(s==null||!s.$protected){this[i]=t;}};a.implement({implement:b.overloadSetter(),extend:m.overloadSetter(),alias:function(i,s){b.call(this,i,this.prototype[s]);
}.overloadSetter(),mirror:function(i){r(this).push(i);return this;}});new a("Type",a);var d=function(s,x,v){var u=(x!=Object),B=x.prototype;if(u){x=new a(s,x);
}for(var y=0,w=v.length;y<w;y++){var C=v[y],A=x[C],z=B[C];if(A){A.protect();}if(u&&z){x.implement(C,z.protect());}}if(u){var t=B.propertyIsEnumerable(v[0]);
x.forEachMethod=function(G){if(!t){for(var F=0,D=v.length;F<D;F++){G.call(B,B[v[F]],v[F]);}}for(var E in B){G.call(B,B[E],E);}};}return d;};d("String",String,["charAt","charCodeAt","concat","indexOf","lastIndexOf","match","quote","replace","search","slice","split","substr","substring","trim","toLowerCase","toUpperCase"])("Array",Array,["pop","push","reverse","shift","sort","splice","unshift","concat","join","slice","indexOf","lastIndexOf","filter","forEach","every","map","some","reduce","reduceRight"])("Number",Number,["toExponential","toFixed","toLocaleString","toPrecision"])("Function",f,["apply","call","bind"])("RegExp",RegExp,["exec","test"])("Object",Object,["create","defineProperty","defineProperties","keys","getPrototypeOf","getOwnPropertyDescriptor","getOwnPropertyNames","preventExtensions","isExtensible","seal","isSealed","freeze","isFrozen"])("Date",Date,["now"]);
Object.extend=m.overloadSetter();Date.extend("now",function(){return +(new Date);});new a("Boolean",Boolean);Number.prototype.$family=function(){return isFinite(this)?"number":"null";
}.hide();Number.extend("random",function(s,i){return Math.floor(Math.random()*(i-s+1)+s);});var g=Object.prototype.hasOwnProperty;Object.extend("forEach",function(i,t,u){for(var s in i){if(g.call(i,s)){t.call(u,i[s],s,i);
}}});Object.each=Object.forEach;Array.implement({forEach:function(u,v){for(var t=0,s=this.length;t<s;t++){if(t in this){u.call(v,this[t],t,this);}}},each:function(i,s){Array.forEach(this,i,s);
return this;}});var l=function(i){switch(o(i)){case"array":return i.clone();case"object":return Object.clone(i);default:return i;}};Array.implement("clone",function(){var s=this.length,t=new Array(s);
while(s--){t[s]=l(this[s]);}return t;});var h=function(s,i,t){switch(o(t)){case"object":if(o(s[i])=="object"){Object.merge(s[i],t);}else{s[i]=Object.clone(t);
}break;case"array":s[i]=t.clone();break;default:s[i]=t;}return s;};Object.extend({merge:function(z,u,t){if(o(u)=="string"){return h(z,u,t);}for(var y=1,s=arguments.length;
y<s;y++){var w=arguments[y];for(var x in w){h(z,x,w[x]);}}return z;},clone:function(i){var t={};for(var s in i){t[s]=l(i[s]);}return t;},append:function(w){for(var v=1,t=arguments.length;
v<t;v++){var s=arguments[v]||{};for(var u in s){w[u]=s[u];}}return w;}});["Object","WhiteSpace","TextNode","Collection","Arguments"].each(function(i){new a(i);
});var c=Date.now();String.extend("uniqueID",function(){return(c++).toString(36);});})();Array.implement({every:function(c,d){for(var b=0,a=this.length>>>0;
b<a;b++){if((b in this)&&!c.call(d,this[b],b,this)){return false;}}return true;},filter:function(d,f){var c=[];for(var e,b=0,a=this.length>>>0;b<a;b++){if(b in this){e=this[b];
if(d.call(f,e,b,this)){c.push(e);}}}return c;},indexOf:function(c,d){var b=this.length>>>0;for(var a=(d<0)?Math.max(0,b+d):d||0;a<b;a++){if(this[a]===c){return a;
}}return -1;},map:function(c,e){var d=this.length>>>0,b=Array(d);for(var a=0;a<d;a++){if(a in this){b[a]=c.call(e,this[a],a,this);}}return b;},some:function(c,d){for(var b=0,a=this.length>>>0;
b<a;b++){if((b in this)&&c.call(d,this[b],b,this)){return true;}}return false;},clean:function(){return this.filter(function(a){return a!=null;});},invoke:function(a){var b=Array.slice(arguments,1);
return this.map(function(c){return c[a].apply(c,b);});},associate:function(c){var d={},b=Math.min(this.length,c.length);for(var a=0;a<b;a++){d[c[a]]=this[a];
}return d;},link:function(c){var a={};for(var e=0,b=this.length;e<b;e++){for(var d in c){if(c[d](this[e])){a[d]=this[e];delete c[d];break;}}}return a;},contains:function(a,b){return this.indexOf(a,b)!=-1;
},append:function(a){this.push.apply(this,a);return this;},getLast:function(){return(this.length)?this[this.length-1]:null;},getRandom:function(){return(this.length)?this[Number.random(0,this.length-1)]:null;
},include:function(a){if(!this.contains(a)){this.push(a);}return this;},combine:function(c){for(var b=0,a=c.length;b<a;b++){this.include(c[b]);}return this;
},erase:function(b){for(var a=this.length;a--;){if(this[a]===b){this.splice(a,1);}}return this;},empty:function(){this.length=0;return this;},flatten:function(){var d=[];
for(var b=0,a=this.length;b<a;b++){var c=typeOf(this[b]);if(c=="null"){continue;}d=d.concat((c=="array"||c=="collection"||c=="arguments"||instanceOf(this[b],Array))?Array.flatten(this[b]):this[b]);
}return d;},pick:function(){for(var b=0,a=this.length;b<a;b++){if(this[b]!=null){return this[b];}}return null;},rgbToHex:function(d){if(this.length<3){return null;}if(this.length==4&&this[3]==0&&!d){return"transparent";
}var b=[];for(var a=0;a<3;a++){var c=(this[a]-0).toString(16);b.push((c.length==1)?"0"+c:c);}return(d)?b:"#"+b.join("");}});String.implement({test:function(a,b){return((typeOf(a)=="regexp")?a:new RegExp(""+a,b)).test(this);
},contains:function(a,b){return(b)?(b+this+b).indexOf(b+a+b)>-1:String(this).indexOf(a)>-1;},trim:function(){return String(this).replace(/^\s+|\s+$/g,"");
},clean:function(){return String(this).replace(/\s+/g," ").trim();},camelCase:function(){return String(this).replace(/-\D/g,function(a){return a.charAt(1).toUpperCase();
});},hyphenate:function(){return String(this).replace(/[A-Z]/g,function(a){return("-"+a.charAt(0).toLowerCase());});},capitalize:function(){return String(this).replace(/\b[a-z]/g,function(a){return a.toUpperCase();
});},escapeRegExp:function(){return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g,"\\$1");},rgbToHex:function(b){var a=String(this).match(/\d{1,3}/g);
return(a)?a.rgbToHex(b):null;},substitute:function(a,b){return String(this).replace(b||(/\\?\{([^{}]+)\}/g),function(d,c){if(d.charAt(0)=="\\"){return d.slice(1);
}return(a[c]!=null)?a[c]:"";});}});
Function.implement({bind:function(e){var a=this,b=arguments.length>1?Array.slice(arguments,1):null,d=function(){};var c=function(){var g=e,h=arguments.length;if(this instanceof c){d.prototype=a.prototype;g=new d;}var f=(!b&&!h)?a.call(g):a.apply(g,b&&h?b.concat(Array.slice(arguments)):b||arguments);return g==e?f:g;};return c;},pass:function(b,c){var a=this;if(b!=null){b=Array.from(b);}return function(){return a.apply(c,b||arguments);};},delay:function(b,c,a){return setTimeout(this.pass((a==null?[]:a),c),b);},});
Number.alias("each","times");(function(b){var a={};b.each(function(c){if(!Number[c]){a[c]=function(){return Math[c].apply(null,[this].concat(Array.from(arguments)));
};}});Number.implement(a);})(["abs","acos","asin","atan","atan2","ceil","cos","exp","floor","log","max","min","pow","sin","sqrt","tan"]);(function(){var a=this.Class=new Type("Class",function(h){if(instanceOf(h,Function)){h={initialize:h};
}var g=function(){e(this);if(g.$prototyping){return this;}this.$caller=null;var i=(this.initialize)?this.initialize.apply(this,arguments):this;this.$caller=this.caller=null;
return i;}.extend(this).implement(h);g.$constructor=a;g.prototype.$constructor=g;g.prototype.parent=c;return g;});var c=function(){if(!this.$caller){throw new Error('The method "parent" cannot be called.');
}var g=this.$caller.$name,h=this.$caller.$owner.parent,i=(h)?h.prototype[g]:null;if(!i){throw new Error('The method "'+g+'" has no parent.');}return i.apply(this,arguments);
};var e=function(g){for(var h in g){var j=g[h];switch(typeOf(j)){case"object":var i=function(){};i.prototype=j;g[h]=e(new i);break;case"array":g[h]=j.clone();
break;}}return g;};var b=function(g,h,j){if(j.$origin){j=j.$origin;}var i=function(){if(j.$protected&&this.$caller==null){throw new Error('The method "'+h+'" cannot be called.');
}var l=this.caller,m=this.$caller;this.caller=m;this.$caller=i;var k=j.apply(this,arguments);this.$caller=m;this.caller=l;return k;}.extend({$owner:g,$origin:j,$name:h});
return i;};var f=function(h,i,g){if(a.Mutators.hasOwnProperty(h)){i=a.Mutators[h].call(this,i);if(i==null){return this;}}if(typeOf(i)=="function"){if(i.$hidden){return this;
}this.prototype[h]=(g)?i:b(this,h,i);}else{Object.merge(this.prototype,h,i);}return this;};var d=function(g){g.$prototyping=true;var h=new g;delete g.$prototyping;
return h;};a.implement("implement",f.overloadSetter());a.Mutators={Extends:function(g){this.parent=g;this.prototype=d(g);},Implements:function(g){Array.from(g).each(function(j){var h=new j;for(var i in h){f.call(this,i,h[i],true);}},this);}};})();
(function () {
this.MooTools = { version: '1.4.5', build: 'ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0' }; const o = this.typeOf = function (i) {
if (i == null) { return 'null'; } if (i.$family != null) {
return i.$family();
} if (i.nodeName) { if (i.nodeType == 1) { return 'element'; } if (i.nodeType == 3) { return (/\S/).test(i.nodeValue) ? 'textnode' : 'whitespace'; } } else if (typeof i.length === 'number') {
if (i.callee) {
return 'arguments';
} if ('item' in i) { return 'collection'; }
} return typeof i;
}; const j = this.instanceOf = function (t, i) {
if (t == null) { return false; } let s = t.$constructor || t.constructor;
while (s) { if (s === i) { return true; }s = s.parent; } if (!t.hasOwnProperty) { return false; } return t instanceof i;
}; const f = this.Function; let p = true; for (const k in { toString: 1 }) {
p = null;
} if (p) { p = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor']; }f.prototype.overloadSetter = function (s) {
const i = this;
return function (u, t) {
if (u == null) { return this; } if (s || typeof u !== 'string') {
for (var v in u) { i.call(this, v, u[v]); } if (p) {
for (let w = p.length; w--;) {
v = p[w]; if (u.hasOwnProperty(v)) {
i.call(this, v, u[v]);
}
}
}
} else { i.call(this, u, t); } return this;
};
}; f.prototype.overloadGetter = function (s) {
const i = this; return function (u) {
let v; let t; if (typeof u !== 'string') { v = u; } else if (arguments.length > 1) {
v = arguments;
} else if (s) { v = [u]; } if (v) { t = {}; for (let w = 0; w < v.length; w++) { t[v[w]] = i.call(this, v[w]); } } else { t = i.call(this, u); } return t;
};
}; f.prototype.extend = function (i, s) {
this[i] = s;
}.overloadSetter(); f.prototype.implement = function (i, s) { this.prototype[i] = s; }.overloadSetter(); const n = Array.prototype.slice; f.from = function (i) {
return (o(i) == 'function') ? i : function () {
return i;
};
}; Array.from = function (i) { if (i == null) { return []; } return (a.isEnumerable(i) && typeof i !== 'string') ? (o(i) == 'array') ? i : n.call(i) : [i]; }; Number.from = function (s) {
const i = parseFloat(s);
return isFinite(i) ? i : null;
}; String.from = function (i) { return `${i}`; }; f.implement({
hide() { this.$hidden = true; return this; },
protect() {
this.$protected = true;
return this;
},
}); var a = this.Type = function (u, t) {
if (u) {
const s = u.toLowerCase(); const i = function (v) { return (o(v) == s); }; a[`is${u}`] = i; if (t != null) {
t.prototype.$family = (function () {
return s;
}).hide();
}
} if (t == null) { return null; }t.extend(this); t.$constructor = a; t.prototype.$constructor = t; return t;
}; const e = Object.prototype.toString; a.isEnumerable = function (i) {
return (i != null && typeof i.length === 'number' && e.call(i) != '[object Function]');
}; const q = {}; const r = function (i) { const s = o(i.prototype); return q[s] || (q[s] = []); }; var b = function (t, x) {
if (x && x.$hidden) { return; } const s = r(this); for (let u = 0; u < s.length;
u++) { const w = s[u]; if (o(w) == 'type') { b.call(w, t, x); } else { w.call(this, t, x); } } const v = this.prototype[t]; if (v == null || !v.$protected) { this.prototype[t] = x; } if (this[t] == null && o(x) == 'function') {
m.call(this, t, function (i) {
return x.apply(i, n.call(arguments, 1));
});
}
}; var m = function (i, t) { if (t && t.$hidden) { return; } const s = this[i]; if (s == null || !s.$protected) { this[i] = t; } }; a.implement({
implement: b.overloadSetter(),
extend: m.overloadSetter(),
alias: function (i, s) {
b.call(this, i, this.prototype[s]);
}.overloadSetter(),
mirror(i) { r(this).push(i); return this; },
}); new a('Type', a); var d = function (s, x, v) {
const u = (x != Object); const B = x.prototype; if (u) {
x = new a(s, x);
} for (let y = 0, w = v.length; y < w; y++) { const C = v[y]; const A = x[C]; const z = B[C]; if (A) { A.protect(); } if (u && z) { x.implement(C, z.protect()); } } if (u) {
const t = B.propertyIsEnumerable(v[0]);
x.forEachMethod = function (G) { if (!t) { for (let F = 0, D = v.length; F < D; F++) { G.call(B, B[v[F]], v[F]); } } for (const E in B) { G.call(B, B[E], E); } };
} return d;
}; d('String', String, ['charAt', 'charCodeAt', 'concat', 'indexOf', 'lastIndexOf', 'match', 'quote', 'replace', 'search', 'slice', 'split', 'substr', 'substring', 'trim', 'toLowerCase', 'toUpperCase'])('Array', Array, ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice', 'indexOf', 'lastIndexOf', 'filter', 'forEach', 'every', 'map', 'some', 'reduce', 'reduceRight'])('Number', Number, ['toExponential', 'toFixed', 'toLocaleString', 'toPrecision'])('Function', f, ['apply', 'call', 'bind'])('RegExp', RegExp, ['exec', 'test'])('Object', Object, ['create', 'defineProperty', 'defineProperties', 'keys', 'getPrototypeOf', 'getOwnPropertyDescriptor', 'getOwnPropertyNames', 'preventExtensions', 'isExtensible', 'seal', 'isSealed', 'freeze', 'isFrozen'])('Date', Date, ['now']);
Object.extend = m.overloadSetter(); Date.extend('now', () => +(new Date())); new a('Boolean', Boolean); Number.prototype.$family = function () {
return isFinite(this) ? 'number' : 'null';
}.hide(); Number.extend('random', (s, i) => Math.floor(Math.random() * (i - s + 1) + s)); const g = Object.prototype.hasOwnProperty; Object.extend('forEach', (i, t, u) => {
for (const s in i) {
if (g.call(i, s)) {
t.call(u, i[s], s, i);
}
}
}); Object.each = Object.forEach; Array.implement({
forEach(u, v) { for (let t = 0, s = this.length; t < s; t++) { if (t in this) { u.call(v, this[t], t, this); } } },
each(i, s) {
Array.forEach(this, i, s);
return this;
},
}); const l = function (i) { switch (o(i)) { case 'array': return i.clone(); case 'object': return Object.clone(i); default: return i; } }; Array.implement('clone', function () {
let s = this.length; const t = new Array(s);
while (s--) { t[s] = l(this[s]); } return t;
}); const h = function (s, i, t) {
switch (o(t)) {
case 'object': if (o(s[i]) == 'object') { Object.merge(s[i], t); } else {
s[i] = Object.clone(t);
} break; case 'array': s[i] = t.clone(); break; default: s[i] = t;
} return s;
}; Object.extend({
merge(z, u, t) {
if (o(u) == 'string') { return h(z, u, t); } for (let y = 1, s = arguments.length;
y < s; y++) { const w = arguments[y]; for (const x in w) { h(z, x, w[x]); } } return z;
},
clone(i) { const t = {}; for (const s in i) { t[s] = l(i[s]); } return t; },
append(w) {
for (let v = 1, t = arguments.length;
v < t; v++) { const s = arguments[v] || {}; for (const u in s) { w[u] = s[u]; } } return w;
},
}); ['Object', 'WhiteSpace', 'TextNode', 'Collection', 'Arguments'].each((i) => {
new a(i);
}); let c = Date.now(); String.extend('uniqueID', () => (c++).toString(36));
}()); Array.implement({
every(c, d) {
for (let b = 0, a = this.length >>> 0;
b < a; b++) { if ((b in this) && !c.call(d, this[b], b, this)) { return false; } } return true;
},
filter(d, f) {
const c = []; for (var e, b = 0, a = this.length >>> 0; b < a; b++) {
if (b in this) {
e = this[b];
if (d.call(f, e, b, this)) { c.push(e); }
}
} return c;
},
indexOf(c, d) {
const b = this.length >>> 0; for (let a = (d < 0) ? Math.max(0, b + d) : d || 0; a < b; a++) {
if (this[a] === c) {
return a;
}
} return -1;
},
map(c, e) { const d = this.length >>> 0; const b = Array(d); for (let a = 0; a < d; a++) { if (a in this) { b[a] = c.call(e, this[a], a, this); } } return b; },
some(c, d) {
for (let b = 0, a = this.length >>> 0;
b < a; b++) { if ((b in this) && c.call(d, this[b], b, this)) { return true; } } return false;
},
clean() { return this.filter((a) => a != null); },
invoke(a) {
const b = Array.slice(arguments, 1);
return this.map((c) => c[a].apply(c, b));
},
associate(c) {
const d = {}; const b = Math.min(this.length, c.length); for (let a = 0; a < b; a++) {
d[c[a]] = this[a];
} return d;
},
link(c) { const a = {}; for (let e = 0, b = this.length; e < b; e++) { for (const d in c) { if (c[d](this[e])) { a[d] = this[e]; delete c[d]; break; } } } return a; },
contains(a, b) {
return this.indexOf(a, b) != -1;
},
append(a) { this.push.apply(this, a); return this; },
getLast() { return (this.length) ? this[this.length - 1] : null; },
getRandom() {
return (this.length) ? this[Number.random(0, this.length - 1)] : null;
},
include(a) { if (!this.contains(a)) { this.push(a); } return this; },
combine(c) {
for (let b = 0, a = c.length; b < a; b++) { this.include(c[b]); } return this;
},
erase(b) { for (let a = this.length; a--;) { if (this[a] === b) { this.splice(a, 1); } } return this; },
empty() { this.length = 0; return this; },
flatten() {
let d = [];
for (let b = 0, a = this.length; b < a; b++) {
const c = typeOf(this[b]); if (c == 'null') { continue; }d = d.concat((c == 'array' || c == 'collection' || c == 'arguments' || instanceOf(this[b], Array)) ? Array.flatten(this[b]) : this[b]);
} return d;
},
pick() { for (let b = 0, a = this.length; b < a; b++) { if (this[b] != null) { return this[b]; } } return null; },
rgbToHex(d) {
if (this.length < 3) { return null; } if (this.length == 4 && this[3] == 0 && !d) {
return 'transparent';
} const b = []; for (let a = 0; a < 3; a++) { const c = (this[a] - 0).toString(16); b.push((c.length == 1) ? `0${c}` : c); } return (d) ? b : `#${b.join('')}`;
},
}); String.implement({
test(a, b) {
return ((typeOf(a) == 'regexp') ? a : new RegExp(`${a}`, b)).test(this);
},
contains(a, b) { return (b) ? (b + this + b).indexOf(b + a + b) > -1 : String(this).indexOf(a) > -1; },
trim() {
return String(this).replace(/^\s+|\s+$/g, '');
},
clean() { return String(this).replace(/\s+/g, ' ').trim(); },
camelCase() {
return String(this).replace(/-\D/g, (a) => a.charAt(1).toUpperCase());
},
hyphenate() { return String(this).replace(/[A-Z]/g, (a) => (`-${a.charAt(0).toLowerCase()}`)); },
capitalize() {
return String(this).replace(/\b[a-z]/g, (a) => a.toUpperCase());
},
escapeRegExp() { return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1'); },
rgbToHex(b) {
const a = String(this).match(/\d{1,3}/g);
return (a) ? a.rgbToHex(b) : null;
},
substitute(a, b) {
return String(this).replace(b || (/\\?\{([^{}]+)\}/g), (d, c) => {
if (d.charAt(0) == '\\') {
return d.slice(1);
} return (a[c] != null) ? a[c] : '';
});
},
});
Function.implement({ bind(e) { const a = this; const b = arguments.length > 1 ? Array.slice(arguments, 1) : null; const d = function () {}; var c = function () { let g = e; const h = arguments.length; if (this instanceof c) { d.prototype = a.prototype; g = new d(); } const f = (!b && !h) ? a.call(g) : a.apply(g, b && h ? b.concat(Array.slice(arguments)) : b || arguments); return g == e ? f : g; }; return c; }, pass(b, c) { const a = this; if (b != null) { b = Array.from(b); } return function () { return a.apply(c, b || arguments); }; }, delay(b, c, a) { return setTimeout(this.pass((a == null ? [] : a), c), b); } });
Number.alias('each', 'times'); (function (b) {
const a = {}; b.each((c) => {
if (!Number[c]) {
a[c] = function () {
return Math[c].apply(null, [this].concat(Array.from(arguments)));
};
}
}); Number.implement(a);
}(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan'])); (function () {
var a = this.Class = new Type('Class', function (h) {
if (instanceOf(h, Function)) {
h = { initialize: h };
} var g = function () {
e(this); if (g.$prototyping) { return this; } this.$caller = null; const i = (this.initialize) ? this.initialize.apply(this, arguments) : this; this.$caller = this.caller = null;
return i;
}.extend(this).implement(h); g.$constructor = a; g.prototype.$constructor = g; g.prototype.parent = c; return g;
}); var c = function () {
if (!this.$caller) {
throw new Error('The method "parent" cannot be called.');
} const g = this.$caller.$name; const h = this.$caller.$owner.parent; const i = (h) ? h.prototype[g] : null; if (!i) { throw new Error(`The method "${g}" has no parent.`); } return i.apply(this, arguments);
}; var e = function (g) {
for (const h in g) {
const j = g[h]; switch (typeOf(j)) {
case 'object': var i = function () {}; i.prototype = j; g[h] = e(new i()); break; case 'array': g[h] = j.clone();
break;
}
} return g;
}; const b = function (g, h, j) {
if (j.$origin) { j = j.$origin; } var i = function () {
if (j.$protected && this.$caller == null) {
throw new Error(`The method "${h}" cannot be called.`);
} const l = this.caller; const m = this.$caller; this.caller = m; this.$caller = i; const k = j.apply(this, arguments); this.$caller = m; this.caller = l; return k;
}.extend({ $owner: g, $origin: j, $name: h });
return i;
}; const f = function (h, i, g) {
if (a.Mutators.hasOwnProperty(h)) { i = a.Mutators[h].call(this, i); if (i == null) { return this; } } if (typeOf(i) == 'function') {
if (i.$hidden) {
return this;
} this.prototype[h] = (g) ? i : b(this, h, i);
} else { Object.merge(this.prototype, h, i); } return this;
}; const d = function (g) {
g.$prototyping = true; const h = new g(); delete g.$prototyping;
return h;
}; a.implement('implement', f.overloadSetter()); a.Mutators = { Extends(g) { this.parent = g; this.prototype = d(g); }, Implements(g) { Array.from(g).each(function (j) { const h = new j(); for (const i in h) { f.call(this, i, h[i], true); } }, this); } };
}());

10367
packages/mindplot/lib/components/libraries/mootools/mootools-core-1.6.0.js vendored
View File

File diff suppressed because it is too large Load Diff

10
packages/mindplot/lib/components/libraries/underscorejs/underscore-min.js vendored
View File

File diff suppressed because one or more lines are too long

112
packages/mindplot/lib/components/model/FeatureModel.js
View File

@ -17,75 +17,75 @@
*/
const FeatureModel = new Class(/** @lends FeatureModel */{
Static:{
_nextUUID:function () {
if (!$defined(FeatureModel._uuid)) {
FeatureModel._uuid = 0;
}
Static: {
_nextUUID() {
if (!$defined(FeatureModel._uuid)) {
FeatureModel._uuid = 0;
}
FeatureModel._uuid = FeatureModel._uuid + 1;
return FeatureModel._uuid;
}
FeatureModel._uuid += 1;
return FeatureModel._uuid;
},
},
/**
/**
* @constructs
* @param type
* @throws will throw an exception if type is null or undefined
* assigns a unique id and the given type to the new model
*/
initialize:function (type) {
$assert(type, 'type can not be null');
this._id = FeatureModel._nextUUID();
initialize(type) {
$assert(type, 'type can not be null');
this._id = FeatureModel._nextUUID();
this._type = type;
this._attributes = {};
this._type = type;
this._attributes = {};
// Create type method ...
this['is' + $.camelCase(type) + 'Model'] = function () {
return true;
};
},
// Create type method ...
this[`is${$.camelCase(type)}Model`] = function () {
return true;
};
},
/** */
getAttributes:function () {
return Object.clone(this._attributes);
},
/** */
getAttributes() {
return Object.clone(this._attributes);
},
/** */
setAttributes:function (attributes) {
for (key in attributes) {
this["set" + key.capitalize()](attributes[key]);
}
},
/** */
setAttribute:function (key, value) {
$assert(key, 'key id can not be null');
this._attributes[key] = value;
},
/** */
getAttribute:function (key) {
$assert(key, 'key id can not be null');
return this._attributes[key];
},
/** */
getId:function () {
return this._id;
},
/** */
setId:function (id) {
this._id = id;
},
/** */
getType:function () {
return this._type;
/** */
setAttributes(attributes) {
for (key in attributes) {
this[`set${key.capitalize()}`](attributes[key]);
}
},
/** */
setAttribute(key, value) {
$assert(key, 'key id can not be null');
this._attributes[key] = value;
},
/** */
getAttribute(key) {
$assert(key, 'key id can not be null');
return this._attributes[key];
},
/** */
getId() {
return this._id;
},
/** */
setId(id) {
this._id = id;
},
/** */
getType() {
return this._type;
},
});
export default FeatureModel;

238
packages/mindplot/lib/components/model/IMindmap.js
View File

@ -17,165 +17,165 @@
*/
const IMindmap = new Class(/** @lends IMindmap */{
/**
/**
* @constructs
* @abstract
*/
initialize : function() {
throw "Unsupported operation";
},
initialize() {
throw 'Unsupported operation';
},
/** */
getCentralTopic : function() {
return this.getBranches()[0];
},
/** */
getCentralTopic() {
return this.getBranches()[0];
},
/** @abstract */
getDescription : function() {
throw "Unsupported operation";
},
/** @abstract */
getDescription() {
throw 'Unsupported operation';
},
/** @abstract */
setDescription : function(value) {
throw "Unsupported operation";
},
/** @abstract */
setDescription(value) {
throw 'Unsupported operation';
},
/** @abstract */
getId : function() {
throw "Unsupported operation";
},
/** @abstract */
getId() {
throw 'Unsupported operation';
},
/** @abstract */
setId : function(id) {
throw "Unsupported operation";
},
/** @abstract */
setId(id) {
throw 'Unsupported operation';
},
/** @abstract */
getVersion : function() {
throw "Unsupported operation";
},
/** @abstract */
getVersion() {
throw 'Unsupported operation';
},
/** @abstract */
setVersion : function(version) {
throw "Unsupported operation";
},
/** @abstract */
setVersion(version) {
throw 'Unsupported operation';
},
/** @abstract */
addBranch : function(nodeModel) {
throw "Unsupported operation";
},
/** @abstract */
addBranch(nodeModel) {
throw 'Unsupported operation';
},
/** @abstract */
getBranches : function() {
throw "Unsupported operation";
},
/** @abstract */
getBranches() {
throw 'Unsupported operation';
},
/** @abstract */
removeBranch : function(node) {
throw "Unsupported operation";
},
/** @abstract */
removeBranch(node) {
throw 'Unsupported operation';
},
/** @abstract */
getRelationships : function() {
throw "Unsupported operation";
},
/** @abstract */
getRelationships() {
throw 'Unsupported operation';
},
/**
/**
* @param parent
* @param child
* @throws will throw an error if child already has a connection to a parent node
*/
connect : function(parent, child) {
// Child already has a parent ?
$assert(!child.getParent(), 'Child model seems to be already connected');
connect(parent, child) {
// Child already has a parent ?
$assert(!child.getParent(), 'Child model seems to be already connected');
// Connect node...
parent.append(child);
// Connect node...
parent.append(child);
// Remove from the branch ...
this.removeBranch(child);
},
// Remove from the branch ...
this.removeBranch(child);
},
/**
/**
* @param child
* @throws will throw an error if child is null or undefined
* @throws will throw an error if child's parent cannot be found
*/
disconnect : function(child) {
var parent = child.getParent();
$assert(child, 'Child can not be null.');
$assert(parent, 'Child model seems to be already connected');
disconnect(child) {
const parent = child.getParent();
$assert(child, 'Child can not be null.');
$assert(parent, 'Child model seems to be already connected');
parent.removeChild(child);
this.addBranch(child);
},
parent.removeChild(child);
this.addBranch(child);
},
/** @abstract */
hasAlreadyAdded : function(node) {
throw "Unsupported operation";
},
/** @abstract */
hasAlreadyAdded(node) {
throw 'Unsupported operation';
},
/** @abstract */
createNode : function(type, id) {
throw "Unsupported operation";
},
/** @abstract */
createNode(type, id) {
throw 'Unsupported operation';
},
/** @abstract */
createRelationship : function(fromNode, toNode) {
throw "Unsupported operation";
},
/** @abstract */
createRelationship(fromNode, toNode) {
throw 'Unsupported operation';
},
/** @abstract */
addRelationship : function(rel) {
throw "Unsupported operation";
},
/** @abstract */
addRelationship(rel) {
throw 'Unsupported operation';
},
/** @abstract */
deleteRelationship : function(relationship) {
throw "Unsupported operation";
},
/** @abstract */
deleteRelationship(relationship) {
throw 'Unsupported operation';
},
/** */
inspect : function() {
var result = '';
result = '{ ';
/** */
inspect() {
let result = '';
result = '{ ';
var branches = this.getBranches();
result = result + "version:" + this.getVersion();
result = result + " , [";
const branches = this.getBranches();
result = `${result}version:${this.getVersion()}`;
result = `${result} , [`;
for (var i = 0; i < branches.length; i++) {
var node = branches[i];
if (i != 0) {
result = result + ',\n ';
}
result = result + "(" + i + ") =>" + node.inspect();
}
result = result + "]";
for (let i = 0; i < branches.length; i++) {
const node = branches[i];
if (i != 0) {
result = `${result},\n `;
}
result = `${result}(${i}) =>${node.inspect()}`;
}
result = `${result}]`;
result = result + ' } ';
return result;
},
result = `${result} } `;
return result;
},
/**
/**
* @param target
*/
copyTo : function(target) {
var source = this;
var version = source.getVersion();
target.setVersion(version);
copyTo(target) {
const source = this;
const version = source.getVersion();
target.setVersion(version);
var desc = this.getDescription();
target.setDescription(desc);
const desc = this.getDescription();
target.setDescription(desc);
// Then the rest of the branches ...
var sbranchs = source.getBranches();
_.each(sbranchs, function(snode) {
var tnode = target.createNode(snode.getType(), snode.getId());
snode.copyTo(tnode);
target.addBranch(tnode);
});
}
// Then the rest of the branches ...
const sbranchs = source.getBranches();
_.each(sbranchs, (snode) => {
const tnode = target.createNode(snode.getType(), snode.getId());
snode.copyTo(tnode);
target.addBranch(tnode);
});
},
});
export default IMindmap
export default IMindmap;

577
packages/mindplot/lib/components/model/INodeModel.js
View File

@ -17,375 +17,374 @@
*/
const INodeModel = new Class(
/** @lends INodeModel */ {
/**
/** @lends INodeModel */ {
/**
* @constructs
* @param mindmap
*/
initialize: function (mindmap) {
$assert(mindmap && mindmap.getBranches, 'mindmap can not be null');
this._mindmap = mindmap;
},
initialize(mindmap) {
$assert(mindmap && mindmap.getBranches, 'mindmap can not be null');
this._mindmap = mindmap;
},
/** */
getId: function () {
return this.getProperty('id');
},
/** */
getId() {
return this.getProperty('id');
},
/** */
setId: function (id) {
if ($defined(id) && id > INodeModel._uuid) {
INodeModel._uuid = id;
}
if (!$defined(id)) {
id = INodeModel._nextUUID();
}
/** */
setId(id) {
if ($defined(id) && id > INodeModel._uuid) {
INodeModel._uuid = id;
}
if (!$defined(id)) {
id = INodeModel._nextUUID();
}
this.putProperty('id', id);
},
this.putProperty('id', id);
},
/** */
getType: function () {
return this.getProperty('type');
},
/** */
getType() {
return this.getProperty('type');
},
/** */
setType: function (type) {
this.putProperty('type', type);
},
/** */
setType(type) {
this.putProperty('type', type);
},
/** */
setText: function (text) {
this.putProperty('text', text);
},
/** */
setText(text) {
this.putProperty('text', text);
},
/** */
getText: function () {
return this.getProperty('text');
},
/** */
getText() {
return this.getProperty('text');
},
/** */
setPosition: function (x, y) {
$assert(!isNaN(parseInt(x)), 'x position is not valid:' + x);
$assert(!isNaN(parseInt(y)), 'y position is not valid:' + y);
this.putProperty('position', '{x:' + parseInt(x) + ',y:' + parseInt(y) + '}');
},
/** */
setPosition(x, y) {
$assert(!isNaN(parseInt(x)), `x position is not valid:${x}`);
$assert(!isNaN(parseInt(y)), `y position is not valid:${y}`);
this.putProperty('position', `{x:${parseInt(x)},y:${parseInt(y)}}`);
},
/** */
getPosition: function () {
var value = this.getProperty('position');
var result = null;
if (value != null) {
result = eval('(' + value + ')');
}
return result;
},
/** */
getPosition() {
const value = this.getProperty('position');
let result = null;
if (value != null) {
result = eval(`(${value})`);
}
return result;
},
/** */
setImageSize: function (width, height) {
this.putProperty('imageSize', '{width:' + width + ',height:' + height + '}');
},
/** */
setImageSize(width, height) {
this.putProperty('imageSize', `{width:${width},height:${height}}`);
},
/** */
getImageSize: function () {
var value = this.getProperty('imageSize');
var result = null;
if (value != null) {
result = eval('(' + value + ')');
}
return result;
},
/** */
getImageSize() {
const value = this.getProperty('imageSize');
let result = null;
if (value != null) {
result = eval(`(${value})`);
}
return result;
},
/** */
setImageUrl: function (url) {
this.putProperty('imageUrl', url);
},
/** */
setImageUrl(url) {
this.putProperty('imageUrl', url);
},
/** */
getMetadata: function () {
return this.getProperty('metadata');
},
/** */
getMetadata() {
return this.getProperty('metadata');
},
/** */
setMetadata: function (json) {
this.putProperty('metadata', json);
},
/** */
setMetadata(json) {
this.putProperty('metadata', json);
},
/** */
getImageUrl: function () {
return this.getProperty('imageUrl');
},
/** */
getImageUrl() {
return this.getProperty('imageUrl');
},
/** */
getMindmap: function () {
return this._mindmap;
},
/** */
getMindmap() {
return this._mindmap;
},
/**
/**
* lets the mindmap handle the disconnect node operation
* @see mindplot.model.IMindmap.disconnect
*/
disconnect: function () {
var mindmap = this.getMindmap();
mindmap.disconnect(this);
},
disconnect() {
const mindmap = this.getMindmap();
mindmap.disconnect(this);
},
/** */
getShapeType: function () {
return this.getProperty('shapeType');
},
/** */
getShapeType() {
return this.getProperty('shapeType');
},
/** */
setShapeType: function (type) {
this.putProperty('shapeType', type);
},
/** */
setShapeType(type) {
this.putProperty('shapeType', type);
},
/** */
setOrder: function (value) {
$assert(
(typeof value === 'number' && isFinite(value)) || value == null,
'Order must be null or a number'
);
this.putProperty('order', value);
},
/** */
setOrder(value) {
$assert(
(typeof value === 'number' && isFinite(value)) || value == null,
'Order must be null or a number',
);
this.putProperty('order', value);
},
/** */
getOrder: function () {
return this.getProperty('order');
},
/** */
getOrder() {
return this.getProperty('order');
},
/** */
setFontFamily: function (fontFamily) {
this.putProperty('fontFamily', fontFamily);
},
/** */
setFontFamily(fontFamily) {
this.putProperty('fontFamily', fontFamily);
},
/** */
getFontFamily: function () {
return this.getProperty('fontFamily');
},
/** */
getFontFamily() {
return this.getProperty('fontFamily');
},
/** */
setFontStyle: function (fontStyle) {
this.putProperty('fontStyle', fontStyle);
},
/** */
setFontStyle(fontStyle) {
this.putProperty('fontStyle', fontStyle);
},
/** */
getFontStyle: function () {
return this.getProperty('fontStyle');
},
/** */
getFontStyle() {
return this.getProperty('fontStyle');
},
/** */
setFontWeight: function (weight) {
this.putProperty('fontWeight', weight);
},
/** */
setFontWeight(weight) {
this.putProperty('fontWeight', weight);
},
/** */
getFontWeight: function () {
return this.getProperty('fontWeight');
},
/** */
getFontWeight() {
return this.getProperty('fontWeight');
},
/** */
setFontColor: function (color) {
this.putProperty('fontColor', color);
},
/** */
setFontColor(color) {
this.putProperty('fontColor', color);
},
/** */
getFontColor: function () {
return this.getProperty('fontColor');
},
/** */
getFontColor() {
return this.getProperty('fontColor');
},
/** */
setFontSize: function (size) {
this.putProperty('fontSize', size);
},
/** */
setFontSize(size) {
this.putProperty('fontSize', size);
},
/** */
getFontSize: function () {
return this.getProperty('fontSize');
},
/** */
getFontSize() {
return this.getProperty('fontSize');
},
/** */
getBorderColor: function () {
return this.getProperty('borderColor');
},
/** */
getBorderColor() {
return this.getProperty('borderColor');
},
/** */
setBorderColor: function (color) {
this.putProperty('borderColor', color);
},
/** */
setBorderColor(color) {
this.putProperty('borderColor', color);
},
/** */
getBackgroundColor: function () {
return this.getProperty('backgroundColor');
},
/** */
getBackgroundColor() {
return this.getProperty('backgroundColor');
},
/** */
setBackgroundColor: function (color) {
this.putProperty('backgroundColor', color);
},
/** */
setBackgroundColor(color) {
this.putProperty('backgroundColor', color);
},
/** */
areChildrenShrunken: function () {
var result = this.getProperty('shrunken');
return $defined(result) ? result : false;
},
/** */
areChildrenShrunken() {
const result = this.getProperty('shrunken');
return $defined(result) ? result : false;
},
/**
/**
* @return {Boolean} true if the children nodes are hidden by the shrink option
*/
setChildrenShrunken: function (value) {
this.putProperty('shrunken', value);
},
setChildrenShrunken(value) {
this.putProperty('shrunken', value);
},
/**
/**
* @return {Boolean} true
*/
isNodeModel: function () {
return true;
},
isNodeModel() {
return true;
},
/**
/**
* @return {Boolean} true if the node model has a parent assigned to it
*/
isConnected: function () {
return this.getParent() != null;
},
isConnected() {
return this.getParent() != null;
},
/** @abstract */
append: function (node) {
throw 'Unsupported operation';
},
/** @abstract */
append(node) {
throw 'Unsupported operation';
},
/**
/**
* lets the mindmap handle the connect node operation
* @throws will throw an error if parent is null or undefined
* @see mindplot.model.IMindmap.connect
*/
connectTo: function (parent) {
$assert(parent, 'parent can not be null');
var mindmap = this.getMindmap();
mindmap.connect(parent, this);
},
connectTo(parent) {
$assert(parent, 'parent can not be null');
const mindmap = this.getMindmap();
mindmap.connect(parent, this);
},
/**
/**
* @param target
* @return target
*/
copyTo: function (target) {
var source = this;
// Copy properties ...
var keys = source.getPropertiesKeys();
_.each(keys, function (key) {
var value = source.getProperty(key);
target.putProperty(key, value);
});
copyTo(target) {
const source = this;
// Copy properties ...
const keys = source.getPropertiesKeys();
_.each(keys, (key) => {
const value = source.getProperty(key);
target.putProperty(key, value);
});
// Copy children ...
var children = this.getChildren();
var tmindmap = target.getMindmap();
// Copy children ...
const children = this.getChildren();
const tmindmap = target.getMindmap();
_.each(function (children, snode) {
var tnode = tmindmap.createNode(snode.getType(), snode.getId());
snode.copyTo(tnode);
target.append(tnode);
});
_.each((children, snode) => {
const tnode = tmindmap.createNode(snode.getType(), snode.getId());
snode.copyTo(tnode);
target.append(tnode);
});
return target;
},
return target;
},
/**
/**
* lets parent handle the delete node operation, or, if none defined, calls the mindmap to
* remove the respective branch
*/
deleteNode: function () {
var mindmap = this.getMindmap();
deleteNode() {
const mindmap = this.getMindmap();
// console.log("Before:" + mindmap.inspect());
var parent = this.getParent();
if ($defined(parent)) {
parent.removeChild(this);
} else {
// If it has not parent, it must be an isolate topic ...
mindmap.removeBranch(this);
}
// It's an isolated node. It must be a hole branch ...
// console.log("After:" + mindmap.inspect());
},
// console.log("Before:" + mindmap.inspect());
const parent = this.getParent();
if ($defined(parent)) {
parent.removeChild(this);
} else {
// If it has not parent, it must be an isolate topic ...
mindmap.removeBranch(this);
}
// It's an isolated node. It must be a hole branch ...
// console.log("After:" + mindmap.inspect());
},
/** @abstract */
getPropertiesKeys: function () {
throw 'Unsupported operation';
},
/** @abstract */
getPropertiesKeys() {
throw 'Unsupported operation';
},
/** @abstract */
putProperty: function (key, value) {
throw 'Unsupported operation';
},
/** @abstract */
putProperty(key, value) {
throw 'Unsupported operation';
},
/** @abstract */
setParent: function (parent) {
throw 'Unsupported operation';
},
/** @abstract */
setParent(parent) {
throw 'Unsupported operation';
},
/** @abstract */
getChildren: function () {
throw 'Unsupported operation';
},
/** @abstract */
getChildren() {
throw 'Unsupported operation';
},
/** @abstract */
getParent: function () {
throw 'Unsupported operation';
},
/** @abstract */
getParent() {
throw 'Unsupported operation';
},
/** @abstract */
clone: function () {
throw 'Unsupported operation';
},
/** @abstract */
clone() {
throw 'Unsupported operation';
},
/** */
inspect: function () {
var result =
'{ type: ' +
this.getType() +
' , id: ' +
this.getId() +
' , text: ' +
this.getText();
/** */
inspect() {
let result = `{ type: ${
this.getType()
} , id: ${
this.getId()
} , text: ${
this.getText()}`;
var children = this.getChildren();
if (children.length > 0) {
result = result + ', children: {(size:' + children.length;
_.each(children, function (node) {
result = result + '=> (';
var keys = node.getPropertiesKeys();
_.each(keys, function (key) {
var value = node.getProperty(key);
result = result + key + ':' + value + ',';
});
result = result + '}';
});
}
const children = this.getChildren();
if (children.length > 0) {
result = `${result}, children: {(size:${children.length}`;
_.each(children, (node) => {
result = `${result}=> (`;
const keys = node.getPropertiesKeys();
_.each(keys, (key) => {
const value = node.getProperty(key);
result = `${result + key}:${value},`;
});
result = `${result}}`;
});
}
result = result + ' }';
return result;
},
result = `${result} }`;
return result;
},
/** @abstract */
removeChild: function (child) {
throw 'Unsupported operation';
},
}
/** @abstract */
removeChild(child) {
throw 'Unsupported operation';
},
},
);
/**
* @enum {String}
*/
const TopicShape = {
RECTANGLE: 'rectagle',
ROUNDED_RECT: 'rounded rectagle',
ELLIPSE: 'elipse',
LINE: 'line',
IMAGE: 'image',
RECTANGLE: 'rectagle',
ROUNDED_RECT: 'rounded rectagle',
ELLIPSE: 'elipse',
LINE: 'line',
IMAGE: 'image',
};
/**
@ -412,12 +411,12 @@ INodeModel.MAIN_TOPIC_TO_MAIN_TOPIC_DISTANCE = 220;
* @todo: This method must be implemented. (unascribed)
*/
INodeModel._nextUUID = function () {
if (!$defined(INodeModel._uuid)) {
INodeModel._uuid = 0;
}
if (!$defined(INodeModel._uuid)) {
INodeModel._uuid = 0;
}
INodeModel._uuid = INodeModel._uuid + 1;
return INodeModel._uuid;
INodeModel._uuid += 1;
return INodeModel._uuid;
};
INodeModel._uuid = 0;

34
packages/mindplot/lib/components/model/IconModel.js
View File

@ -15,30 +15,30 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const FeatureModel = require('./FeatureModel').default
const FeatureModel = require('./FeatureModel').default;
const IconModel = new Class(/** @lends IconModel */{
Extends: FeatureModel,
/**
Extends: FeatureModel,
/**
* @constructs
* @param attributes
* @extends mindplot.model.FeatureModel
*/
initialize:function (attributes) {
this.parent(IconModel.FEATURE_TYPE);
this.setIconType(attributes.id);
},
initialize(attributes) {
this.parent(IconModel.FEATURE_TYPE);
this.setIconType(attributes.id);
},
/** @return the icon type id */
getIconType:function () {
return this.getAttribute('id');
},
/** @return the icon type id */
getIconType() {
return this.getAttribute('id');
},
/** @param {String} iconType the icon type id*/
setIconType:function (iconType) {
$assert(iconType, 'iconType id can not be null');
this.setAttribute('id', iconType);
}
/** @param {String} iconType the icon type id */
setIconType(iconType) {
$assert(iconType, 'iconType id can not be null');
this.setAttribute('id', iconType);
},
});
/**
@ -46,6 +46,6 @@ const IconModel = new Class(/** @lends IconModel */{
* @type {String}
* @default
*/
IconModel.FEATURE_TYPE = "icon";
IconModel.FEATURE_TYPE = 'icon';
export default IconModel;

69
packages/mindplot/lib/components/model/LinkModel.js
View File

@ -18,54 +18,53 @@
const FeatureModel = require('./FeatureModel').default;
const LinkModel = new Class(/** @lends LinkModel */{
Extends:FeatureModel,
/**
Extends: FeatureModel,
/**
* @constructs
* @param attributes
* @extends mindplot.model.FeatureModel
*/
initialize:function (attributes) {
this.parent(LinkModel.FEATURE_TYPE);
this.setUrl(attributes.url);
},
initialize(attributes) {
this.parent(LinkModel.FEATURE_TYPE);
this.setUrl(attributes.url);
},
/** @return {String} the url attribute value */
getUrl:function () {
return this.getAttribute('url');
},
/** @return {String} the url attribute value */
getUrl() {
return this.getAttribute('url');
},
/**
/**
* @param {String} url a URL provided by the user to set the link to
* @throws will throw an error if url is null or undefined
*/
setUrl:function (url) {
$assert(url, 'url can not be null');
setUrl(url) {
$assert(url, 'url can not be null');
var fixedUrl = this._fixUrl(url);
this.setAttribute('url', fixedUrl);
const fixedUrl = this._fixUrl(url);
this.setAttribute('url', fixedUrl);
var type = fixedUrl.contains('mailto:') ? 'mail' : 'url';
this.setAttribute('urlType', type);
const type = fixedUrl.contains('mailto:') ? 'mail' : 'url';
this.setAttribute('urlType', type);
},
},
//url format is already checked in LinkEditor.checkUrl
_fixUrl:function (url) {
var result = url;
if (!result.contains('http://') && !result.contains('https://') && !result.contains('mailto://')) {
result = "http://" + result;
}
return result;
},
/**
* @param {String} urlType the url type, either 'mail' or 'url'
* @throws will throw an error if urlType is null or undefined
*/
setUrlType:function (urlType) {
$assert(urlType, 'urlType can not be null');
this.setAttribute('urlType', urlType);
// url format is already checked in LinkEditor.checkUrl
_fixUrl(url) {
let result = url;
if (!result.contains('http://') && !result.contains('https://') && !result.contains('mailto://')) {
result = `http://${result}`;
}
return result;
},
/**
* @param {String} urlType the url type, either 'mail' or 'url'
* @throws will throw an error if urlType is null or undefined
*/
setUrlType(urlType) {
$assert(urlType, 'urlType can not be null');
this.setAttribute('urlType', urlType);
},
});
/**

217
packages/mindplot/lib/components/model/Mindmap.js
View File

@ -19,173 +19,172 @@ const IMindmap = require('./IMindmap').default;
const INodeModel = require('./INodeModel').default;
const NodeModel = require('./NodeModel').default;
const RelationshipModel = require('./RelationshipModel').default;
const ModelCodeName = require('../persistence/ModelCodeName').default
const ModelCodeName = require('../persistence/ModelCodeName').default;
const Mindmap = new Class(/** @lends Mindmap */{
Extends:IMindmap,
/**
Extends: IMindmap,
/**
* @constructs
* @param id
* @param version
* @extends mindplot.model.IMindmap
*/
initialize:function (id, version) {
$assert(id, "Id can not be null");
this._branches = [];
this._description = null;
this._relationships = [];
this._version = $defined(version) ? version : ModelCodeName.TANGO;
this._id = id;
},
initialize(id, version) {
$assert(id, 'Id can not be null');
this._branches = [];
this._description = null;
this._relationships = [];
this._version = $defined(version) ? version : ModelCodeName.TANGO;
this._id = id;
},
/** */
getDescription:function () {
return this._description;
},
/** */
getDescription() {
return this._description;
},
/** */
setDescription:function (value) {
this._description = value;
},
/** */
setDescription(value) {
this._description = value;
},
/** */
getId:function () {
return this._id;
},
/** */
getId() {
return this._id;
},
/** */
setId:function (id) {
this._id = id;
},
/** */
setId(id) {
this._id = id;
},
/** */
getVersion:function () {
return this._version;
},
/** */
getVersion() {
return this._version;
},
/** */
setVersion:function (version) {
this._version = version;
},
/** */
setVersion(version) {
this._version = version;
},
/**
/**
* @param {mindplot.model.NodeModel} nodeModel
* @throws will throw an error if nodeModel is null, undefined or not a node model object
* @throws will throw an error if
* @throws will throw an error if
*/
addBranch:function (nodeModel) {
$assert(nodeModel && nodeModel.isNodeModel(), 'Add node must be invoked with model objects');
var branches = this.getBranches();
if (branches.length == 0) {
$assert(nodeModel.getType() == INodeModel.CENTRAL_TOPIC_TYPE, "First element must be the central topic");
nodeModel.setPosition(0, 0);
} else {
$assert(nodeModel.getType() != INodeModel.CENTRAL_TOPIC_TYPE, "Mindmaps only have one cental topic");
}
addBranch(nodeModel) {
$assert(nodeModel && nodeModel.isNodeModel(), 'Add node must be invoked with model objects');
const branches = this.getBranches();
if (branches.length == 0) {
$assert(nodeModel.getType() == INodeModel.CENTRAL_TOPIC_TYPE, 'First element must be the central topic');
nodeModel.setPosition(0, 0);
} else {
$assert(nodeModel.getType() != INodeModel.CENTRAL_TOPIC_TYPE, 'Mindmaps only have one cental topic');
}
this._branches.push(nodeModel);
},
this._branches.push(nodeModel);
},
/**
/**
* @param nodeModel
*/
removeBranch:function (nodeModel) {
$assert(nodeModel && nodeModel.isNodeModel(), 'Remove node must be invoked with model objects');
return this._branches.erase(nodeModel);
},
removeBranch(nodeModel) {
$assert(nodeModel && nodeModel.isNodeModel(), 'Remove node must be invoked with model objects');
return this._branches.erase(nodeModel);
},
/** */
getBranches:function () {
return this._branches;
},
/** */
getBranches() {
return this._branches;
},
/** */
getRelationships:function () {
return this._relationships;
},
/** */
getRelationships() {
return this._relationships;
},
/**
/**
* @param node
* @return {Boolean} true if node already exists
*/
hasAlreadyAdded:function (node) {
var result = false;
hasAlreadyAdded(node) {
let result = false;
// Check in not connected nodes.
var branches = this._branches;
for (var i = 0; i < branches.length; i++) {
result = branches[i]._isChildNode(node);
if (result) {
break;
}
}
},
// Check in not connected nodes.
const branches = this._branches;
for (let i = 0; i < branches.length; i++) {
result = branches[i]._isChildNode(node);
if (result) {
break;
}
}
},
/**
/**
* @param type
* @param id
* @return the node model created
*/
createNode:function (type, id) {
type = !$defined(type) ? INodeModel.MAIN_TOPIC_TYPE : type;
return new NodeModel(type, this, id);
},
createNode(type, id) {
type = !$defined(type) ? INodeModel.MAIN_TOPIC_TYPE : type;
return new NodeModel(type, this, id);
},
/**
/**
* @param sourceNodeId
* @param targetNodeId
* @throws will throw an error if source node is null or undefined
* @throws will throw an error if target node is null or undefined
* @return the relationship model created
*/
createRelationship:function (sourceNodeId, targetNodeId) {
$assert($defined(sourceNodeId), 'from node cannot be null');
$assert($defined(targetNodeId), 'to node cannot be null');
createRelationship(sourceNodeId, targetNodeId) {
$assert($defined(sourceNodeId), 'from node cannot be null');
$assert($defined(targetNodeId), 'to node cannot be null');
return new RelationshipModel(sourceNodeId, targetNodeId);
},
return new RelationshipModel(sourceNodeId, targetNodeId);
},
/**
/**
* @param relationship
*/
addRelationship:function (relationship) {
this._relationships.push(relationship);
},
addRelationship(relationship) {
this._relationships.push(relationship);
},
/**
/**
* @param relationship
*/
deleteRelationship:function (relationship) {
this._relationships.erase(relationship);
},
deleteRelationship(relationship) {
this._relationships.erase(relationship);
},
/**
/**
* @param id
* @return the node with the respective id or null if not in the mindmap
*/
findNodeById:function (id) {
var result = null;
for (var i = 0; i < this._branches.length; i++) {
var branch = this._branches[i];
result = branch.findNodeById(id);
if (result) {
break;
}
}
return result;
}
findNodeById(id) {
let result = null;
for (let i = 0; i < this._branches.length; i++) {
const branch = this._branches[i];
result = branch.findNodeById(id);
if (result) {
break;
}
}
);
return result;
},
});
/**
* @param mapId
* @return an empty mindmap with central topic only
*/
Mindmap.buildEmpty = function (mapId) {
var result = new Mindmap(mapId);
var node = result.createNode(INodeModel.CENTRAL_TOPIC_TYPE, 0);
result.addBranch(node);
return result;
const result = new Mindmap(mapId);
const node = result.createNode(INodeModel.CENTRAL_TOPIC_TYPE, 0);
result.addBranch(node);
return result;
};
export default Mindmap;

311
packages/mindplot/lib/components/model/NodeModel.js
View File

@ -15,231 +15,224 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const INodeModel = require('./INodeModel').default
const TopicFeature = require('../TopicFeature').default
const INodeModel = require('./INodeModel').default;
const TopicFeature = require('../TopicFeature').default;
const NodeModel = new Class(/** @lends NodeModel */{
Extends:INodeModel,
/**
Extends: INodeModel,
/**
* @constructs
* @param {String} type node type
* @param mindmap
* @param id
*/
initialize:function (type, mindmap, id) {
$assert(type, 'Node type can not be null');
$assert(mindmap, 'mindmap can not be null');
this._properties = {};
initialize(type, mindmap, id) {
$assert(type, 'Node type can not be null');
$assert(mindmap, 'mindmap can not be null');
this._properties = {};
this.parent(mindmap);
this.setId(id);
this.setType(type);
this.areChildrenShrunken(false);
this.parent(mindmap);
this.setId(id);
this.setType(type);
this.areChildrenShrunken(false);
this._children = [];
this._feature = [];
},
this._children = [];
this._feature = [];
},
/**
/**
* @param type
* @param attributes
* @return {mindplot.model.FeatureModel} the created feature model
*/
createFeature:function (type, attributes) {
return TopicFeature.createModel(type, attributes);
},
createFeature(type, attributes) {
return TopicFeature.createModel(type, attributes);
},
/**
/**
* @param feature
* @throws will throw an error if feature is null or undefined
*/
addFeature:function (feature) {
$assert(feature, 'feature can not be null');
this._feature.push(feature);
},
addFeature(feature) {
$assert(feature, 'feature can not be null');
this._feature.push(feature);
},
/** */
getFeatures:function () {
return this._feature;
},
/** */
getFeatures() {
return this._feature;
},
/**
/**
* @param feature
* @throws will throw an error if feature is null or undefined
* @throws will throw an error if the feature could not be removed
*/
removeFeature:function (feature) {
$assert(feature, 'feature can not be null');
var size = this._feature.length;
this._feature = this._feature.filter(function (f) {
return feature.getId() != f.getId();
});
$assert(size - 1 == this._feature.length, 'Could not be removed ...');
removeFeature(feature) {
$assert(feature, 'feature can not be null');
const size = this._feature.length;
this._feature = this._feature.filter((f) => feature.getId() != f.getId());
$assert(size - 1 == this._feature.length, 'Could not be removed ...');
},
},
/**
/**
* @param {String} type the feature type, e.g. icon or link
* @throws will throw an error if type is null or undefined
*/
findFeatureByType:function (type) {
$assert(type, 'type can not be null');
return this._feature.filter(function (feature) {
return feature.getType() == type;
});
},
findFeatureByType(type) {
$assert(type, 'type can not be null');
return this._feature.filter((feature) => feature.getType() == type);
},
/**
/**
* @param {String} id
* @throws will throw an error if id is null or undefined
* @throws will throw an error if feature could not be found
* @return the feature with the given id
*/
findFeatureById:function (id) {
$assert($defined(id), 'id can not be null');
var result = this._feature.filter(function (feature) {
return feature.getId() == id;
});
$assert(result.length == 1, "Feature could not be found:" + id);
return result[0];
},
findFeatureById(id) {
$assert($defined(id), 'id can not be null');
const result = this._feature.filter((feature) => feature.getId() == id);
$assert(result.length == 1, `Feature could not be found:${id}`);
return result[0];
},
/** */
getPropertiesKeys:function () {
return Object.keys(this._properties);
},
/** */
getPropertiesKeys() {
return Object.keys(this._properties);
},
/**
/**
* @param key
* @param value
* @throws will throw an error if key is null or undefined
*/
putProperty:function (key, value) {
$defined(key, 'key can not be null');
this._properties[key] = value;
},
putProperty(key, value) {
$defined(key, 'key can not be null');
this._properties[key] = value;
},
/** */
getProperties:function () {
return this._properties;
},
/** */
getProperties() {
return this._properties;
},
/** */
getProperty:function (key) {
$defined(key, 'key can not be null');
var result = this._properties[key];
return !$defined(result) ? null : result;
},
/** */
getProperty(key) {
$defined(key, 'key can not be null');
const result = this._properties[key];
return !$defined(result) ? null : result;
},
/**
/**
* @return {mindplot.model.NodeModel} an identical clone of the NodeModel
*/
clone:function () {
var result = new NodeModel(this.getType(), this._mindmap);
result._children = this._children.map(function (node) {
var cnode = node.clone();
cnode._parent = result;
return cnode;
});
clone() {
const result = new NodeModel(this.getType(), this._mindmap);
result._children = this._children.map((node) => {
const cnode = node.clone();
cnode._parent = result;
return cnode;
});
result._properties = Object.clone(this._properties);
result._feature = this._feature.clone();
return result;
},
result._properties = Object.clone(this._properties);
result._feature = this._feature.clone();
return result;
},
/**
/**
* Similar to clone, assign new id to the elements ...
* @return {mindplot.model.NodeModel}
*/
deepCopy:function () {
var result = new NodeModel(this.getType(), this._mindmap);
result._children = this._children.map(function (node) {
var cnode = node.deepCopy();
cnode._parent = result;
return cnode;
});
deepCopy() {
const result = new NodeModel(this.getType(), this._mindmap);
result._children = this._children.map((node) => {
const cnode = node.deepCopy();
cnode._parent = result;
return cnode;
});
var id = result.getId();
result._properties = Object.clone(this._properties);
result.setId(id);
const id = result.getId();
result._properties = Object.clone(this._properties);
result.setId(id);
result._feature = this._feature.clone();
return result;
},
result._feature = this._feature.clone();
return result;
},
/**
* @param {mindplot.model.NodeModel} child
* @throws will throw an error if child is null, undefined or not a NodeModel object
*/
append:function (child) {
$assert(child && child.isNodeModel(), 'Only NodeModel can be appended to Mindmap object');
this._children.push(child);
child._parent = this;
},
/**
/**
* @param {mindplot.model.NodeModel} child
* @throws will throw an error if child is null, undefined or not a NodeModel object
*/
removeChild:function (child) {
$assert(child && child.isNodeModel(), 'Only NodeModel can be appended to Mindmap object.');
this._children.erase(child);
child._parent = null;
},
append(child) {
$assert(child && child.isNodeModel(), 'Only NodeModel can be appended to Mindmap object');
this._children.push(child);
child._parent = this;
},
/** */
getChildren:function () {
return this._children;
},
/**
* @param {mindplot.model.NodeModel} child
* @throws will throw an error if child is null, undefined or not a NodeModel object
*/
removeChild(child) {
$assert(child && child.isNodeModel(), 'Only NodeModel can be appended to Mindmap object.');
this._children.erase(child);
child._parent = null;
},
/** */
getParent:function () {
return this._parent;
},
/** */
getChildren() {
return this._children;
},
/** */
setParent:function (parent) {
$assert(parent != this, 'The same node can not be parent and child if itself.');
this._parent = parent;
},
/** */
getParent() {
return this._parent;
},
_isChildNode:function (node) {
var result = false;
if (node == this) {
result = true;
} else {
var children = this.getChildren();
for (var i = 0; i < children.length; i++) {
var child = children[i];
result = child._isChildNode(node);
if (result) {
break;
}
}
/** */
setParent(parent) {
$assert(parent != this, 'The same node can not be parent and child if itself.');
this._parent = parent;
},
_isChildNode(node) {
let result = false;
if (node == this) {
result = true;
} else {
const children = this.getChildren();
for (let i = 0; i < children.length; i++) {
const child = children[i];
result = child._isChildNode(node);
if (result) {
break;
}
return result;
},
}
}
return result;
},
/**
/**
* @id
* @return {mindplot.model.NodeModel} the node with the respective id
*/
findNodeById:function (id) {
var result = null;
if (this.getId() == id) {
result = this;
} else {
var children = this.getChildren();
for (var i = 0; i < children.length; i++) {
var child = children[i];
result = child.findNodeById(id);
if (result) {
break;
}
}
findNodeById(id) {
let result = null;
if (this.getId() == id) {
result = this;
} else {
const children = this.getChildren();
for (let i = 0; i < children.length; i++) {
const child = children[i];
result = child.findNodeById(id);
if (result) {
break;
}
return result;
}
}
return result;
},
});
export default NodeModel
export default NodeModel;

36
packages/mindplot/lib/components/model/NoteModel.js
View File

@ -15,31 +15,31 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const FeatureModel = require('./FeatureModel').default
const FeatureModel = require('./FeatureModel').default;
const NoteModel = new Class(/** @lends NoteModel */{
Extends:FeatureModel,
/**
Extends: FeatureModel,
/**
* @constructs
* @param attributes
* @extends mindplot.model.FeatureModel
*/
initialize:function (attributes) {
this.parent(NoteModel.FEATURE_TYPE);
var noteText = attributes.text ? attributes.text : " ";
this.setText(noteText);
},
initialize(attributes) {
this.parent(NoteModel.FEATURE_TYPE);
const noteText = attributes.text ? attributes.text : ' ';
this.setText(noteText);
},
/** */
getText:function () {
return this.getAttribute('text');
},
/** */
getText() {
return this.getAttribute('text');
},
/** */
setText:function (text) {
$assert(text, 'text can not be null');
this.setAttribute('text', text);
}
/** */
setText(text) {
$assert(text, 'text can not be null');
this.setAttribute('text', text);
},
});
/**
@ -47,6 +47,6 @@ const NoteModel = new Class(/** @lends NoteModel */{
* @type {String}
* @default
*/
NoteModel.FEATURE_TYPE = "note";
NoteModel.FEATURE_TYPE = 'note';
export default NoteModel;

196
packages/mindplot/lib/components/model/RelationshipModel.js
View File

@ -18,131 +18,131 @@
const ConnectionLine = require('../ConnectionLine').default;
const RelationshipModel = new Class(
/** @lends RelationshipModel */ {
Static: {
_nextUUID: function () {
if (!$defined(RelationshipModel._uuid)) {
RelationshipModel._uuid = 0;
}
RelationshipModel._uuid = RelationshipModel._uuid + 1;
return RelationshipModel._uuid;
},
},
/** @lends RelationshipModel */ {
Static: {
_nextUUID() {
if (!$defined(RelationshipModel._uuid)) {
RelationshipModel._uuid = 0;
}
RelationshipModel._uuid += 1;
return RelationshipModel._uuid;
},
},
/**
/**
* @constructs
* @param sourceTopicId
* @param targetTopicId
* @throws will throw an error if sourceTopicId is null or undefined
* @throws will throw an error if targetTopicId is null or undefined
*/
initialize: function (sourceTopicId, targetTopicId) {
$assert($defined(sourceTopicId), 'from node type can not be null');
$assert($defined(targetTopicId), 'to node type can not be null');
initialize(sourceTopicId, targetTopicId) {
$assert($defined(sourceTopicId), 'from node type can not be null');
$assert($defined(targetTopicId), 'to node type can not be null');
this._id = RelationshipModel._nextUUID();
this._sourceTargetId = sourceTopicId;
this._targetTopicId = targetTopicId;
this._lineType = ConnectionLine.SIMPLE_CURVED;
this._srcCtrlPoint = null;
this._destCtrlPoint = null;
this._endArrow = true;
this._startArrow = false;
},
this._id = RelationshipModel._nextUUID();
this._sourceTargetId = sourceTopicId;
this._targetTopicId = targetTopicId;
this._lineType = ConnectionLine.SIMPLE_CURVED;
this._srcCtrlPoint = null;
this._destCtrlPoint = null;
this._endArrow = true;
this._startArrow = false;
},
/** */
getFromNode: function () {
return this._sourceTargetId;
},
/** */
getFromNode() {
return this._sourceTargetId;
},
/** */
getToNode: function () {
return this._targetTopicId;
},
/** */
getToNode() {
return this._targetTopicId;
},
/** */
getId: function () {
$assert(this._id, 'id is null');
return this._id;
},
/** */
getId() {
$assert(this._id, 'id is null');
return this._id;
},
/** */
getLineType: function () {
return this._lineType;
},
/** */
getLineType() {
return this._lineType;
},
/** */
setLineType: function (lineType) {
this._lineType = lineType;
},
/** */
setLineType(lineType) {
this._lineType = lineType;
},
/** */
getSrcCtrlPoint: function () {
return this._srcCtrlPoint;
},
/** */
getSrcCtrlPoint() {
return this._srcCtrlPoint;
},
/** */
setSrcCtrlPoint: function (srcCtrlPoint) {
this._srcCtrlPoint = srcCtrlPoint;
},
/** */
setSrcCtrlPoint(srcCtrlPoint) {
this._srcCtrlPoint = srcCtrlPoint;
},
/** */
getDestCtrlPoint: function () {
return this._destCtrlPoint;
},
/** */
getDestCtrlPoint() {
return this._destCtrlPoint;
},
/** */
setDestCtrlPoint: function (destCtrlPoint) {
this._destCtrlPoint = destCtrlPoint;
},
/** */
setDestCtrlPoint(destCtrlPoint) {
this._destCtrlPoint = destCtrlPoint;
},
/** */
getEndArrow: function () {
return this._endArrow;
},
/** */
getEndArrow() {
return this._endArrow;
},
/** */
setEndArrow: function (endArrow) {
this._endArrow = endArrow;
},
/** */
setEndArrow(endArrow) {
this._endArrow = endArrow;
},
/** */
getStartArrow: function () {
return this._startArrow;
},
/** */
getStartArrow() {
return this._startArrow;
},
/** */
setStartArrow: function (startArrow) {
this._startArrow = startArrow;
},
/** */
setStartArrow(startArrow) {
this._startArrow = startArrow;
},
/**
/**
* @return a clone of the relationship model
*/
clone: function () {
var result = new RelationshipModel(this._sourceTargetId, this._targetTopicId);
result._id = this._id;
result._lineType = this._lineType;
result._srcCtrlPoint = this._srcCtrlPoint;
result._destCtrlPoint = this._destCtrlPoint;
result._endArrow = this._endArrow;
result._startArrow = this._startArrow;
return result;
},
clone() {
const result = new RelationshipModel(this._sourceTargetId, this._targetTopicId);
result._id = this._id;
result._lineType = this._lineType;
result._srcCtrlPoint = this._srcCtrlPoint;
result._destCtrlPoint = this._destCtrlPoint;
result._endArrow = this._endArrow;
result._startArrow = this._startArrow;
return result;
},
/**
/**
* @return {String} textual information about the relationship's source and target node
*/
inspect: function () {
return (
'(fromNode:' +
this.getFromNode().getId() +
' , toNode: ' +
this.getToNode().getId() +
')'
);
},
}
inspect() {
return (
`(fromNode:${
this.getFromNode().getId()
} , toNode: ${
this.getToNode().getId()
})`
);
},
},
);
export default RelationshipModel;

18
packages/mindplot/lib/components/model/index.js
View File

@ -9,13 +9,13 @@ const nodeModel = require('./NodeModel').default;
const relationshipModel = require('./RelationshipModel').default;
export const Model = {
FeatureModel: featureModel,
IconModel: iconModel,
IMindmap: iMindmap,
INodeModel: iNodeModel,
LinkModel: linkModel,
NoteModel: noteModel,
Mindmap: mindmap,
NodeModel: nodeModel,
RelationshipModel: relationshipModel,
FeatureModel: featureModel,
IconModel: iconModel,
IMindmap: iMindmap,
INodeModel: iNodeModel,
LinkModel: linkModel,
NoteModel: noteModel,
Mindmap: mindmap,
NodeModel: nodeModel,
RelationshipModel: relationshipModel,
};

62
packages/mindplot/lib/components/persistence/Beta2PelaMigrator.js
View File

@ -15,45 +15,45 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const ModelCodeName = require('./ModelCodeName').default
const ModelCodeName = require('./ModelCodeName').default;
const XMLSerializer_Pela = require('./XMLSerializer_Pela').default;
const Beta2PelaMigrator = new Class({
initialize:function (betaSerializer) {
this._betaSerializer = betaSerializer;
this._pelaSerializer = new XMLSerializer_Pela();
},
initialize(betaSerializer) {
this._betaSerializer = betaSerializer;
this._pelaSerializer = new XMLSerializer_Pela();
},
toXML:function (mindmap) {
return this._pelaSerializer.toXML(mindmap);
},
toXML(mindmap) {
return this._pelaSerializer.toXML(mindmap);
},
loadFromDom:function (dom, mapId) {
$assert($defined(mapId), "mapId can not be null");
var mindmap = this._betaSerializer.loadFromDom(dom, mapId);
mindmap.setVersion(ModelCodeName.PELA);
loadFromDom(dom, mapId) {
$assert($defined(mapId), 'mapId can not be null');
const mindmap = this._betaSerializer.loadFromDom(dom, mapId);
mindmap.setVersion(ModelCodeName.PELA);
// Beta does not set position on second level nodes ...
var branches = mindmap.getBranches();
var me = this;
_.each(branches, function (model) {
me._fixPosition(model);
});
// Beta does not set position on second level nodes ...
const branches = mindmap.getBranches();
const me = this;
_.each(branches, (model) => {
me._fixPosition(model);
});
return mindmap;
},
return mindmap;
},
_fixPosition:function (parentModel) {
var parentPos = parentModel.getPosition();
var isRight = parentPos.x > 0;
var me = this;
_.each(parentModel.getChildren(), function (child) {
if (!child.getPosition()) {
child.setPosition(parentPos.x + (50 * isRight ? 1 : -1), parentPos.y);
}
me._fixPosition(child);
});
}
_fixPosition(parentModel) {
const parentPos = parentModel.getPosition();
const isRight = parentPos.x > 0;
const me = this;
_.each(parentModel.getChildren(), (child) => {
if (!child.getPosition()) {
child.setPosition(parentPos.x + (50 * isRight ? 1 : -1), parentPos.y);
}
me._fixPosition(child);
});
},
});
export default Beta2PelaMigrator;

8
packages/mindplot/lib/components/persistence/ModelCodeName.js
View File

@ -21,9 +21,9 @@
* @enum {String}
*/
const ModelCodeName = {
BETA : "beta",
PELA : "pela",
TANGO : "tango"
BETA: 'beta',
PELA: 'pela',
TANGO: 'tango',
};
export default ModelCodeName
export default ModelCodeName;

137
packages/mindplot/lib/components/persistence/Pela2TangoMigrator.js
View File

@ -15,85 +15,78 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const XMLSerializer_Tango = require('./XMLSerializer_Tango').default
const XMLSerializer_Tango = require('./XMLSerializer_Tango').default;
const ModelCodeName = require('./ModelCodeName').default;
const Pela2TangoMigrator = new Class({
initialize : function(pelaSerializer) {
this._pelaSerializer = pelaSerializer;
this._tangoSerializer = new XMLSerializer_Tango();
},
initialize(pelaSerializer) {
this._pelaSerializer = pelaSerializer;
this._tangoSerializer = new XMLSerializer_Tango();
},
toXML : function(mindmap) {
return this._tangoSerializer.toXML(mindmap);
},
toXML(mindmap) {
return this._tangoSerializer.toXML(mindmap);
},
loadFromDom : function(dom, mapId) {
$assert($defined(mapId), "mapId can not be null");
var mindmap = this._pelaSerializer.loadFromDom(dom, mapId);
mindmap.setVersion(ModelCodeName.TANGO);
this._fixOrder(mindmap);
this._fixPosition(mindmap);
return mindmap;
},
_fixOrder : function(mindmap) {
// First level node policies has been changed.
var centralNode = mindmap.getBranches()[0];
var children = centralNode.getChildren();
var leftNodes = [];
var rightNodes = [];
for (var i = 0; i < children.length; i++) {
var child = children[i];
var position = child.getPosition();
if (position.x < 0) {
leftNodes.push(child);
} else {
rightNodes.push(child);
}
}
rightNodes.sort(function(a, b) {
return a.getOrder() > b.getOrder()
});
leftNodes.sort(function(a, b) {
return a.getOrder() > b.getOrder();
});
for (i = 0; i < rightNodes.length; i++) {
rightNodes[i].setOrder(i * 2);
}
for (i = 0; i < leftNodes.length; i++) {
leftNodes[i].setOrder(i * 2 + 1);
}
},
_fixPosition : function(mindmap) {
// Position was not required in previous versions. Try to synthesize one .
var centralNode = mindmap.getBranches()[0];
var children = centralNode.getChildren();
for (var i = 0; i < children.length; i++) {
var child = children[i];
var position = child.getPosition();
this._fixNodePosition(child, position)
}
},
_fixNodePosition : function(node, parentPosition) {
// Position was not required in previous versions. Try to synthesize one .
var position = node.getPosition();
if (!position) {
position = {x:parentPosition.x + 30,y:parentPosition.y};
node.setPosition(position.x, position.y);
}
var children = node.getChildren();
for (var i = 0; i < children.length; i++) {
var child = children[i];
this._fixNodePosition(child, position);
}
loadFromDom(dom, mapId) {
$assert($defined(mapId), 'mapId can not be null');
const mindmap = this._pelaSerializer.loadFromDom(dom, mapId);
mindmap.setVersion(ModelCodeName.TANGO);
this._fixOrder(mindmap);
this._fixPosition(mindmap);
return mindmap;
},
_fixOrder(mindmap) {
// First level node policies has been changed.
const centralNode = mindmap.getBranches()[0];
const children = centralNode.getChildren();
const leftNodes = [];
const rightNodes = [];
for (var i = 0; i < children.length; i++) {
const child = children[i];
const position = child.getPosition();
if (position.x < 0) {
leftNodes.push(child);
} else {
rightNodes.push(child);
}
}
rightNodes.sort((a, b) => a.getOrder() > b.getOrder());
leftNodes.sort((a, b) => a.getOrder() > b.getOrder());
for (i = 0; i < rightNodes.length; i++) {
rightNodes[i].setOrder(i * 2);
}
for (i = 0; i < leftNodes.length; i++) {
leftNodes[i].setOrder(i * 2 + 1);
}
},
_fixPosition(mindmap) {
// Position was not required in previous versions. Try to synthesize one .
const centralNode = mindmap.getBranches()[0];
const children = centralNode.getChildren();
for (let i = 0; i < children.length; i++) {
const child = children[i];
const position = child.getPosition();
this._fixNodePosition(child, position);
}
},
_fixNodePosition(node, parentPosition) {
// Position was not required in previous versions. Try to synthesize one .
let position = node.getPosition();
if (!position) {
position = { x: parentPosition.x + 30, y: parentPosition.y };
node.setPosition(position.x, position.y);
}
const children = node.getChildren();
for (let i = 0; i < children.length; i++) {
const child = children[i];
this._fixNodePosition(child, position);
}
},
});
export default Pela2TangoMigrator;

Some files were not shown because too many files have changed in this diff Show More