drawio/war/shapes/mxSysML.js

/**
 * $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;

}

//**********************************************************************************************************************************************************
//Package2
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeSysMLPackage2(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(mxShapeSysMLPackage2, mxShape);

mxShapeSysMLPackage2.prototype.cst = {
		PACKAGE2 : 'mxgraph.sysml.package2',
		LABEL_X : 'labelX'
};

/**
* Function: paintVertexShape
* 
* Paints the vertex shape.
*/
mxShapeSysMLPackage2.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);
};

mxShapeSysMLPackage2.prototype.background = function(c, x, y, w, h)
{
	c.rect(0, 0, w, h);
	c.stroke();
};

mxShapeSysMLPackage2.prototype.foreground = function(c, x, y, w, h)
{
	var xSize = parseInt(mxUtils.getValue(this.style, mxShapeSysMLPackage2.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.lineTo(0, 0);
		c.close();
		c.fillAndStroke();
	}
};

mxCellRenderer.registerShape(mxShapeSysMLPackage2.prototype.cst.PACKAGE2, mxShapeSysMLPackage2);

Graph.handleFactory[mxShapeSysMLPackage2.prototype.cst.PACKAGE2] = 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);