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

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;