mirror of
https://bitbucket.org/wisemapping/wisemapping-frontend.git
synced 2024-11-26 16:14:56 +01:00
425 lines
9.0 KiB
JavaScript
425 lines
9.0 KiB
JavaScript
/*
|
|
* Copyright [2015] [wisemapping]
|
|
*
|
|
* Licensed under WiseMapping Public License, Version 1.0 (the "License").
|
|
* It is basically the Apache License, Version 2.0 (the "License") plus the
|
|
* "powered by wisemapping" text requirement on every single page;
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the license at
|
|
*
|
|
* http://www.wisemapping.org/license
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
const INodeModel = new Class(
|
|
/** @lends INodeModel */ {
|
|
/**
|
|
* @constructs
|
|
* @param mindmap
|
|
*/
|
|
initialize(mindmap) {
|
|
$assert(mindmap && mindmap.getBranches, 'mindmap can not be null');
|
|
this._mindmap = mindmap;
|
|
},
|
|
|
|
/** */
|
|
getId() {
|
|
return this.getProperty('id');
|
|
},
|
|
|
|
/** */
|
|
setId(id) {
|
|
if ($defined(id) && id > INodeModel._uuid) {
|
|
INodeModel._uuid = id;
|
|
}
|
|
if (!$defined(id)) {
|
|
id = INodeModel._nextUUID();
|
|
}
|
|
|
|
this.putProperty('id', id);
|
|
},
|
|
|
|
/** */
|
|
getType() {
|
|
return this.getProperty('type');
|
|
},
|
|
|
|
/** */
|
|
setType(type) {
|
|
this.putProperty('type', type);
|
|
},
|
|
|
|
/** */
|
|
setText(text) {
|
|
this.putProperty('text', text);
|
|
},
|
|
|
|
/** */
|
|
getText() {
|
|
return this.getProperty('text');
|
|
},
|
|
|
|
/** */
|
|
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() {
|
|
const value = this.getProperty('position');
|
|
let result = null;
|
|
if (value != null) {
|
|
result = eval(`(${value})`);
|
|
}
|
|
return result;
|
|
},
|
|
|
|
/** */
|
|
setImageSize(width, height) {
|
|
this.putProperty('imageSize', `{width:${width},height:${height}}`);
|
|
},
|
|
|
|
/** */
|
|
getImageSize() {
|
|
const value = this.getProperty('imageSize');
|
|
let result = null;
|
|
if (value != null) {
|
|
result = eval(`(${value})`);
|
|
}
|
|
return result;
|
|
},
|
|
|
|
/** */
|
|
setImageUrl(url) {
|
|
this.putProperty('imageUrl', url);
|
|
},
|
|
|
|
/** */
|
|
getMetadata() {
|
|
return this.getProperty('metadata');
|
|
},
|
|
|
|
/** */
|
|
setMetadata(json) {
|
|
this.putProperty('metadata', json);
|
|
},
|
|
|
|
/** */
|
|
getImageUrl() {
|
|
return this.getProperty('imageUrl');
|
|
},
|
|
|
|
/** */
|
|
getMindmap() {
|
|
return this._mindmap;
|
|
},
|
|
|
|
/**
|
|
* lets the mindmap handle the disconnect node operation
|
|
* @see mindplot.model.IMindmap.disconnect
|
|
*/
|
|
disconnect() {
|
|
const mindmap = this.getMindmap();
|
|
mindmap.disconnect(this);
|
|
},
|
|
|
|
/** */
|
|
getShapeType() {
|
|
return this.getProperty('shapeType');
|
|
},
|
|
|
|
/** */
|
|
setShapeType(type) {
|
|
this.putProperty('shapeType', type);
|
|
},
|
|
|
|
/** */
|
|
setOrder(value) {
|
|
$assert(
|
|
(typeof value === 'number' && isFinite(value)) || value == null,
|
|
'Order must be null or a number',
|
|
);
|
|
this.putProperty('order', value);
|
|
},
|
|
|
|
/** */
|
|
getOrder() {
|
|
return this.getProperty('order');
|
|
},
|
|
|
|
/** */
|
|
setFontFamily(fontFamily) {
|
|
this.putProperty('fontFamily', fontFamily);
|
|
},
|
|
|
|
/** */
|
|
getFontFamily() {
|
|
return this.getProperty('fontFamily');
|
|
},
|
|
|
|
/** */
|
|
setFontStyle(fontStyle) {
|
|
this.putProperty('fontStyle', fontStyle);
|
|
},
|
|
|
|
/** */
|
|
getFontStyle() {
|
|
return this.getProperty('fontStyle');
|
|
},
|
|
|
|
/** */
|
|
setFontWeight(weight) {
|
|
this.putProperty('fontWeight', weight);
|
|
},
|
|
|
|
/** */
|
|
getFontWeight() {
|
|
return this.getProperty('fontWeight');
|
|
},
|
|
|
|
/** */
|
|
setFontColor(color) {
|
|
this.putProperty('fontColor', color);
|
|
},
|
|
|
|
/** */
|
|
getFontColor() {
|
|
return this.getProperty('fontColor');
|
|
},
|
|
|
|
/** */
|
|
setFontSize(size) {
|
|
this.putProperty('fontSize', size);
|
|
},
|
|
|
|
/** */
|
|
getFontSize() {
|
|
return this.getProperty('fontSize');
|
|
},
|
|
|
|
/** */
|
|
getBorderColor() {
|
|
return this.getProperty('borderColor');
|
|
},
|
|
|
|
/** */
|
|
setBorderColor(color) {
|
|
this.putProperty('borderColor', color);
|
|
},
|
|
|
|
/** */
|
|
getBackgroundColor() {
|
|
return this.getProperty('backgroundColor');
|
|
},
|
|
|
|
/** */
|
|
setBackgroundColor(color) {
|
|
this.putProperty('backgroundColor', color);
|
|
},
|
|
|
|
/** */
|
|
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(value) {
|
|
this.putProperty('shrunken', value);
|
|
},
|
|
|
|
/**
|
|
* @return {Boolean} true
|
|
*/
|
|
isNodeModel() {
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* @return {Boolean} true if the node model has a parent assigned to it
|
|
*/
|
|
isConnected() {
|
|
return this.getParent() != null;
|
|
},
|
|
|
|
/** @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(parent) {
|
|
$assert(parent, 'parent can not be null');
|
|
const mindmap = this.getMindmap();
|
|
mindmap.connect(parent, this);
|
|
},
|
|
|
|
/**
|
|
* @param target
|
|
* @return target
|
|
*/
|
|
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 ...
|
|
const children = this.getChildren();
|
|
const tmindmap = target.getMindmap();
|
|
|
|
_.each((children, snode) => {
|
|
const tnode = tmindmap.createNode(snode.getType(), snode.getId());
|
|
snode.copyTo(tnode);
|
|
target.append(tnode);
|
|
});
|
|
|
|
return target;
|
|
},
|
|
|
|
/**
|
|
* lets parent handle the delete node operation, or, if none defined, calls the mindmap to
|
|
* remove the respective branch
|
|
*/
|
|
deleteNode() {
|
|
const mindmap = this.getMindmap();
|
|
|
|
// 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() {
|
|
throw 'Unsupported operation';
|
|
},
|
|
|
|
/** @abstract */
|
|
putProperty(key, value) {
|
|
throw 'Unsupported operation';
|
|
},
|
|
|
|
/** @abstract */
|
|
setParent(parent) {
|
|
throw 'Unsupported operation';
|
|
},
|
|
|
|
/** @abstract */
|
|
getChildren() {
|
|
throw 'Unsupported operation';
|
|
},
|
|
|
|
/** @abstract */
|
|
getParent() {
|
|
throw 'Unsupported operation';
|
|
},
|
|
|
|
/** @abstract */
|
|
clone() {
|
|
throw 'Unsupported operation';
|
|
},
|
|
|
|
/** */
|
|
inspect() {
|
|
let result = `{ type: ${
|
|
this.getType()
|
|
} , id: ${
|
|
this.getId()
|
|
} , text: ${
|
|
this.getText()}`;
|
|
|
|
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;
|
|
},
|
|
|
|
/** @abstract */
|
|
removeChild(child) {
|
|
throw 'Unsupported operation';
|
|
},
|
|
},
|
|
);
|
|
|
|
/**
|
|
* @enum {String}
|
|
*/
|
|
const TopicShape = {
|
|
RECTANGLE: 'rectagle',
|
|
ROUNDED_RECT: 'rounded rectagle',
|
|
ELLIPSE: 'elipse',
|
|
LINE: 'line',
|
|
IMAGE: 'image',
|
|
};
|
|
|
|
/**
|
|
* @constant
|
|
* @type {String}
|
|
* @default
|
|
*/
|
|
INodeModel.CENTRAL_TOPIC_TYPE = 'CentralTopic';
|
|
/**
|
|
* @constant
|
|
* @type {String}
|
|
* @default
|
|
*/
|
|
INodeModel.MAIN_TOPIC_TYPE = 'MainTopic';
|
|
|
|
/**
|
|
* @constant
|
|
* @type {Number}
|
|
* @default
|
|
*/
|
|
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;
|
|
}
|
|
|
|
INodeModel._uuid += 1;
|
|
return INodeModel._uuid;
|
|
};
|
|
INodeModel._uuid = 0;
|
|
|
|
export { TopicShape };
|
|
export default INodeModel;
|