wbrawner/drawio
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
drawio/war/shapes/mxSysML.js

2484 lines
67 KiB
JavaScript
Raw Normal View History

5.6.0.0 release Former-commit-id: 648b0f02cbadc643db2535476188df1e7b57c87c
2016-09-06 14:07:11 +00:00
/**
* $Id: mxSysML.js,v 1.0 2014/07/23 07:05:39 mate Exp $
* Copyright (c) 2006-2014, JGraph Ltd
*/
//**********************************************************************************************************************************************************
//Composite
//**********************************************************************************************************************************************************
function mxShapeSysMLComposite()
{
mxCylinder.call(this);
};
mxUtils.extend(mxShapeSysMLComposite, mxShape);
mxShapeSysMLComposite.prototype.isHtmlAllowed = function()
{
return false;
};
mxShapeSysMLComposite.prototype.paintForeground = function(c, x, y, w, h)
{
if (this.style != null)
{
var shape = mxCellRenderer.prototype.defaultShapes[this.style['symbol0']];
c.save();
var tmp = new shape();
tmp.style = this.style;
shape.prototype.paintVertexShape.call(tmp, c, x, y, w, h);
c.restore();
c.setDashed(false);
// Draws the symbols defined in the style. The symbols are
// numbered from 1...n. Possible postfixes are align,
// verticalAlign, spacing, arcSpacing, width, height
var counter = 1;
do
{
shape = mxCellRenderer.prototype.defaultShapes[this.style['symbol' + counter]];
if (shape != null)
{
var align = this.style['symbol' + counter + 'Align'];
var valign = this.style['symbol' + counter + 'VerticalAlign'];
var width = this.style['symbol' + counter + 'Width'];
var height = this.style['symbol' + counter + 'Height'];
var spacing = this.style['symbol' + counter + 'Spacing'] || 0;
var vspacing = this.style['symbol' + counter + 'VSpacing'] || 0;
var arcspacing = this.style['symbol' + counter + 'ArcSpacing'];
var direction = this.style['symbol' + counter + 'Direction'];
if (arcspacing != null)
{
spacing += this.getArcSize(w + this.strokewidth, h + this.strokewidth) * arcspacing;
vspacing += this.getArcSize(w + this.strokewidth, h + this.strokewidth) * arcspacing;
}
var x2 = x;
var y2 = y;
if (align == mxConstants.ALIGN_CENTER)
{
x2 += (w - width) / 2;
}
else if (align == mxConstants.ALIGN_RIGHT)
{
x2 += w - width - spacing;
}
else
{
x2 += spacing;
}
if (valign == mxConstants.ALIGN_MIDDLE)
{
y2 += (h - height) / 2;
}
else if (valign == mxConstants.ALIGN_BOTTOM)
{
y2 += h - height - vspacing;
}
else
{
y2 += vspacing;
}
c.save();
var tmp = new shape();
tmp.style = mxUtils.clone(this.style);
tmp.direction = direction;
tmp.updateTransform(c, x2, y2, width, height);
shape.prototype.paintVertexShape.call(tmp, c, x2, y2, width, height);
c.restore();
}
counter++;
}
while (shape != null);
}
};
mxCellRenderer.prototype.defaultShapes['mxgraph.sysml.composite'] = mxShapeSysMLComposite;
//**********************************************************************************************************************************************************
//Package
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLPackage(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLPackage, mxShape);
mxShapeSysMLPackage.prototype.cst = {
PACKAGE : 'mxgraph.sysml.package',
LABEL_X : 'labelX'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLPackage.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
this.background(c, x, y, w, h);
c.setShadow(false);
this.foreground(c, x, y, w, h);
};
mxShapeSysMLPackage.prototype.background = function(c, x, y, w, h)
{
c.rect(0, 0, w, h);
c.fillAndStroke();
};
mxShapeSysMLPackage.prototype.foreground = function(c, x, y, w, h)
{
var xSize = parseInt(mxUtils.getValue(this.style, mxShapeSysMLPackage.prototype.cst.LABEL_X, '90'));
var ySize = 20;
xSize = Math.min(xSize, w);
if (xSize > ySize)
{
c.begin();
c.moveTo(0, ySize);
c.lineTo(xSize - ySize * 0.5, ySize);
c.lineTo(xSize, ySize * 0.5);
c.lineTo(xSize, 0);
c.stroke();
}
};
mxCellRenderer.registerShape(mxShapeSysMLPackage.prototype.cst.PACKAGE, mxShapeSysMLPackage);
Graph.handleFactory[mxShapeSysMLPackage.prototype.cst.PACKAGE] = function(state)
{
var handles = [Graph.createHandle(state, ['labelX'], function(bounds)
{
var labelX = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'labelX', 90))));
return new mxPoint(bounds.x + labelX, bounds.y + 10);
}, function(bounds, pt)
{
this.state.style['labelX'] = Math.round(100 * Math.max(0, Math.min(bounds.width, pt.x - bounds.x))) / 100;
})];
return handles;
}
//**********************************************************************************************************************************************************
//None
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLNone(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLNone, mxShape);
mxShapeSysMLNone.prototype.cst = {
NONE : 'mxgraph.sysml.none'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLNone.prototype.paintVertexShape = function(c, x, y, w, h)
{
};
mxCellRenderer.registerShape(mxShapeSysMLNone.prototype.cst.NONE, mxShapeSysMLNone);
//**********************************************************************************************************************************************************
//Rectangle
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLRect(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLRect, mxShape);
mxShapeSysMLRect.prototype.cst = {
RECT : 'mxgraph.sysml.rect'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLRect.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x, y, w, h);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLRect.prototype.cst.RECT, mxShapeSysMLRect);
//**********************************************************************************************************************************************************
//Port
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLPortOne(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLPortOne, mxShape);
mxShapeSysMLPortOne.prototype.cst = {
PORT1 : 'mxgraph.sysml.port1'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLPortOne.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x + w * 0.05, y, w - w * 0.1, h);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLPortOne.prototype.cst.PORT1, mxShapeSysMLPortOne);
//**********************************************************************************************************************************************************
//Port2
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLPortTwo(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLPortTwo, mxShape);
mxShapeSysMLPortTwo.prototype.cst = {
PORT2 : 'mxgraph.sysml.port2'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLPortTwo.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x + w * 0.05, y, w * 0.8, h);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLPortTwo.prototype.cst.PORT2, mxShapeSysMLPortTwo);
//**********************************************************************************************************************************************************
//Port3
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLPortThree(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLPortThree, mxShape);
mxShapeSysMLPortThree.prototype.cst = {
PORT3 : 'mxgraph.sysml.port3'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLPortThree.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x + w * 0.07, y, w * 0.86, h);
c.fillAndStroke();
c.rect(x, y + h * 0.125, w * 0.14, h * 0.25);
c.fillAndStroke();
c.rect(x, y + h * 0.625, w * 0.14, h * 0.25);
c.fillAndStroke();
c.rect(x + w * 0.86, y + h * 0.375, w * 0.14, h * 0.25);
c.fillAndStroke();
this.drawIn(c, x + w * 0.01, y + h * 0.2, w * 0.11, h * 0.10);
this.drawOut(c, x + w * 0.02, y + h * 0.7, w * 0.11, h * 0.10);
this.drawInOut(c, x + w * 0.88, y + h * 0.45, w * 0.1, h * 0.10);
};
mxShapeSysMLPortThree.prototype.drawIn = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x, y + h * 0.5);
c.lineTo(x + w, y + h * 0.5);
c.moveTo(x + w * 0.75, y);
c.lineTo(x + w, y + h * 0.5);
c.lineTo(x + w * 0.75, y + h);
c.stroke();
}
mxShapeSysMLPortThree.prototype.drawOut = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x, y + h * 0.5);
c.lineTo(x + w, y + h * 0.5);
c.moveTo(x + w * 0.25, y);
c.lineTo(x, y + h * 0.5);
c.lineTo(x + w * 0.25, y + h);
c.stroke();
}
mxShapeSysMLPortThree.prototype.drawInOut = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x + w * 0.75, y);
c.lineTo(x + w, y + h * 0.5);
c.lineTo(x + w * 0.75, y + h);
c.moveTo(x + w * 0.25, y);
c.lineTo(x, y + h * 0.5);
c.lineTo(x + w * 0.25, y + h);
c.stroke();
}
mxCellRenderer.registerShape(mxShapeSysMLPortThree.prototype.cst.PORT3, mxShapeSysMLPortThree);
//**********************************************************************************************************************************************************
//Port
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLPortFour(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLPortFour, mxShape);
mxShapeSysMLPortFour.prototype.cst = {
PORT4 : 'mxgraph.sysml.port4'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLPortFour.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x + w * 0.05, y, w - w * 0.05, h);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLPortFour.prototype.cst.PORT4, mxShapeSysMLPortFour);
mxShapeSysMLPortFour.prototype.constraints = [
new mxConnectionConstraint(new mxPoint(0.5, 0), true),
new mxConnectionConstraint(new mxPoint(0, 0.5), true),
new mxConnectionConstraint(new mxPoint(0.5, 1), true),
new mxConnectionConstraint(new mxPoint(1, 0.5), true)
];
//**********************************************************************************************************************************************************
//Item Flow
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLItemFlow(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLItemFlow, mxShape);
mxShapeSysMLItemFlow.prototype.cst = {
ITEM_FLOW : 'mxgraph.sysml.itemFlow',
FLOW_DIR : 'flowDir',
FLOW_TYPE : 'flowType'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLItemFlow.prototype.paintVertexShape = function(c, x, y, w, h)
{
var flowDir = mxUtils.getValue(this.style, mxShapeSysMLItemFlow.prototype.cst.FLOW_DIR, 'none').toLowerCase();
var flowType = mxUtils.getValue(this.style, mxShapeSysMLItemFlow.prototype.cst.FLOW_TYPE, 'none');
if (flowDir === 'n')
{
c.rect(x, y + 10, w, h - 10);
c.fillAndStroke();
c.setShadow(false);
c.rect(x + w * 0.5 - 10, y, 20, 20);
c.fillAndStroke();
if (flowType === 'in')
{
this.drawDown(c, x + w * 0.5 - 5, y + 2, 10, 16);
}
else if (flowType === 'out')
{
this.drawUp(c, x + w * 0.5 - 5, y + 2, 10, 16);
}
}
else if (flowDir === 's')
{
c.rect(x, y, w, h - 10);
c.fillAndStroke();
c.setShadow(false);
c.rect(x + w * 0.5 - 10, y + h - 20, 20, 20);
c.fillAndStroke();
if (flowType === 'in')
{
this.drawUp(c, x + w * 0.5 - 5, y + h - 18, 10, 16);
}
else if (flowType === 'out')
{
this.drawDown(c, x + w * 0.5 - 5, y + h - 18, 10, 16);
}
}
else if (flowDir === 'w')
{
c.rect(x + 10, y, w - 10, h);
c.fillAndStroke();
c.setShadow(false);
c.rect(x, y + h * 0.5 - 10, 20, 20);
c.fillAndStroke();
if (flowType === 'in')
{
this.drawRight(c, x + 2, y + h * 0.5 - 5, 16, 10);
}
else if (flowType === 'out')
{
this.drawLeft(c, x + 2, y + h * 0.5 - 5, 16, 10);
}
}
else if (flowDir === 'e')
{
c.rect(x, y, w - 10, h);
c.fillAndStroke();
c.setShadow(false);
c.rect(x + w - 20, y + h * 0.5 - 10, 20, 20);
c.fillAndStroke();
if (flowType === 'in')
{
this.drawLeft(c, x + w - 18, y + h * 0.5 - 5, 16, 10);
}
else if (flowType === 'out')
{
this.drawRight(c, x + w - 18, y + h * 0.5 - 5, 16, 10);
}
}
};
mxShapeSysMLItemFlow.prototype.drawRight = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x, y + h * 0.5);
c.lineTo(x + w, y + h * 0.5);
c.moveTo(x + w * 0.75, y);
c.lineTo(x + w, y + h * 0.5);
c.lineTo(x + w * 0.75, y + h);
c.stroke();
}
mxShapeSysMLItemFlow.prototype.drawDown = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x + w * 0.5, y);
c.lineTo(x + w * 0.5, y + h);
c.moveTo(x, y + h * 0.75);
c.lineTo(x + w * 0.5, y + h);
c.lineTo(x + w, y + h * 0.75);
c.stroke();
}
mxShapeSysMLItemFlow.prototype.drawLeft = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x, y + h * 0.5);
c.lineTo(x + w, y + h * 0.5);
c.moveTo(x + w * 0.25, y);
c.lineTo(x, y + h * 0.5);
c.lineTo(x + w * 0.25, y + h);
c.stroke();
}
mxShapeSysMLItemFlow.prototype.drawUp = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x + w * 0.5, y + h);
c.lineTo(x + w * 0.5, y);
c.moveTo(x, y + h * 0.25);
c.lineTo(x + w * 0.5, y);
c.lineTo(x + w, y + h * 0.25);
c.stroke();
}
mxCellRenderer.registerShape(mxShapeSysMLItemFlow.prototype.cst.ITEM_FLOW, mxShapeSysMLItemFlow);
mxShapeSysMLItemFlow.prototype.constraints = [
new mxConnectionConstraint(new mxPoint(0.5, 0), true),
new mxConnectionConstraint(new mxPoint(1, 0.5), true),
new mxConnectionConstraint(new mxPoint(0.5, 1), true),
new mxConnectionConstraint(new mxPoint(0, 0.5), true)
];
//**********************************************************************************************************************************************************
//Item Flow Left
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLItemFlowLeft(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLItemFlowLeft, mxShape);
mxShapeSysMLItemFlowLeft.prototype.cst = {
ITEM_FLOW_LEFT : 'mxgraph.sysml.itemFlowLeft'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLItemFlowLeft.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x + 10, y, w - 10, h);
c.fillAndStroke();
c.rect(x, y + h * 0.25 - 10, 20, 20);
c.fillAndStroke();
c.rect(x, y + h * 0.5 - 10, 20, 20);
c.fillAndStroke();
c.rect(x, y + h * 0.75 - 10, 20, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLItemFlowLeft.prototype.cst.ITEM_FLOW_LEFT, mxShapeSysMLItemFlowLeft);
mxShapeSysMLItemFlowLeft.prototype.constraints = [
new mxConnectionConstraint(new mxPoint(0.5, 0), true),
new mxConnectionConstraint(new mxPoint(1, 0.5), true),
new mxConnectionConstraint(new mxPoint(0.5, 1), true),
new mxConnectionConstraint(new mxPoint(0, 0.25), true),
new mxConnectionConstraint(new mxPoint(0, 0.5), true),
new mxConnectionConstraint(new mxPoint(0, 0.75), true)
];
//**********************************************************************************************************************************************************
//Item Flow Right
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLItemFlowRight(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLItemFlowRight, mxShape);
mxShapeSysMLItemFlowRight.prototype.cst = {
ITEM_FLOW_RIGHT : 'mxgraph.sysml.itemFlowRight'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLItemFlowRight.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x, y, w - 10, h);
c.fillAndStroke();
c.rect(x + w - 20, y + h * 0.25 - 10, 20, 20);
c.fillAndStroke();
c.rect(x + w - 20, y + h * 0.5 - 10, 20, 20);
c.fillAndStroke();
c.rect(x + w - 20, y + h * 0.75 - 10, 20, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLItemFlowRight.prototype.cst.ITEM_FLOW_RIGHT, mxShapeSysMLItemFlowRight);
mxShapeSysMLItemFlowRight.prototype.constraints = [
new mxConnectionConstraint(new mxPoint(0.5, 0), true),
new mxConnectionConstraint(new mxPoint(0, 0.5), true),
new mxConnectionConstraint(new mxPoint(0.5, 1), true),
new mxConnectionConstraint(new mxPoint(1, 0.25), true),
new mxConnectionConstraint(new mxPoint(1, 0.5), true),
new mxConnectionConstraint(new mxPoint(1, 0.75), true)
];
//**********************************************************************************************************************************************************
//Nested Port
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLNestedPort(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLNestedPort, mxShape);
mxShapeSysMLNestedPort.prototype.cst = {
NESTED_PORT : 'mxgraph.sysml.nestedPort'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLNestedPort.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x + w * 0.08, y, w * 0.92, h);
c.fillAndStroke();
c.rect(x + w * 0.03, y + h * 0.1, w * 0.1, h * 0.8);
c.fillAndStroke();
c.rect(x, y + h * 0.15, w * 0.06, h * 0.16);
c.fillAndStroke();
c.rect(x, y + h * 0.42, w * 0.06, h * 0.16);
c.fillAndStroke();
c.rect(x, y + h * 0.69, w * 0.06, h * 0.16);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLNestedPort.prototype.cst.NESTED_PORT, mxShapeSysMLNestedPort);
//**********************************************************************************************************************************************************
//Package Containment
//**********************************************************************************************************************************************************
mxMarker.addMarker('sysMLPackCont', function(c, shape, type, pe, unitX, unitY, size, source, sw, filled)
{
var nx = unitX * (size + sw + 1);
var ny = unitY * (size + sw + 1);
var a = size / 2;
return function()
{
c.begin();
c.moveTo(pe.x - nx / 2 - ny / 2, pe.y - ny / 2 + nx / 2);
c.lineTo(pe.x - nx / 2 + ny / 2, pe.y - ny / 2 - nx / 2);
c.stroke();
c.ellipse(pe.x - 0.5 * nx - a, pe.y - 0.5 * ny - a, 2 * a, 2 * a);
c.stroke();
};
});
//**********************************************************************************************************************************************************
//Required Interface
//**********************************************************************************************************************************************************
mxMarker.addMarker('sysMLReqInt', function(c, shape, type, pe, unitX, unitY, size, source, sw, filled)
{
var nx = unitX * (size + sw + 1);
var ny = unitY * (size + sw + 1);
var a = size / 2;
return function()
{
var fillColor = mxUtils.getValue(shape.style, mxConstants.STYLE_FILLCOLOR, 'none');
c.setFillColor(fillColor);
c.ellipse(pe.x - 0.5 * nx - a, pe.y - 0.5 * ny - a, 2 * a, 2 * a);
c.fillAndStroke();
};
});
//**********************************************************************************************************************************************************
//Provided Interface
//**********************************************************************************************************************************************************
mxMarker.addMarker('sysMLProvInt', function(c, shape, type, pe, unitX, unitY, size, source, sw, filled)
{
var nx = unitX * (size + sw + 1);
var ny = unitY * (size + sw + 1);
var a = size / 2;
return function()
{
var fillColor = mxUtils.getValue(shape.style, mxConstants.STYLE_FILLCOLOR, 'none');
c.setFillColor(fillColor);
c.begin();
c.moveTo(pe.x - ny / 2, pe.y + nx / 2);
c.arcTo(a, a, 0, 0, 1, pe.x + ny / 2, pe.y - nx / 2);
c.fillAndStroke();
};
});
//**********************************************************************************************************************************************************
//Parametric Diagram
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLParametricDiagram(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLParametricDiagram, mxShape);
mxShapeSysMLParametricDiagram.prototype.cst = {
PARAM_DGM : 'mxgraph.sysml.paramDgm'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLParametricDiagram.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.roundrect(x, y, w, h, 10, 10);
c.fillAndStroke();
c.setShadow(false);
if (h > 60)
{
c.rect(x, y + h * 0.25 - 10, 20, 20);
c.stroke();
c.rect(x, y + h * 0.75 - 10, 20, 20);
c.stroke();
}
};
mxCellRenderer.registerShape(mxShapeSysMLParametricDiagram.prototype.cst.PARAM_DGM, mxShapeSysMLParametricDiagram);
//**********************************************************************************************************************************************************
//Constraint Property
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLConstraintProperty(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLConstraintProperty, mxShape);
mxShapeSysMLConstraintProperty.prototype.cst = {
CONS_PROP : 'mxgraph.sysml.consProp'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLConstraintProperty.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.rect(x, y, w, h);
c.fillAndStroke();
c.setShadow(false);
if (h > 60)
{
c.rect(x, y + 50, 20, 20);
c.stroke();
c.rect(x, y + 80, 20, 20);
c.stroke();
}
};
mxCellRenderer.registerShape(mxShapeSysMLConstraintProperty.prototype.cst.CONS_PROP, mxShapeSysMLConstraintProperty);
//**********************************************************************************************************************************************************
//Call Behavior Action
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLCallBehaviorAction(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLCallBehaviorAction, mxShape);
mxShapeSysMLCallBehaviorAction.prototype.cst = {
CALL_BEH_ACT : 'mxgraph.sysml.callBehAct'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLCallBehaviorAction.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.roundrect(x, y, w, h, 10, 10);
c.fillAndStroke();
if ((h > 30) && (w > 40))
{
c.setShadow(false);
this.drawSymb(c, x + w - 30, y + h - 30, 20, 20);
}
};
mxShapeSysMLCallBehaviorAction.prototype.drawSymb = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x + w * 0.5, y);
c.lineTo(x + w * 0.5, y + h);
c.moveTo(x, y + h);
c.lineTo(x, y + h * 0.5);
c.lineTo(x + w, y + h * 0.5);
c.lineTo(x + w, y + h);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeSysMLCallBehaviorAction.prototype.cst.CALL_BEH_ACT, mxShapeSysMLCallBehaviorAction);
//**********************************************************************************************************************************************************
//Accept Event Action
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLAcceptEventAction(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLAcceptEventAction, mxShape);
mxShapeSysMLAcceptEventAction.prototype.cst = {
ACC_EVENT : 'mxgraph.sysml.accEvent'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLAcceptEventAction.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x, y);
c.lineTo(x + w, y);
c.lineTo(x + w, y + h);
c.lineTo(x, y + h);
c.lineTo(x + h * 0.3, y + h * 0.5);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLAcceptEventAction.prototype.cst.ACC_EVENT, mxShapeSysMLAcceptEventAction);
//**********************************************************************************************************************************************************
//Time Event
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLTimeEvent(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLTimeEvent, mxShape);
mxShapeSysMLTimeEvent.prototype.cst = {
TIME_EVENT : 'mxgraph.sysml.timeEvent'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLTimeEvent.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x, y);
c.lineTo(x + w, y);
c.lineTo(x, y + h);
c.lineTo(x + w, y + h);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLTimeEvent.prototype.cst.TIME_EVENT, mxShapeSysMLTimeEvent);
//**********************************************************************************************************************************************************
//Send Signal Action
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLSendSignalAction(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLSendSignalAction, mxShape);
mxShapeSysMLSendSignalAction.prototype.cst = {
SEND_SIG_ACT : 'mxgraph.sysml.sendSigAct'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLSendSignalAction.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.begin();
c.moveTo(x, y);
c.lineTo(x + w - h * 0.3, y);
c.lineTo(x + w, y + h * 0.5);
c.lineTo(x + w - h * 0.3, y + h);
c.lineTo(x, y + h);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLSendSignalAction.prototype.cst.SEND_SIG_ACT, mxShapeSysMLSendSignalAction);
//**********************************************************************************************************************************************************
//Activity Final
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLActivityFinal(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLActivityFinal, mxShape);
mxShapeSysMLActivityFinal.prototype.cst = {
ACT_FINAL : 'mxgraph.sysml.actFinal'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLActivityFinal.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.ellipse(x, y, w, h);
c.fillAndStroke();
var strokeColor = mxUtils.getValue(this.style, mxConstants.STYLE_STROKECOLOR, '#000000');
c.setFillColor(strokeColor);
c.ellipse(x + 5, y + 5, w - 10, h - 10);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLActivityFinal.prototype.cst.ACT_FINAL, mxShapeSysMLActivityFinal);
//**********************************************************************************************************************************************************
//Activity Parameter Node
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLActivityParameterNode(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLActivityParameterNode, mxShape);
mxShapeSysMLActivityParameterNode.prototype.cst = {
ACT_PARAM_NODE : 'mxgraph.sysml.actParamNode'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLActivityParameterNode.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.begin();
var minX = Math.max(w * 0.35, 70);
var maxX = Math.min(w * 0.65, w - 10);
c.begin();
c.moveTo(minX, h);
c.lineTo(10, h);
c.lineTo(10, 0);
c.lineTo(minX, 0);
c.moveTo(maxX, h);
c.lineTo(w - 10, h);
c.lineTo(w - 10, 0);
c.lineTo(maxX, 0);
c.stroke();
var xSize = 50;
var ySize = 20;
xSize = Math.min(xSize, w);
if (xSize > ySize)
{
c.begin();
c.moveTo(10, ySize);
c.lineTo(xSize - ySize * 0.5, ySize);
c.lineTo(xSize, ySize * 0.5);
c.lineTo(xSize, 0);
c.lineTo(10, 0);
c.close();
c.fillAndStroke();
}
c.rect(0, h * 0.35 - 10, 20, 20);
c.fillAndStroke();
c.rect(0, h * 0.65 - 10, 20, 20);
c.fillAndStroke();
c.rect(w - 20, h * 0.5 - 10, 20, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLActivityParameterNode.prototype.cst.ACT_PARAM_NODE, mxShapeSysMLActivityParameterNode);
//**********************************************************************************************************************************************************
//Control Operator
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLControlOperator(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLControlOperator, mxShape);
mxShapeSysMLControlOperator.prototype.cst = {
CONT_OPER : 'mxgraph.sysml.contOper'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLControlOperator.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
this.background(c, x, y, w, h);
c.setShadow(false);
this.foreground(c, x, y, w, h);
};
mxShapeSysMLControlOperator.prototype.background = function(c, x, y, w, h)
{
c.rect(0, 0, w, h);
c.fillAndStroke();
};
mxShapeSysMLControlOperator.prototype.foreground = function(c, x, y, w, h)
{
var xSize = 130;
var ySize = 20;
xSize = Math.min(xSize, w);
if (xSize > ySize)
{
c.begin();
c.moveTo(0, ySize);
c.lineTo(xSize - ySize * 0.5, ySize);
c.lineTo(xSize, ySize * 0.5);
c.lineTo(xSize, 0);
c.stroke();
}
};
mxCellRenderer.registerShape(mxShapeSysMLControlOperator.prototype.cst.CONT_OPER, mxShapeSysMLControlOperator);
//**********************************************************************************************************************************************************
//Flow Final
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLFlowFinal(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLFlowFinal, mxShape);
mxShapeSysMLFlowFinal.prototype.cst = {
FLOW_FINAL : 'mxgraph.sysml.flowFinal'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLFlowFinal.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.ellipse(0, 0, w, h);
c.fillAndStroke();
c.setShadow(false);
c.begin();
c.moveTo(w * 0.145, h * 0.145);
c.lineTo(w * 0.855, h * 0.855);
c.moveTo(w * 0.855, h * 0.145);
c.lineTo(w * 0.145, h * 0.855);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeSysMLFlowFinal.prototype.cst.FLOW_FINAL, mxShapeSysMLFlowFinal);
//**********************************************************************************************************************************************************
//Is Control
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLIsControl(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLIsControl, mxShape);
mxShapeSysMLIsControl.prototype.cst = {
IS_CONTROL : 'mxgraph.sysml.isControl'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLIsControl.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.rect(0, h * 0.5 - 10, 10, 20);
c.fillAndStroke();
c.roundrect(10, 0, w - 20, h, 10, 10);
c.fillAndStroke();
c.rect(w - 10, h * 0.5 - 10, 10, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLIsControl.prototype.cst.IS_CONTROL, mxShapeSysMLIsControl);
//**********************************************************************************************************************************************************
//Is Stream
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLIsStream(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLIsStream, mxShape);
mxShapeSysMLIsStream.prototype.cst = {
IS_STREAM : 'mxgraph.sysml.isStream'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLIsStream.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var strokeColor = mxUtils.getValue(this.style, mxConstants.STYLE_STROKECOLOR, '#000000');
var fillColor = mxUtils.getValue(this.style, mxConstants.STYLE_FILLCOLOR, '#ffffff');
c.setFillColor(strokeColor);
c.rect(0, h * 0.5 - 10, 10, 20);
c.fillAndStroke();
c.setFillColor(fillColor);
c.roundrect(10, 0, w - 20, h, 10, 10);
c.fillAndStroke();
c.setFillColor(strokeColor);
c.rect(w - 10, h * 0.5 - 10, 10, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLIsStream.prototype.cst.IS_STREAM, mxShapeSysMLIsStream);
//**********************************************************************************************************************************************************
//Is Activity Stream
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLIsActStream(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLIsActStream, mxShape);
mxShapeSysMLIsActStream.prototype.cst = {
IS_ACT_STREAM : 'mxgraph.sysml.isActStream'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLIsActStream.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.begin();
c.rect(0, 0, w - 10, h);
c.fillAndStroke();
var xSize = 40;
var ySize = 20;
xSize = Math.min(xSize, w);
if (xSize > ySize)
{
c.begin();
c.moveTo(0, ySize);
c.lineTo(xSize - ySize * 0.5, ySize);
c.lineTo(xSize, ySize * 0.5);
c.lineTo(xSize, 0);
c.lineTo(0, 0);
c.close();
c.fillAndStroke();
}
c.rect(w - 20, h * 0.5 - 10, 20, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLIsActStream.prototype.cst.IS_ACT_STREAM, mxShapeSysMLIsActStream);
//**********************************************************************************************************************************************************
//Parameter Set
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLParameterSet(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLParameterSet, mxShape);
mxShapeSysMLParameterSet.prototype.cst = {
PARAM_SET : 'mxgraph.sysml.paramSet'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLParameterSet.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.rect(0, h * 0.5 - 28, 10, 56);
c.fillAndStroke();
c.roundrect(10, 0, w - 20, h, 10, 10);
c.fillAndStroke();
c.rect(w - 10, h * 0.5 - 28, 10, 56);
c.fillAndStroke();
c.setShadow(false);
c.rect(4, h * 0.5 - 24, 6, 20);
c.fillAndStroke();
c.rect(4, h * 0.5 + 4, 6, 20);
c.fillAndStroke();
c.rect(w - 10, h * 0.5 - 24, 6, 20);
c.fillAndStroke();
c.rect(w - 10, h * 0.5 + 4, 6, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLParameterSet.prototype.cst.PARAM_SET, mxShapeSysMLParameterSet);
//**********************************************************************************************************************************************************
//Is Activity Stream
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLParameterActivitySet(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLParameterActivitySet, mxShape);
mxShapeSysMLParameterActivitySet.prototype.cst = {
PARAM_ACT_SET : 'mxgraph.sysml.paramActSet'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLParameterActivitySet.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.begin();
c.rect(10, 0, w - 20, h);
c.fillAndStroke();
var xSize = 50;
var ySize = 20;
xSize = Math.min(xSize, w);
if (xSize > ySize)
{
c.begin();
c.moveTo(10, ySize);
c.lineTo(xSize - ySize * 0.5, ySize);
c.lineTo(xSize, ySize * 0.5);
c.lineTo(xSize, 0);
c.lineTo(10, 0);
c.close();
c.fillAndStroke();
}
c.setShadow(false);
if (h > 70)
{
c.rect(0, h * 0.5 - 28, 15, 56);
c.fillAndStroke();
c.rect(4, h * 0.5 - 24, 15, 20);
c.fillAndStroke();
c.rect(4, h * 0.5 + 4, 15, 20);
c.fillAndStroke();
c.rect(w - 15, h * 0.5 - 28, 15, 56);
c.fillAndStroke();
c.rect(w - 19, h * 0.5 - 24, 15, 20);
c.fillAndStroke();
c.rect(w - 19, h * 0.5 + 4, 15, 20);
c.fillAndStroke();
}
};
mxCellRenderer.registerShape(mxShapeSysMLParameterActivitySet.prototype.cst.PARAM_ACT_SET, mxShapeSysMLParameterActivitySet);
//**********************************************************************************************************************************************************
//Probability
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLProbability(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLProbability, mxShape);
mxShapeSysMLProbability.prototype.cst = {
PROBABILITY : 'mxgraph.sysml.probability'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLProbability.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.roundrect(0, 0, w - 10, h, 10, 10);
c.fillAndStroke();
c.rect(w - 10, h * 0.25 - 28, 10, 56);
c.fillAndStroke();
c.rect(w - 10, h * 0.75 - 28, 10, 56);
c.fillAndStroke();
c.setShadow(false);
c.rect(w - 10, h * 0.25 - 24, 6, 20);
c.fillAndStroke();
c.rect(w - 10, h * 0.25 + 4, 6, 20);
c.fillAndStroke();
c.rect(w - 10, h * 0.75 - 24, 6, 20);
c.fillAndStroke();
c.rect(w - 10, h * 0.75 + 4, 6, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLProbability.prototype.cst.PROBABILITY, mxShapeSysMLProbability);
//**********************************************************************************************************************************************************
//Is Activity Stream
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLActivityProbability(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLActivityProbability, mxShape);
mxShapeSysMLActivityProbability.prototype.cst = {
ACT_PROB : 'mxgraph.sysml.actProb'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLActivityProbability.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.begin();
c.rect(0, 0, w - 10, h);
c.fillAndStroke();
var xSize = 40;
var ySize = 20;
xSize = Math.min(xSize, w);
if (xSize > ySize)
{
c.begin();
c.moveTo(0, ySize);
c.lineTo(xSize - ySize * 0.5, ySize);
c.lineTo(xSize, ySize * 0.5);
c.lineTo(xSize, 0);
c.lineTo(0, 0);
c.close();
c.fillAndStroke();
}
c.setShadow(false);
if (h > 70)
{
c.rect(w - 15, h * 0.25 - 28, 15, 56);
c.fillAndStroke();
c.rect(w - 19, h * 0.25 - 24, 15, 20);
c.fillAndStroke();
c.rect(w - 19, h * 0.25 + 4, 15, 20);
c.fillAndStroke();
c.rect(w - 15, h * 0.75 - 28, 15, 56);
c.fillAndStroke();
c.rect(w - 19, h * 0.75 - 24, 15, 20);
c.fillAndStroke();
c.rect(w - 19, h * 0.75 + 4, 15, 20);
c.fillAndStroke();
}
};
mxCellRenderer.registerShape(mxShapeSysMLActivityProbability.prototype.cst.ACT_PROB, mxShapeSysMLActivityProbability);
//**********************************************************************************************************************************************************
//Object Flow Right
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLObjectFlowRight(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLObjectFlowRight, mxShape);
mxShapeSysMLObjectFlowRight.prototype.cst = {
OBJ_FLOW_R : 'mxgraph.sysml.objFlowR'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLObjectFlowRight.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.roundrect(0, 0, w - 10, h, 10, 10);
c.fillAndStroke();
c.rect(w - 10, h * 0.5 - 10, 10, 20);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLObjectFlowRight.prototype.cst.OBJ_FLOW_R, mxShapeSysMLObjectFlowRight);
//**********************************************************************************************************************************************************
//Object Flow Right
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLObjectFlowLeft(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLObjectFlowLeft, mxShape);
mxShapeSysMLObjectFlowLeft.prototype.cst = {
OBJ_FLOW_L : 'mxgraph.sysml.objFlowL'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLObjectFlowLeft.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.rect(0, h * 0.5 - 10, 10, 20);
c.fillAndStroke();
c.roundrect(10, 0, w - 10, h, 10, 10);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLObjectFlowLeft.prototype.cst.OBJ_FLOW_L, mxShapeSysMLObjectFlowLeft);
//**********************************************************************************************************************************************************
//Activity Partition
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLActivityPartition(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLActivityPartition, mxShape);
mxShapeSysMLActivityPartition.prototype.cst = {
ACT_PART : 'mxgraph.sysml.actPart'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLActivityPartition.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.begin();
c.moveTo(0, 0);
c.lineTo(0, h);
c.moveTo(w, 0);
c.lineTo(w, h);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeSysMLActivityPartition.prototype.cst.ACT_PART, mxShapeSysMLActivityPartition);
//**********************************************************************************************************************************************************
//Continuation
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLContinuation(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLContinuation, mxShape);
mxShapeSysMLContinuation.prototype.cst = {
CONT : 'mxgraph.sysml.cont'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLContinuation.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
if (w > h)
{
var r = h * 0.5;
c.begin();
c.moveTo(w - r, 0);
c.arcTo(r, r, 0, 0, 1, w - r, h);
c.lineTo(r, h);
c.arcTo(r, r, 0, 0, 1, r, 0);
c.close();
c.fillAndStroke();
}
else
{
var r = w * 0.5;
c.begin();
c.moveTo(0, h - r);
c.arcTo(r, r, 0, 0, 0, w, h - r);
c.lineTo(w, r);
c.arcTo(r, r, 0, 0, 0, 0, r);
c.close();
c.fillAndStroke();
}
};
mxCellRenderer.registerShape(mxShapeSysMLContinuation.prototype.cst.CONT, mxShapeSysMLContinuation);
//**********************************************************************************************************************************************************
//Coregion
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLCoregion(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLCoregion, mxShape);
mxShapeSysMLCoregion.prototype.cst = {
COREGION : 'mxgraph.sysml.coregion'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLCoregion.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var brack = 10;
brack = Math.min(brack, h);
c.begin();
c.moveTo(0, brack);
c.lineTo(0, 0);
c.lineTo(w, 0);
c.lineTo(w, brack);
c.moveTo(0, h - brack);
c.lineTo(0, h);
c.lineTo(w, h);
c.lineTo(w, h - brack);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeSysMLCoregion.prototype.cst.COREGION, mxShapeSysMLCoregion);
//**********************************************************************************************************************************************************
//X marker
//**********************************************************************************************************************************************************
mxMarker.addMarker('sysMLx', function(c, shape, type, pe, unitX, unitY, size, source, sw, filled)
{
var nx = unitX * (size + sw + 1);
var ny = unitY * (size + sw + 1);
return function()
{
c.begin();
c.moveTo(pe.x - nx / 2 - ny / 2, pe.y - ny / 2 + nx / 2);
c.lineTo(pe.x + nx / 2 + ny / 2, pe.y + ny / 2 - nx / 2);
c.moveTo(pe.x + nx / 2 - ny / 2, pe.y + ny / 2 + nx / 2);
c.lineTo(pe.x - nx / 2 + ny / 2, pe.y - ny / 2 - nx / 2);
c.stroke();
};
});
//**********************************************************************************************************************************************************
//Dimension
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLDimension(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLDimension, mxShape);
mxShapeSysMLDimension.prototype.cst = {
DIMENSION : 'mxgraph.sysml.dimension'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLDimension.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
this.background(c, x, y, w, h);
};
mxShapeSysMLDimension.prototype.background = function(c, x, y, w, h)
{
c.begin();
c.moveTo(0, 20);
c.lineTo(w, 20);
c.moveTo(10, 15);
c.lineTo(0, 20);
c.lineTo(10, 25);
c.moveTo(w - 10, 15);
c.lineTo(w, 20);
c.lineTo(w - 10, 25);
c.moveTo(0, 15);
c.lineTo(0, h);
c.moveTo(w, 15);
c.lineTo(w, h);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeSysMLDimension.prototype.cst.DIMENSION, mxShapeSysMLDimension);
//**********************************************************************************************************************************************************
//Lost marker
//**********************************************************************************************************************************************************
mxMarker.addMarker('sysMLLost', function(c, shape, type, pe, unitX, unitY, size, source, sw, filled)
{
var nx = unitX * (size + sw + 1);
var ny = unitY * (size + sw + 1);
var a = size / 2;
return function()
{
c.begin();
c.moveTo(pe.x - 1.5 * nx - ny / 2, pe.y - 1.5 * ny + nx / 2);
c.lineTo(pe.x - nx / 2, pe.y - ny / 2);
c.lineTo(pe.x - 1.5 * nx + ny / 2, pe.y - 1.5 * ny - nx / 2);
c.stroke();
c.ellipse(pe.x - 0.5 * nx - a, pe.y - 0.5 * ny - a, 2 * a, 2 * a);
var strokeColor = mxUtils.getValue(shape.style, mxConstants.STYLE_STROKECOLOR, '#000000');
c.setFillColor(strokeColor);
c.fillAndStroke();
};
});
//**********************************************************************************************************************************************************
//Found marker
//**********************************************************************************************************************************************************
mxMarker.addMarker('sysMLFound', function(c, shape, type, pe, unitX, unitY, size, source, sw, filled)
{
var nx = unitX * (size + sw + 1);
var ny = unitY * (size + sw + 1);
var a = size / 2;
return function()
{
c.ellipse(pe.x - 0.5 * nx - a, pe.y - 0.5 * ny - a, 2 * a, 2 * a);
var strokeColor = mxUtils.getValue(shape.style, mxConstants.STYLE_STROKECOLOR, '#000000');
c.setFillColor(strokeColor);
c.fillAndStroke();
};
});
//**********************************************************************************************************************************************************
//Composite State
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLCompositeState(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLCompositeState, mxShape);
mxShapeSysMLCompositeState.prototype.cst = {
COMP_STATE : 'mxgraph.sysml.compState'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLCompositeState.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
this.background(c, x, y, w, h);
};
mxShapeSysMLCompositeState.prototype.background = function(c, x, y, w, h)
{
var tabH = 20;
var tabW = 110;
c.roundrect(0, tabH, w, h - tabH, 10, 10);
c.fillAndStroke();
c.rect(15, 0, tabW, tabH);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLCompositeState.prototype.cst.COMP_STATE, mxShapeSysMLCompositeState);
//**********************************************************************************************************************************************************
//Region
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLRegion(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLRegion, mxShape);
mxShapeSysMLRegion.prototype.cst = {
REGION : 'mxgraph.sysml.region'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLRegion.prototype.paintVertexShape = function(c, x, y, w, h)
{
var tabH = 20;
var tabW = 50;
c.translate(x, y);
this.background(c, x, y, w, h, tabH, tabW);
c.setShadow(false);
this.foreground(c, x, y, w, h, tabH, tabW);
};
mxShapeSysMLRegion.prototype.background = function(c, x, y, w, h, tabH, tabW)
{
var strokeW = parseInt(mxUtils.getValue(this.style, mxConstants.STYLE_STROKEWIDTH, '1'));
c.roundrect(0, tabH, w, h - tabH, 10, 10);
c.fillAndStroke();
c.setStrokeWidth(strokeW * 2);
c.rect(15, 0, tabW, tabH);
c.fillAndStroke();
c.setStrokeWidth(strokeW);
};
mxShapeSysMLRegion.prototype.foreground = function(c, x, y, w, h, tabH, tabW)
{
c.setDashed(true);
c.begin();
c.moveTo(w * 0.5, tabH);
c.lineTo(w * 0.5, h);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeSysMLRegion.prototype.cst.REGION, mxShapeSysMLRegion);
//**********************************************************************************************************************************************************
//Simple State
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLSimpleState(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLSimpleState, mxShape);
mxShapeSysMLSimpleState.prototype.cst = {
SIMPLE_STATE : 'mxgraph.sysml.simpleState'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLSimpleState.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
this.background(c, x, y, w, h);
c.setShadow(false);
// this.foreground(c, x, y, w, h);
};
mxShapeSysMLSimpleState.prototype.background = function(c, x, y, w, h)
{
var strokeW = parseInt(mxUtils.getValue(this.style, mxConstants.STYLE_STROKEWIDTH, '1'));
c.roundrect(0, 0, w, h, 10, 10);
c.fillAndStroke();
};
mxShapeSysMLSimpleState.prototype.foreground = function(c, x, y, w, h)
{
c.begin();
c.moveTo(0, 20);
c.lineTo(w, 20);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeSysMLSimpleState.prototype.cst.SIMPLE_STATE, mxShapeSysMLSimpleState);
//**********************************************************************************************************************************************************
//State Machine
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLStateMachine(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLStateMachine, mxShape);
mxShapeSysMLStateMachine.prototype.cst = {
STATE_MACHINE : 'mxgraph.sysml.stateMachine'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLStateMachine.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
this.background(c, x, y, w, h);
c.setShadow(false);
this.foreground(c, x, y, w, h);
};
mxShapeSysMLStateMachine.prototype.background = function(c, x, y, w, h)
{
c.roundrect(0, 0, w - 10, h, 10, 10);
c.fillAndStroke();
};
mxShapeSysMLStateMachine.prototype.foreground = function(c, x, y, w, h)
{
var strokeC = mxUtils.getValue(this.style, mxConstants.STYLE_STROKECOLOR, '#000000');
c.setFillColor(strokeC);
c.ellipse(w - 20, h * 0.5 - 10, 20, 20);
c.stroke();
c.ellipse(w - 17, h * 0.5 - 7, 14, 14);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLStateMachine.prototype.cst.STATE_MACHINE, mxShapeSysMLStateMachine);
//**********************************************************************************************************************************************************
// X
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLX(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLX, mxShape);
mxShapeSysMLX.prototype.cst = {
X : 'mxgraph.sysml.x'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLX.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.begin();
c.moveTo(0, 0);
c.lineTo(w, h);
c.moveTo(0, h);
c.lineTo(w, 0);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLX.prototype.cst.X, mxShapeSysMLX);
//**********************************************************************************************************************************************************
//Submachine State
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLSubmachineState(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLSubmachineState, mxShape);
mxShapeSysMLSubmachineState.prototype.cst = {
SUBMACHINE_STATE : 'mxgraph.sysml.submState'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLSubmachineState.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
this.background(c, x, y, w, h);
c.setShadow(false);
this.foreground(c, x, y, w, h);
};
mxShapeSysMLSubmachineState.prototype.background = function(c, x, y, w, h)
{
c.roundrect(0, 0, w - 10, h, 10, 10);
c.fillAndStroke();
};
mxShapeSysMLSubmachineState.prototype.foreground = function(c, x, y, w, h)
{
var strokeC = mxUtils.getValue(this.style, mxConstants.STYLE_STROKECOLOR, '#000000');
c.setFillColor(strokeC);
c.ellipse(w - 20, h * 0.5 - 10, 20, 20);
c.stroke();
c.ellipse(w - 17, h * 0.5 - 7, 14, 14);
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeSysMLSubmachineState.prototype.cst.SUBMACHINE_STATE, mxShapeSysMLSubmachineState);
//**********************************************************************************************************************************************************
//Use Case with Extension Points
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLUseCaseExtensionPoints(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeSysMLUseCaseExtensionPoints, mxShape);
mxShapeSysMLUseCaseExtensionPoints.prototype.cst = {
USE_CASE_EXT_PT : 'mxgraph.sysml.useCaseExtPt'
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeSysMLUseCaseExtensionPoints.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
this.background(c, x, y, w, h);
c.setShadow(false);
this.foreground(c, x, y, w, h);
};
mxShapeSysMLUseCaseExtensionPoints.prototype.background = function(c, x, y, w, h)
{
c.ellipse(0, 0, w, h);
c.fillAndStroke();
};
mxShapeSysMLUseCaseExtensionPoints.prototype.foreground = function(c, x, y, w, h)
{
c.begin();
c.moveTo(w * 0.02, h * 0.35);
c.lineTo(w * 0.98, h * 0.35);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeSysMLUseCaseExtensionPoints.prototype.cst.USE_CASE_EXT_PT, mxShapeSysMLUseCaseExtensionPoints);
Reference in a new issue Copy permalink