draw.io is a JavaScript, client-side editor for general diagramming.
/**
* Copyright (c) 2006-2018, JGraph Holdings Ltd
*/
//**********************************************************************************************************************************************************
// Cross
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicCross(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicCross, mxActor);
mxShapeBasicCross.prototype.cst = {CROSS : 'mxgraph.basic.cross2'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicCross.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
c.begin();
c.moveTo(w * 0.5 + dx, 0);
c.lineTo(w * 0.5 + dx, h * 0.5 - dx);
c.lineTo(w, h * 0.5 - dx);
c.lineTo(w, h * 0.5 + dx);
c.lineTo(w * 0.5 + dx, h * 0.5 + dx);
c.lineTo(w * 0.5 + dx, h);
c.lineTo(w * 0.5 - dx, h);
c.lineTo(w * 0.5 - dx, h * 0.5 + dx);
c.lineTo(0, h * 0.5 + dx);
c.lineTo(0, h * 0.5 - dx);
c.lineTo(w * 0.5 - dx, h * 0.5 - dx);
c.lineTo(w * 0.5 - dx, 0);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicCross.prototype.cst.CROSS, mxShapeBasicCross);
mxShapeBasicCross.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicCross.prototype.cst.CROSS] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 2, bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + bounds.width / 2 + dx, bounds.y + bounds.height / 2 - dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, pt.x - bounds.x - bounds.width / 2))) / 100;
})];
return handles;
};
//**********************************************************************************************************************************************************
// Rectangular Callout
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicRectCallout(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dy = 0.5;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicRectCallout, mxActor);
mxShapeBasicRectCallout.prototype.customProperties = [
{name: 'dx', dispName: 'Callout Position', type: 'float', min:0, defVal:30},
{name: 'dy', dispName: 'Callout Size', type: 'float', min:0, defVal:15},
{name: 'boundedLbl', dispName: 'Bounded Label', type: 'bool', defVal: false}
];
mxShapeBasicRectCallout.prototype.cst = {RECT_CALLOUT : 'mxgraph.basic.rectCallout'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicRectCallout.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
c.begin();
c.moveTo(dx - dy * 0.5, h - dy);
c.lineTo(0, h - dy);
c.lineTo(0, 0);
c.lineTo(w, 0);
c.lineTo(w, h - dy);
c.lineTo(dx + dy * 0.5, h - dy);
c.lineTo(dx - dy, h);
c.close();
c.fillAndStroke();
};
mxShapeBasicRectCallout.prototype.getLabelMargins = function()
{
if (mxUtils.getValue(this.style, 'boundedLbl', false))
{
return new mxRectangle(0, 0, 0, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy)) * this.scale);
}
return null;
};
mxCellRenderer.registerShape(mxShapeBasicRectCallout.prototype.cst.RECT_CALLOUT, mxShapeBasicRectCallout);
Graph.handleFactory[mxShapeBasicRectCallout.prototype.cst.RECT_CALLOUT] = function(state)
{
var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
var dy = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
return new mxPoint(bounds.x + dx, bounds.y + bounds.height - dy);
}, function(bounds, pt)
{
var y = parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) * 0.6;
this.state.style['dx'] = Math.round(100 * Math.max(y, Math.min(bounds.width - y, pt.x - bounds.x))) / 100;
this.state.style['dy'] = Math.round(Math.max(0, Math.min(bounds.height, bounds.y + bounds.height - pt.y)));
})];
return handles;
};
mxShapeBasicRectCallout.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
// Relative points with the fixed px offsets, so edges follow a resize
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false, null, 0, -dy * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false, null, 0, -dy));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, dx - dy, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, 0, -dy));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, 0, -dy * 0.5));
return (constr);
}
//**********************************************************************************************************************************************************
// Rounded Rectangular Callout
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicRoundRectCallout(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dy = 0.5;
this.dx = 0.5;
this.size = 10;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicRoundRectCallout, mxActor);
mxShapeBasicRoundRectCallout.prototype.cst = {ROUND_RECT_CALLOUT : 'mxgraph.basic.roundRectCallout'};
mxShapeBasicRoundRectCallout.prototype.getLabelMargins = mxShapeBasicRectCallout.prototype.getLabelMargins;
mxShapeBasicRoundRectCallout.prototype.customProperties = [
{name: 'size', dispName: 'Arc Size', type: 'float', min:0, defVal:5},
{name: 'dx', dispName: 'Callout Position', type: 'float', min:0, defVal:30},
{name: 'dy', dispName: 'Callout Size', type: 'float', min:0, defVal:15},
{name: 'boundedLbl', dispName: 'Bounded Label', type: 'bool', defVal: false}
];
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicRoundRectCallout.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
var r = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'size', this.size))));
r = Math.min((h - dy) / 2, w / 2, r);
dx = Math.max(r + dy * 0.5, dx);
dx = Math.min(w - r - dy * 0.5, dx);
c.begin();
c.moveTo(dx - dy * 0.5, h - dy);
c.lineTo(r, h - dy);
c.arcTo(r, r, 0, 0, 1, 0, h - dy - r);
c.lineTo(0, r);
c.arcTo(r, r, 0, 0, 1, r, 0);
c.lineTo(w - r, 0);
c.arcTo(r, r, 0, 0, 1, w, r);
c.lineTo(w, h - dy - r);
c.arcTo(r, r, 0, 0, 1, w - r, h - dy);
c.lineTo(dx + dy * 0.5, h - dy);
c.arcTo(1.9 * dy, 1.4 * dy, 0, 0, 1, dx - dy, h);
c.arcTo(0.9 * dy, 1.4 * dy, 0, 0, 0, dx - dy * 0.5, h - dy);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicRoundRectCallout.prototype.cst.ROUND_RECT_CALLOUT, mxShapeBasicRoundRectCallout);
mxShapeBasicRoundRectCallout.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicRoundRectCallout.prototype.cst.ROUND_RECT_CALLOUT] = function(state)
{
return [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
var dy = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
return new mxPoint(bounds.x + dx, bounds.y + bounds.height - dy);
}, function(bounds, pt)
{
var y = parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) * 0.6;
this.state.style['dx'] = Math.round(100 * Math.max(y, Math.min(bounds.width - y, pt.x - bounds.x))) / 100;
this.state.style['dy'] = Math.round(Math.max(0, Math.min(bounds.height, bounds.y + bounds.height - pt.y)));
}), Graph.createHandle(state, ['size'], function(bounds)
{
var size = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'size', this.size))));
return new mxPoint(bounds.x + bounds.width - size, bounds.y + 10);
}, function(bounds, pt)
{
var dy = parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy));
this.state.style['size'] = Math.round(100 * Math.max(0, Math.min(bounds.width / 2, (bounds.height - dy) / 2, bounds.x + bounds.width - pt.x))) / 100;
})];
};
mxShapeBasicRoundRectCallout.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
var r = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'size', this.size))));
r = Math.min((h - dy) / 2, w / 2, r);
dx = Math.max(r + dy * 0.5, dx);
dx = Math.min(w - r - dy * 0.5, dx);
if (r < w * 0.25)
{
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 0), false));
}
// Relative points with the fixed px offsets, so edges follow a resize
if (r < (h - dy) * 0.25)
{
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.25), false, null, 0, -dy * 0.25));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.75), false, null, 0, -dy * 0.75));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.25), false, null, 0, -dy * 0.25));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.75), false, null, 0, -dy * 0.75));
}
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, r * 0.293, r * 0.293));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, -r * 0.293, r * 0.293));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false, null, 0, -dy * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, 0, -dy * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false, null, -r * 0.293, -dy - r * 0.293));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, r * 0.293, -dy - r * 0.293));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, dx - dy, 0));
return (constr);
}
//**********************************************************************************************************************************************************
// Wave
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicWave(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dy = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicWave, mxActor);
mxShapeBasicWave.prototype.customProperties = [
{name: 'dy', dispName: 'Wave Size', type: 'float', min:0, max:1, defVal: 0.3}
];
mxShapeBasicWave.prototype.cst = {WAVE : 'mxgraph.basic.wave2'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicWave.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dy = h * Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
var fy = 1.4
c.begin();
c.moveTo(0, dy / 2);
c.quadTo(w / 6, dy * (1 - fy), w / 3, dy / 2);
c.quadTo(w / 2, dy * fy, w * 2 / 3, dy / 2);
c.quadTo(w * 5 / 6, dy * (1 - fy), w, dy / 2);
c.lineTo(w, h - dy / 2);
c.quadTo(w * 5 / 6, h - dy * fy, w * 2 / 3, h - dy / 2);
c.quadTo(w / 2, h - dy * (1 - fy), w / 3, h - dy / 2);
c.quadTo(w / 6, h - dy * fy, 0, h - dy / 2);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicWave.prototype.cst.WAVE, mxShapeBasicWave);
mxShapeBasicWave.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicWave.prototype.cst.WAVE] = function(state)
{
var handles = [Graph.createHandle(state, ['dy'], function(bounds)
{
var dy = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
return new mxPoint(bounds.x + bounds.width / 2, bounds.y + dy * bounds.height);
}, function(bounds, pt)
{
this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (pt.y - bounds.y) / bounds.height))) / 100;
})];
return handles;
};
mxShapeBasicWave.prototype.getConstraints = function(style, w, h)
{
var constr = [];
// Wave size as a fraction of the height in the relative points, so edges follow a resize
var fdy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
fdy = isNaN(fdy) ? this.dy : fdy;
var fy = 1.4
constr.push(new mxConnectionConstraint(new mxPoint(0, fdy * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1 / 6, 0.015), false));
constr.push(new mxConnectionConstraint(new mxPoint(1 / 3, fdy * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, fdy * 0.95), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.67, fdy * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.83, 0.015), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, fdy * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1 - fdy * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.83, 1 - fdy * 0.95), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.67, 1 - fdy * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1 - fdy * 0.04), false));
constr.push(new mxConnectionConstraint(new mxPoint(1 / 3, 1 - fdy * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1 / 6, 1 - fdy * 0.95), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1 - fdy * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Octagon
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicOctagon(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicOctagon, mxActor);
mxShapeBasicOctagon.prototype.customProperties = [
{name: 'dx', dispName: 'Cutoff Size', type: 'float', min:0, defVal:15}
];
mxShapeBasicOctagon.prototype.cst = {OCTAGON : 'mxgraph.basic.octagon2'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicOctagon.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx)))) * 2;
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(dx, 0);
c.lineTo(w - dx, 0);
c.lineTo(w, dx);
c.lineTo(w, h - dx);
c.lineTo(w - dx, h);
c.lineTo(dx, h);
c.lineTo(0, h - dx);
c.lineTo(0, dx);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicOctagon.prototype.cst.OCTAGON, mxShapeBasicOctagon);
mxShapeBasicOctagon.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicOctagon.prototype.cst.OCTAGON] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 4, bounds.width / 4, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 4, bounds.width / 4, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicOctagon.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx)))) * 2;
dx = Math.min(w * 0.5, h * 0.5, dx) * 0.5;
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
// Relative points with the fixed px offsets, so edges follow a resize
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, dx));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, -dx, dx));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false, null, -dx, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, dx, -dx));
return (constr);
}
//**********************************************************************************************************************************************************
//Isometric Cube
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicIsoCube(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.isoAngle = 15;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicIsoCube, mxActor);
mxShapeBasicIsoCube.prototype.customProperties = [
{name: 'isoAngle', dispName: 'Perspective Angle', type: 'float', min:0, defVal:15}
];
mxShapeBasicIsoCube.prototype.cst = {ISO_CUBE : 'mxgraph.basic.isocube'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicIsoCube.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var isoAngle = Math.max(0.01, Math.min(94, parseFloat(mxUtils.getValue(this.style, 'isoAngle', this.isoAngle)))) * Math.PI / 200 ;
var isoH = Math.min(w * Math.tan(isoAngle), h * 0.5);
c.begin();
c.moveTo(w * 0.5, 0);
c.lineTo(w, isoH);
c.lineTo(w, h - isoH);
c.lineTo(w * 0.5, h);
c.lineTo(0, h - isoH);
c.lineTo(0, isoH);
c.close();
c.fillAndStroke();
c.setShadow(false);
c.begin();
c.moveTo(0, isoH);
c.lineTo(w * 0.5, 2 * isoH);
c.lineTo(w, isoH);
c.moveTo(w * 0.5, 2 * isoH);
c.lineTo(w * 0.5, h);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeBasicIsoCube.prototype.cst.ISO_CUBE, mxShapeBasicIsoCube);
mxShapeBasicIsoCube.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicIsoCube.prototype.cst.ISO_CUBE] = function(state)
{
var handles = [Graph.createHandle(state, ['isoAngle'], function(bounds)
{
var isoAngle = Math.max(0.01, Math.min(94, parseFloat(mxUtils.getValue(this.state.style, 'isoAngle', this.isoAngle)))) * Math.PI / 200 ;
var isoH = Math.min(bounds.width * Math.tan(isoAngle), bounds.height * 0.5);
return new mxPoint(bounds.x, bounds.y + isoH);
}, function(bounds, pt)
{
this.state.style['isoAngle'] = Math.round(100 * Math.max(0, Math.min(100, pt.y - bounds.y))) / 100;
})];
return handles;
};
mxShapeBasicIsoCube.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var isoAngle = Math.max(0.01, Math.min(94, parseFloat(mxUtils.getValue(this.style, 'isoAngle', this.isoAngle)))) * Math.PI / 200 ;
var isoH = Math.min(w * Math.tan(isoAngle), h * 0.5);
// The iso height is drawn from the width: anchored to the nearest side with
// the iso height as offset, so edges follow a resize that keeps the width
// (eg. a taller cube)
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, 0, isoH));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false, null, 0, -isoH));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, 0, -isoH));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, isoH));
return (constr);
}
//**********************************************************************************************************************************************************
//Acute Triangle
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicTriangleAcute(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicTriangleAcute, mxActor);
mxShapeBasicTriangleAcute.prototype.customProperties = [
{name: 'dx', dispName: 'Top', type: 'float', min:0, max:1, defVal:0.5}
];
mxShapeBasicTriangleAcute.prototype.cst = {ACUTE_TRIANGLE : 'mxgraph.basic.acute_triangle'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicTriangleAcute.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = w * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
c.begin();
c.moveTo(0, h);
c.lineTo(dx, 0);
c.lineTo(w, h);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicTriangleAcute.prototype.cst.ACUTE_TRIANGLE, mxShapeBasicTriangleAcute);
mxShapeBasicTriangleAcute.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicTriangleAcute.prototype.cst.ACUTE_TRIANGLE] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx * bounds.width, bounds.y + 10);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100;
})];
return handles;
};
mxShapeBasicTriangleAcute.prototype.getConstraints = function(style, w, h)
{
var constr = [];
// Top position as a fraction of the width in the relative points, so edges follow a resize
var fdx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
fdx = isNaN(fdx) ? this.dx : fdx;
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(fdx, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(fdx * 0.5, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1 - (1 - fdx) * 0.5, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Obtuse Triangle
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicTriangleObtuse(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicTriangleObtuse, mxActor);
mxShapeBasicTriangleObtuse.prototype.customProperties = [
{name: 'dx', dispName: 'Bottom', type: 'float', min:0, max:1, defVal:0.25}
];
mxShapeBasicTriangleObtuse.prototype.cst = {OBTUSE_TRIANGLE : 'mxgraph.basic.obtuse_triangle'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicTriangleObtuse.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = w * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
c.begin();
c.moveTo(dx, h);
c.lineTo(0, 0);
c.lineTo(w, h);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicTriangleObtuse.prototype.cst.OBTUSE_TRIANGLE, mxShapeBasicTriangleObtuse);
mxShapeBasicTriangleObtuse.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicTriangleObtuse.prototype.cst.OBTUSE_TRIANGLE] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx * bounds.width, bounds.y + bounds.height - 10);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100;
})];
return handles;
};
mxShapeBasicTriangleObtuse.prototype.getConstraints = function(style, w, h)
{
var constr = [];
// Bottom position as a fraction of the width in the relative points, so edges follow a resize
var fdx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
fdx = isNaN(fdx) ? this.dx : fdx;
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint((1 + fdx) * 0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(fdx, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(fdx * 0.5, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Drop
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicDrop(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(mxShapeBasicDrop, mxActor);
mxShapeBasicDrop.prototype.cst = {DROP : 'mxgraph.basic.drop'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicDrop.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var r = Math.min(h, w) * 0.5;
var d = h - r;
var a = Math.sqrt(d * d - r * r);
var angle = Math.atan(a / r);
var x1 = r * Math.sin(angle);
var y1 = r * Math.cos(angle);
c.begin();
c.moveTo(w * 0.5, 0);
c.lineTo(w * 0.5 + x1, h - r - y1);
c.arcTo(r, r, 0, 0, 1, w * 0.5 + r, h - r);
c.arcTo(r, r, 0, 0, 1, w * 0.5, h);
c.arcTo(r, r, 0, 0, 1, w * 0.5 - r, h - r);
c.arcTo(r, r, 0, 0, 1, w * 0.5 - x1, h - r - y1);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicDrop.prototype.cst.DROP, mxShapeBasicDrop);
mxShapeBasicDrop.prototype.constraints = null;
//**********************************************************************************************************************************************************
//Cone 2
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicCone2(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
this.dy = 0.9;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicCone2, mxActor);
mxShapeBasicCone2.prototype.customProperties = [
{name: 'dx', dispName: 'Top', type: 'float', min:0, max:1, defVal:0.5},
{name: 'dy', dispName: 'Bottom', type: 'float', min:0, max:1, defVal:0.9}
];
mxShapeBasicCone2.prototype.cst = {CONE2 : 'mxgraph.basic.cone2'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicCone2.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = w * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
var dy = h * Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
var ry = h - dy;
c.begin();
c.moveTo(dx, 0);
if (ry > 0)
{
c.lineTo(w, h - ry);
c.arcTo(w * 0.5, ry, 0, 0, 1, w * 0.5, h);
c.arcTo(w * 0.5, ry, 0, 0, 1, 0, h - ry);
}
else
{
c.lineTo(w, h);
c.lineTo(0, h);
}
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicCone2.prototype.cst.CONE2, mxShapeBasicCone2);
mxShapeBasicCone2.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicCone2.prototype.cst.CONE2] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx * bounds.width, bounds.y + 10);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100;
})];
var handle2 = Graph.createHandle(state, ['dy'], function(bounds)
{
var dy = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
return new mxPoint(bounds.x + 10, bounds.y + dy * bounds.height);
}, function(bounds, pt)
{
this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (pt.y - bounds.y) / bounds.height))) / 100;
});
handles.push(handle2);
return handles;
};
mxShapeBasicCone2.prototype.getConstraints = function(style, w, h)
{
var constr = [];
// Top and bottom as fractions of the size in the relative points, so edges follow a resize
var fdx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
fdx = isNaN(fdx) ? this.dx : fdx;
var fdy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
fdy = isNaN(fdy) ? this.dy : fdy;
constr.push(new mxConnectionConstraint(new mxPoint(fdx, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, fdy), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, fdy), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Pyramid
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicPyramid(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx1 = 0.5;
this.dx2 = 0.6;
this.dy1 = 0.9;
this.dy2 = 0.8;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicPyramid, mxActor);
mxShapeBasicPyramid.prototype.customProperties = [
{name: 'dx1', dispName: 'Top', type: 'float', min:0, max:1, defVal:0.4},
{name: 'dx2', dispName: 'Bottom', type: 'float', min:0, max:1, defVal:0.6},
{name: 'dy1', dispName: 'Perspective Left', type: 'float', min:0, max:1, defVal:0.9},
{name: 'dy2', dispName: 'Perspective Right', type: 'float', min:0, max:1, defVal:0.8}
];
mxShapeBasicPyramid.prototype.cst = {PYRAMID : 'mxgraph.basic.pyramid'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicPyramid.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx1 = w * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
var dx2 = w * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx2', this.dx2))));
var dy1 = h * Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
var dy2 = h * Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy2', this.dy2))));
c.begin();
c.moveTo(dx1, 0);
c.lineTo(w, dy2);
c.lineTo(dx2, h);
c.lineTo(0, dy1);
c.close();
c.fillAndStroke();
c.setShadow(false);
c.begin();
c.moveTo(dx1, 0);
c.lineTo(dx2, h);
c.stroke();
};
mxCellRenderer.registerShape(mxShapeBasicPyramid.prototype.cst.PYRAMID, mxShapeBasicPyramid);
mxShapeBasicPyramid.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicPyramid.prototype.cst.PYRAMID] = function(state)
{
var handles = [Graph.createHandle(state, ['dx1'], function(bounds)
{
var dx1 = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
return new mxPoint(bounds.x + dx1 * bounds.width, bounds.y + 10);
}, function(bounds, pt)
{
this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100;
})];
var handle2 = Graph.createHandle(state, ['dx2'], function(bounds)
{
var dx2 = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
return new mxPoint(bounds.x + dx2 * bounds.width, bounds.y + bounds.height - 10);
}, function(bounds, pt)
{
this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100;
});
handles.push(handle2);
var handle3 = Graph.createHandle(state, ['dy1'], function(bounds)
{
var dy1 = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
return new mxPoint(bounds.x + 10, bounds.y + dy1 * bounds.height);
}, function(bounds, pt)
{
this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(1, (pt.y - bounds.y) / bounds.height))) / 100;
});
handles.push(handle3);
var handle4 = Graph.createHandle(state, ['dy2'], function(bounds)
{
var dy2 = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2))));
return new mxPoint(bounds.x + bounds.width - 10, bounds.y + dy2 * bounds.height);
}, function(bounds, pt)
{
this.state.style['dy2'] = Math.round(100 * Math.max(0, Math.min(1, (pt.y - bounds.y) / bounds.height))) / 100;
});
handles.push(handle4);
return handles;
};
mxShapeBasicPyramid.prototype.getConstraints = function(style, w, h)
{
var constr = [];
// Corners as fractions of the size in the relative points, so edges follow a resize
var fdx1 = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
fdx1 = isNaN(fdx1) ? this.dx1 : fdx1;
var fdx2 = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx2', this.dx2))));
fdx2 = isNaN(fdx2) ? this.dx2 : fdx2;
var fdy1 = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
fdy1 = isNaN(fdy1) ? this.dy1 : fdy1;
var fdy2 = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy2', this.dy2))));
fdy2 = isNaN(fdy2) ? this.dy2 : fdy2;
constr.push(new mxConnectionConstraint(new mxPoint(fdx1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint((1 + fdx1) * 0.5, fdy2 * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, fdy2), false));
constr.push(new mxConnectionConstraint(new mxPoint((1 + fdx2) * 0.5, (1 + fdy2) * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(fdx2, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(fdx2 * 0.5, (1 + fdy1) * 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, fdy1), false));
constr.push(new mxConnectionConstraint(new mxPoint(fdx1 * 0.5, fdy1 * 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//4 Point Star 2
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasic4PointStar2(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.8;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasic4PointStar2, mxActor);
mxShapeBasic4PointStar2.prototype.customProperties = [
{name: 'dx', dispName: 'Thickness', type: 'float', min:0, max:1, defVal:0.8}
];
mxShapeBasic4PointStar2.prototype.cst = {FOUR_POINT_STAR_2 : 'mxgraph.basic.4_point_star_2'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasic4PointStar2.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = 0.5 * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
c.begin();
c.moveTo(0, h * 0.5);
c.lineTo(dx * w, dx * h);
c.lineTo(w * 0.5, 0);
c.lineTo(w - dx * w, dx * h);
c.lineTo(w, h * 0.5);
c.lineTo(w - dx * w, h - dx * h);
c.lineTo(w * 0.5, h);
c.lineTo(dx * w, h - dx * h);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasic4PointStar2.prototype.cst.FOUR_POINT_STAR_2, mxShapeBasic4PointStar2);
mxShapeBasic4PointStar2.prototype.constraints = null;
Graph.handleFactory[mxShapeBasic4PointStar2.prototype.cst.FOUR_POINT_STAR_2] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx * bounds.width / 2, bounds.y + dx * bounds.height / 2);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(1, 2 * (pt.x - bounds.x) / bounds.width))) / 100;
})];
return handles;
};
mxShapeBasic4PointStar2.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = 0.5 * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(dx, dx), false));
constr.push(new mxConnectionConstraint(new mxPoint(1 - dx, dx), false));
constr.push(new mxConnectionConstraint(new mxPoint(1 - dx, 1 - dx), false));
constr.push(new mxConnectionConstraint(new mxPoint(dx, 1 - dx), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Diagonal Snip Rectangle
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicDiagSnipRect(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicDiagSnipRect, mxActor);
mxShapeBasicDiagSnipRect.prototype.customProperties = [
{name: 'dx', dispName: 'Snip', type: 'float', min:0, deVal:6},
];
mxShapeBasicDiagSnipRect.prototype.cst = {DIAG_SNIP_RECT : 'mxgraph.basic.diag_snip_rect'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicDiagSnipRect.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx)))) * 2;
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(dx, 0);
c.lineTo(w, 0);
c.lineTo(w, h - dx);
c.lineTo(w - dx, h);
c.lineTo(0, h);
c.lineTo(0, dx);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicDiagSnipRect.prototype.cst.DIAG_SNIP_RECT, mxShapeBasicDiagSnipRect);
mxShapeBasicDiagSnipRect.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicDiagSnipRect.prototype.cst.DIAG_SNIP_RECT] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 4, bounds.width / 4, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 4, bounds.width / 4, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicDiagSnipRect.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx)))) * 2;
dx = Math.min(w * 0.5, h * 0.5, dx) * 0.5;
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, dx));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
// Relative point with the fixed px offsets, so edges follow a resize
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false, null, -dx, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Diagonal Round Rectangle
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicDiagRoundRect(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicDiagRoundRect, mxActor);
mxShapeBasicDiagRoundRect.prototype.customProperties = [
{name: 'dx', dispName: 'Rounding Size', type: 'float', min:0, defVal:6},
];
mxShapeBasicDiagRoundRect.prototype.cst = {DIAG_ROUND_RECT : 'mxgraph.basic.diag_round_rect'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicDiagRoundRect.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx)))) * 2;
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(dx, 0);
c.lineTo(w, 0);
c.lineTo(w, h - dx);
c.arcTo(dx, dx, 0, 0, 1, w - dx, h);
c.lineTo(0, h);
c.lineTo(0, dx);
c.arcTo(dx, dx, 0, 0, 1, dx, 0);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicDiagRoundRect.prototype.cst.DIAG_ROUND_RECT, mxShapeBasicDiagRoundRect);
mxShapeBasicDiagRoundRect.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicDiagRoundRect.prototype.cst.DIAG_ROUND_RECT] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 4, bounds.width / 4, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 4, bounds.width / 4, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicDiagRoundRect.prototype.getConstraints = function(style, w, h)
{
var constr = [];
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Corner Round Rectangle
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicCornerRoundRect(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicCornerRoundRect, mxActor);
mxShapeBasicCornerRoundRect.prototype.customProperties = [
{name: 'dx', dispName: 'Rounding Size', type: 'float', min:0, defVal:6},
];
mxShapeBasicCornerRoundRect.prototype.cst = {CORNER_ROUND_RECT : 'mxgraph.basic.corner_round_rect'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicCornerRoundRect.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx)))) * 2;
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(dx, 0);
c.lineTo(w, 0);
c.lineTo(w, h);
c.lineTo(0, h);
c.lineTo(0, dx);
c.arcTo(dx, dx, 0, 0, 1, dx, 0);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicCornerRoundRect.prototype.cst.CORNER_ROUND_RECT, mxShapeBasicCornerRoundRect);
mxShapeBasicCornerRoundRect.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicCornerRoundRect.prototype.cst.CORNER_ROUND_RECT] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 4, bounds.width / 4, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 4, bounds.width / 4, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicCornerRoundRect.prototype.getConstraints = function(style, w, h)
{
var constr = [];
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Plaque
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicPlaque(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicPlaque, mxActor);
mxShapeBasicPlaque.prototype.customProperties = [
{name: 'dx', dispName: 'Cutoff Size', type: 'float', min:0, defVal:6},
];
mxShapeBasicPlaque.prototype.cst = {PLAQUE : 'mxgraph.basic.plaque'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicPlaque.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx)))) * 2;
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(w - dx, 0);
c.arcTo(dx, dx, 0, 0, 0, w, dx);
c.lineTo(w, h - dx);
c.arcTo(dx, dx, 0, 0, 0, w - dx, h);
c.lineTo(dx, h);
c.arcTo(dx, dx, 0, 0, 0, 0, h - dx);
c.lineTo(0, dx);
c.arcTo(dx, dx, 0, 0, 0, dx, 0);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicPlaque.prototype.cst.PLAQUE, mxShapeBasicPlaque);
mxShapeBasicPlaque.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicPlaque.prototype.cst.PLAQUE] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 4, bounds.width / 4, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx * 1.41, bounds.y + dx * 1.41);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 4, bounds.width / 4, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicPlaque.prototype.getConstraints = function(style, w, h)
{
var constr = [];
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Frame
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicFrame(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicFrame, mxActor);
mxShapeBasicFrame.prototype.customProperties = [
{name: 'dx', dispName: 'Width', type: 'float', min:0, defVal:10},
];
mxShapeBasicFrame.prototype.cst = {FRAME : 'mxgraph.basic.frame'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicFrame.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(w, 0);
c.lineTo(w, h);
c.lineTo(0, h);
c.lineTo(0, 0);
c.close();
c.moveTo(dx, dx);
c.lineTo(dx, h - dx);
c.lineTo(w - dx, h - dx);
c.lineTo(w - dx, dx);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicFrame.prototype.cst.FRAME, mxShapeBasicFrame);
mxShapeBasicFrame.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicFrame.prototype.cst.FRAME] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 2, bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicFrame.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
// Relative points with the fixed px offsets, so edges follow a resize
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.25), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.75), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.75), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.25), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, dx));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 0), false, null, dx * 0.5, dx));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false, null, 0, dx));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 0), false, null, -dx * 0.5, dx));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, -dx, dx));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.25), false, null, -dx, dx * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false, null, -dx, 0));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.75), false, null, -dx, -dx * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false, null, -dx, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 1), false, null, -dx * 0.5, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false, null, 0, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 1), false, null, dx * 0.5, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, dx, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.75), false, null, dx, -dx * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, dx, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.25), false, null, dx, dx * 0.5));
return (constr);
}
//**********************************************************************************************************************************************************
//Plaque Frame
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicPlaqueFrame(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
*/
mxUtils.extend(mxShapeBasicPlaqueFrame, mxActor);
mxShapeBasicPlaqueFrame.prototype.customProperties = [
{name: 'dx', dispName: 'Width', type: 'float', mix:0, defVal:10},
];
mxShapeBasicPlaqueFrame.prototype.cst = {PLAQUE_FRAME : 'mxgraph.basic.plaque_frame'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicPlaqueFrame.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.25, h * 0.25, dx);
c.begin();
c.moveTo(w - dx, 0);
c.arcTo(dx, dx, 0, 0, 0, w, dx);
c.lineTo(w, h - dx);
c.arcTo(dx, dx, 0, 0, 0, w - dx, h);
c.lineTo(dx, h);
c.arcTo(dx, dx, 0, 0, 0, 0, h - dx);
c.lineTo(0, dx);
c.arcTo(dx, dx, 0, 0, 0, dx, 0);
c.close();
c.moveTo(dx * 2, dx);
c.arcTo(dx * 2, dx * 2, 0, 0, 1, dx, dx * 2);
c.lineTo(dx, h - 2 * dx);
c.arcTo(dx * 2, dx * 2, 0, 0, 1, dx * 2, h - dx);
c.lineTo(w - 2 * dx, h - dx);
c.arcTo(dx * 2, dx * 2, 0, 0, 1, w - dx, h - 2 * dx);
c.lineTo(w - dx, dx * 2);
c.arcTo(dx * 2, dx * 2, 0, 0, 1, w - 2 * dx, dx);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicPlaqueFrame.prototype.cst.PLAQUE_FRAME, mxShapeBasicPlaqueFrame);
mxShapeBasicPlaqueFrame.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicPlaqueFrame.prototype.cst.PLAQUE_FRAME] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 4, bounds.width / 4, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 4, bounds.width / 4, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicPlaqueFrame.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false, null, 0, dx));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false, null, -dx, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false, null, 0, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, dx, 0));
return (constr);
}
//**********************************************************************************************************************************************************
//Rounded Frame
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicRoundedFrame(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicRoundedFrame, mxActor);
mxShapeBasicRoundedFrame.prototype.customProperties = [
{name: 'dx', dispName: 'Width', type: 'float', min:0, defVal:10},
];
mxShapeBasicRoundedFrame.prototype.cst = {ROUNDED_FRAME : 'mxgraph.basic.rounded_frame'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicRoundedFrame.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.25, h * 0.25, dx);
c.begin();
c.moveTo(w - 2 * dx, 0);
c.arcTo(dx * 2, dx * 2, 0, 0, 1, w, 2 * dx);
c.lineTo(w, h - 2 * dx);
c.arcTo(dx * 2, dx * 2, 0, 0, 1, w - 2 * dx, h);
c.lineTo(dx * 2, h);
c.arcTo(dx * 2, dx * 2, 0, 0, 1, 0, h - 2 * dx);
c.lineTo(0, 2 * dx);
c.arcTo(dx * 2, dx * 2, 0, 0, 1, 2 * dx, 0);
c.close();
c.moveTo(dx * 2, dx);
c.arcTo(dx, dx, 0, 0, 0, dx, dx * 2);
c.lineTo(dx, h - 2 * dx);
c.arcTo(dx, dx, 0, 0, 0, dx * 2, h - dx);
c.lineTo(w - 2 * dx, h - dx);
c.arcTo(dx, dx, 0, 0, 0, w - dx, h - 2 * dx);
c.lineTo(w - dx, dx * 2);
c.arcTo(dx, dx, 0, 0, 0, w - 2 * dx, dx);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicRoundedFrame.prototype.cst.ROUNDED_FRAME, mxShapeBasicRoundedFrame);
mxShapeBasicRoundedFrame.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicRoundedFrame.prototype.cst.ROUNDED_FRAME] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 4, bounds.width / 4, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 4, bounds.width / 4, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicRoundedFrame.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false, null, 0, dx));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false, null, -dx, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false, null, 0, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, dx, 0));
return (constr);
}
//**********************************************************************************************************************************************************
//Frame Corner
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicFrameCorner(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicFrameCorner, mxActor);
mxShapeBasicFrameCorner.prototype.customProperties = [
{name: 'dx', dispName: 'Width', type: 'float', min:0, defVal:10},
];
mxShapeBasicFrameCorner.prototype.cst = {FRAME_CORNER : 'mxgraph.basic.frame_corner'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicFrameCorner.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(0, 0);
c.lineTo(w, 0);
c.lineTo(w - dx, dx);
c.lineTo(dx, dx);
c.lineTo(dx, h - dx);
c.lineTo(0, h);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicFrameCorner.prototype.cst.FRAME_CORNER, mxShapeBasicFrameCorner);
mxShapeBasicFrameCorner.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicFrameCorner.prototype.cst.FRAME_CORNER] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 2, bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicFrameCorner.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, -dx, dx));
// Relative points with the fixed px offsets, so edges follow a resize
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false, null, 0, dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, dx, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, dx, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Diagonal Stripe
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicDiagStripe(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicDiagStripe, mxActor);
mxShapeBasicDiagStripe.prototype.customProperties = [
{name: 'dx', dispName: 'Width', type: 'float', mix:0, defVal:10},
];
mxShapeBasicDiagStripe.prototype.cst = {DIAG_STRIPE : 'mxgraph.basic.diag_stripe'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicDiagStripe.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w, h, dx);
c.begin();
c.moveTo(0, h);
c.lineTo(w, 0);
c.lineTo(w, Math.min(dx * 100 / w, h));
c.lineTo(Math.min(dx * 100 / h, w), h);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicDiagStripe.prototype.cst.DIAG_STRIPE, mxShapeBasicDiagStripe);
mxShapeBasicDiagStripe.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicDiagStripe.prototype.cst.DIAG_STRIPE] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + bounds.height);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicDiagStripe.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w, h, dx);
// The end of the stripe on the right side is drawn from the width and the
// end on the bottom from the height: anchored to their side with the end
// as offset, so the edges at each end follow a resize of the other
// dimension (every resize moves one of the ends)
var x1 = Math.min(dx * 100 / h, w);
var y1 = Math.min(dx * 100 / w, h);
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, 0, y1 * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, 0, y1));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0.5), false, null, x1 * 0.5, y1 * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, x1, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, x1 * 0.5, 0));
return (constr);
}
//**********************************************************************************************************************************************************
//Donut
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicDonut(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicDonut, mxActor);
mxShapeBasicDonut.prototype.customProperties = [
{name: 'dx', dispName: 'Width', type: 'float', min:0, defVal:25}
];
mxShapeBasicDonut.prototype.cst = {DONUT : 'mxgraph.basic.donut'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicDonut.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(0, h * 0.5);
c.arcTo(w * 0.5, h * 0.5, 0, 0, 1, w * 0.5, 0);
c.arcTo(w * 0.5, h * 0.5, 0, 0, 1, w, h * 0.5);
c.arcTo(w * 0.5, h * 0.5, 0, 0, 1, w * 0.5, h);
c.arcTo(w * 0.5, h * 0.5, 0, 0, 1, 0, h * 0.5);
c.close();
c.moveTo(w * 0.5, dx);
c.arcTo(w * 0.5 - dx, h * 0.5 - dx, 0, 0, 0, dx, h * 0.5);
c.arcTo(w * 0.5 - dx, h * 0.5 - dx, 0, 0, 0, w * 0.5, h - dx);
c.arcTo(w * 0.5 - dx, h * 0.5 - dx, 0, 0, 0, w - dx, h * 0.5);
c.arcTo(w * 0.5 - dx, h * 0.5 - dx, 0, 0, 0, w * 0.5, dx);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicDonut.prototype.cst.DONUT, mxShapeBasicDonut);
mxShapeBasicDonut.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicDonut.prototype.cst.DONUT] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 2, bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + bounds.height / 2);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, pt.x - bounds.x))) / 100;
})];
return handles;
};
//**********************************************************************************************************************************************************
//Layered Rect
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicLayeredRect(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicLayeredRect, mxActor);
mxShapeBasicLayeredRect.prototype.customProperties = [
{name: 'dx', dispName: 'Layer Distance', type: 'float', mix:0, defVal:10},
{name: 'boundedLbl', dispName: 'Bounded Label', type: 'bool', defVal: false}
];
mxShapeBasicLayeredRect.prototype.cst = {LAYERED_RECT : 'mxgraph.basic.layered_rect'};
/**
* Function: getLabelMargins
*
* Confines the label to the front rectangle if boundedLbl=1. Flips are
* handled in mxShape.getLabelBounds via mxUtils.getDirectedBounds.
*/
mxShapeBasicLayeredRect.prototype.getLabelMargins = function(rect)
{
if (mxUtils.getValue(this.style, 'boundedLbl', false))
{
var w = rect.width / this.scale;
var h = rect.height / this.scale;
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx) * this.scale;
return new mxRectangle(0, 0, dx, dx);
}
return null;
};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicLayeredRect.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(dx, dx);
c.lineTo(w, dx);
c.lineTo(w, h);
c.lineTo(dx, h);
c.close();
c.fillAndStroke();
c.begin();
c.moveTo(dx * 0.5, dx * 0.5);
c.lineTo(w - dx * 0.5, dx * 0.5);
c.lineTo(w - dx * 0.5, h - dx * 0.5);
c.lineTo(dx * 0.5, h - dx * 0.5);
c.close();
c.fillAndStroke();
c.begin();
c.moveTo(0, 0);
c.lineTo(w - dx, 0);
c.lineTo(w - dx, h - dx);
c.lineTo(0, h - dx);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicLayeredRect.prototype.cst.LAYERED_RECT, mxShapeBasicLayeredRect);
mxShapeBasicLayeredRect.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicLayeredRect.prototype.cst.LAYERED_RECT] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 2, bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height - dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, - pt.x + bounds.width + bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicLayeredRect.prototype.getConstraints = function(style, w, h)
{
var constr = [];
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
// Relative points with the fixed px offsets, so edges follow a resize
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 0), false, null, -dx * 0.25, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false, null, -dx * 0.5, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 0), false, null, -dx * 0.75, 0));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, -dx, 0));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, -dx * 0.5, dx * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, 0, dx));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.25), false, null, 0, dx * 0.75));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false, null, 0, dx * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.75), false, null, 0, dx * 0.25));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 1), false, null, dx * 0.25, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false, null, dx * 0.5, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 1), false, null, dx * 0.75, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, dx, 0));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, dx * 0.5, -dx * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, 0, -dx));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.75), false, null, 0, -dx * 0.75));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, 0, -dx * 0.5));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.25), false, null, 0, -dx * 0.25));
return (constr);
}
//**********************************************************************************************************************************************************
//Button
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicButton(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicButton, mxActor);
mxShapeBasicButton.prototype.customProperties = [
{name: 'dx', dispName: 'Button Height', type: 'float', min:0, defVal:10}
];
mxShapeBasicButton.prototype.cst = {BUTTON : 'mxgraph.basic.button'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicButton.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(0, 0);
c.lineTo(w, 0);
c.lineTo(w, h);
c.lineTo(0, h);
c.close();
c.fillAndStroke();
c.setShadow(false);
c.setLineJoin('round');
c.begin();
c.moveTo(0, h);
c.lineTo(0, 0);
c.lineTo(dx, dx);
c.lineTo(dx, h - dx);
c.close();
c.fillAndStroke();
c.begin();
c.moveTo(0, 0);
c.lineTo(w, 0);
c.lineTo(w - dx, dx);
c.lineTo(dx, dx);
c.close();
c.fillAndStroke();
c.begin();
c.moveTo(w, 0);
c.lineTo(w, h);
c.lineTo(w - dx, h - dx);
c.lineTo(w - dx, dx);
c.close();
c.fillAndStroke();
c.begin();
c.moveTo(0, h);
c.lineTo(dx, h - dx);
c.lineTo(w - dx, h - dx);
c.lineTo(w, h);
c.close();
c.fillAndStroke();
c.begin();
c.moveTo(0, h);
c.lineTo(0, 0);
c.lineTo(dx, dx);
c.lineTo(dx, h - dx);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicButton.prototype.cst.BUTTON, mxShapeBasicButton);
mxShapeBasicButton.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicButton.prototype.cst.BUTTON] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 2, bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, pt.x - bounds.x))) / 100;
})];
return handles;
};
//**********************************************************************************************************************************************************
//Shaded Button
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicShadedButton(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicShadedButton, mxActor);
mxShapeBasicShadedButton.prototype.customProperties = [
{name: 'dx', dispName: 'Button Height', type: 'float', min:0, defVal:10}
];
mxShapeBasicShadedButton.prototype.cst = {SHADED_BUTTON : 'mxgraph.basic.shaded_button'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicShadedButton.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
c.setShadow(false);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(0, 0);
c.lineTo(w, 0);
c.lineTo(w, h);
c.lineTo(0, h);
c.close();
c.fill();
c.setFillColor('#ffffff');
c.setAlpha(0.25);
c.begin();
c.moveTo(0, h);
c.lineTo(0, 0);
c.lineTo(dx, dx);
c.lineTo(dx, h - dx);
c.close();
c.fill();
c.setAlpha(0.5);
c.begin();
c.moveTo(0, 0);
c.lineTo(w, 0);
c.lineTo(w - dx, dx);
c.lineTo(dx, dx);
c.close();
c.fill();
c.setFillColor('#000000');
c.setAlpha(0.25);
c.begin();
c.moveTo(w, 0);
c.lineTo(w, h);
c.lineTo(w - dx, h - dx);
c.lineTo(w - dx, dx);
c.close();
c.fill();
c.setAlpha(0.5);
c.begin();
c.moveTo(0, h);
c.lineTo(dx, h - dx);
c.lineTo(w - dx, h - dx);
c.lineTo(w, h);
c.close();
c.fill();
};
mxCellRenderer.registerShape(mxShapeBasicShadedButton.prototype.cst.SHADED_BUTTON, mxShapeBasicShadedButton);
mxShapeBasicShadedButton.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicShadedButton.prototype.cst.SHADED_BUTTON] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 2, bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, pt.x - bounds.x))) / 100;
})];
return handles;
};
//**********************************************************************************************************************************************************
//Pie
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicPie(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.startAngle = 0.25;
this.endAngle = 0.75;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicPie, mxActor);
mxShapeBasicPie.prototype.customProperties = [
{name: 'startAngle', dispName: 'Start Angle', type: 'float', min:0, max:1, defVal: 0.2},
{name: 'endAngle', dispName: 'End Angle', type: 'float', min:0, max:1, defVal: 0.9}
];
mxShapeBasicPie.prototype.cst = {PIE : 'mxgraph.basic.pie'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicPie.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var startAngleSource = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'startAngle', this.startAngle))));
var endAngleSource = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'endAngle', this.endAngle))));
var startAngle = 2 * Math.PI * startAngleSource;
var endAngle = 2 * Math.PI * endAngleSource;
var rx = w * 0.5;
var ry = h * 0.5;
var startX = rx + Math.sin(startAngle) * rx;
var startY = ry - Math.cos(startAngle) * ry;
var endX = rx + Math.sin(endAngle) * rx;
var endY = ry - Math.cos(endAngle) * ry;
var angDiff = endAngle - startAngle;
if (angDiff < 0)
{
angDiff = angDiff + Math.PI * 2;
}
var bigArc = 0;
if (angDiff >= Math.PI)
{
bigArc = 1;
}
c.begin();
var startAngleDiff = startAngleSource % 1;
var endAngleDiff = endAngleSource % 1;
if (startAngleDiff == 0 && endAngleDiff == 0.5)
{
c.moveTo(rx, ry);
c.lineTo(startX, startY);
c.arcTo(rx, ry, 0, 0, 1, w, h * 0.5);
c.arcTo(rx, ry, 0, 0, 1, w * 0.5, h);
}
else if (startAngleDiff == 0.5 && endAngleDiff == 0)
{
c.moveTo(rx, ry);
c.lineTo(startX, startY);
c.arcTo(rx, ry, 0, 0, 1, 0, h * 0.5);
c.arcTo(rx, ry, 0, 0, 1, w * 0.5, 0);
}
else
{
c.moveTo(rx, ry);
c.lineTo(startX, startY);
c.arcTo(rx, ry, 0, bigArc, 1, endX, endY);
}
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicPie.prototype.cst.PIE, mxShapeBasicPie);
mxShapeBasicPie.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicPie.prototype.cst.PIE] = function(state)
{
var handles = [Graph.createHandle(state, ['startAngle'], function(bounds)
{
var startAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'startAngle', this.startAngle))));
return new mxPoint(bounds.x + bounds.width * 0.5 + Math.sin(startAngle) * bounds.width * 0.5, bounds.y + bounds.height * 0.5 - Math.cos(startAngle) * bounds.height * 0.5);
}, function(bounds, pt)
{
var handleX = Math.round(100 * Math.max(-1, Math.min(1, (pt.x - bounds.x - bounds.width * 0.5) / (bounds.width * 0.5)))) / 100;
var handleY = -Math.round(100 * Math.max(-1, Math.min(1, (pt.y - bounds.y - bounds.height * 0.5) / (bounds.height * 0.5)))) / 100;
var res = 0.5 * Math.atan2(handleX, handleY) / Math.PI;
if (res < 0)
{
res = 1 + res;
}
this.state.style['startAngle'] = res;
})];
var handle2 = Graph.createHandle(state, ['endAngle'], function(bounds)
{
var endAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'endAngle', this.endAngle))));
return new mxPoint(bounds.x + bounds.width * 0.5 + Math.sin(endAngle) * bounds.width * 0.5, bounds.y + bounds.height * 0.5 - Math.cos(endAngle) * bounds.height * 0.5);
}, function(bounds, pt)
{
var handleX = Math.round(100 * Math.max(-1, Math.min(1, (pt.x - bounds.x - bounds.width * 0.5) / (bounds.width * 0.5)))) / 100;
var handleY = -Math.round(100 * Math.max(-1, Math.min(1, (pt.y - bounds.y - bounds.height * 0.5) / (bounds.height * 0.5)))) / 100;
var res = 0.5 * Math.atan2(handleX, handleY) / Math.PI;
if (res < 0)
{
res = 1 + res;
}
this.state.style['endAngle'] = res;
});
handles.push(handle2);
return handles;
};
//**********************************************************************************************************************************************************
//Arc
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicArc(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.startAngle = 0.25;
this.endAngle = 0.75;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicArc, mxActor);
mxShapeBasicArc.prototype.customProperties = [
{name: 'startAngle', dispName: 'Start Angle', type: 'float', min:0, max:1, defVal: 0.3},
{name: 'endAngle', dispName: 'End Angle', type: 'float', min:0, max:1, defVal:0.1},
{name: 'startArrow', dispName: 'Start Arrow', type: 'enum', defVal: 'none',
enumList: [{val: 'none', dispName: 'None'}, {val: 'classic', dispName: 'Classic'},
{val: 'classicThin', dispName: 'Classic Thin'}, {val: 'open', dispName: 'Open'},
{val: 'openThin', dispName: 'Open Thin'}, {val: 'block', dispName: 'Block'},
{val: 'blockThin', dispName: 'Block Thin'}, {val: 'oval', dispName: 'Oval'},
{val: 'diamond', dispName: 'Diamond'}, {val: 'diamondThin', dispName: 'Diamond Thin'}]},
{name: 'endArrow', dispName: 'End Arrow', type: 'enum', defVal: 'none',
enumList: [{val: 'none', dispName: 'None'}, {val: 'classic', dispName: 'Classic'},
{val: 'classicThin', dispName: 'Classic Thin'}, {val: 'open', dispName: 'Open'},
{val: 'openThin', dispName: 'Open Thin'}, {val: 'block', dispName: 'Block'},
{val: 'blockThin', dispName: 'Block Thin'}, {val: 'oval', dispName: 'Oval'},
{val: 'diamond', dispName: 'Diamond'}, {val: 'diamondThin', dispName: 'Diamond Thin'}]},
{name: 'startFill', dispName: 'Start Fill', type: 'bool', defVal: true},
{name: 'endFill', dispName: 'End Fill', type: 'bool', defVal: true},
{name: 'startSize', dispName: 'Start Size', type: 'float', min: 1, defVal: 6},
{name: 'endSize', dispName: 'End Size', type: 'float', min: 1, defVal: 6}
];
mxShapeBasicArc.prototype.cst = {ARC : 'mxgraph.basic.arc'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicArc.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var startAngleSource = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'startAngle', this.startAngle))));
var endAngleSource = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'endAngle', this.endAngle))));
var startAngle = 2 * Math.PI * startAngleSource;
var endAngle = 2 * Math.PI * endAngleSource;
// Arrow markers
var startArrow = mxUtils.getValue(this.style, mxConstants.STYLE_STARTARROW, mxConstants.NONE);
var endArrow = mxUtils.getValue(this.style, mxConstants.STYLE_ENDARROW, mxConstants.NONE);
var startSize = mxUtils.getNumber(this.style, mxConstants.STYLE_STARTSIZE, mxConstants.DEFAULT_MARKERSIZE);
var endSize = mxUtils.getNumber(this.style, mxConstants.STYLE_ENDSIZE, mxConstants.DEFAULT_MARKERSIZE);
// Inset ellipse to keep markers within shape bounds
var markerPadding = 0;
if (startArrow != null && startArrow != mxConstants.NONE)
{
markerPadding = Math.max(markerPadding, startSize);
}
if (endArrow != null && endArrow != mxConstants.NONE)
{
markerPadding = Math.max(markerPadding, endSize);
}
if (markerPadding > 0)
{
markerPadding = (markerPadding + this.strokewidth) / 2;
}
var cx = w * 0.5;
var cy = h * 0.5;
var rx = Math.max(0, w * 0.5 - markerPadding);
var ry = Math.max(0, h * 0.5 - markerPadding);
var startX = cx + Math.sin(startAngle) * rx;
var startY = cy - Math.cos(startAngle) * ry;
var endX = cx + Math.sin(endAngle) * rx;
var endY = cy - Math.cos(endAngle) * ry;
var startMarker = null;
var endMarker = null;
if (startArrow != null && startArrow != mxConstants.NONE)
{
var startFilled = this.style[mxConstants.STYLE_STARTFILL] != 0;
// Direction pointing into the start (opposite of clockwise tangent)
var dx = -rx * Math.cos(startAngle);
var dy = -ry * Math.sin(startAngle);
var dist = Math.sqrt(dx * dx + dy * dy);
if (dist > 0)
{
var pe = new mxPoint(startX, startY);
startMarker = mxMarker.createMarker(c, this, startArrow, pe,
dx / dist, dy / dist, startSize, true, this.strokewidth, startFilled);
startX = pe.x;
startY = pe.y;
}
}
if (endArrow != null && endArrow != mxConstants.NONE)
{
var endFilled = this.style[mxConstants.STYLE_ENDFILL] != 0;
// Direction along the clockwise tangent at end
var dx = rx * Math.cos(endAngle);
var dy = ry * Math.sin(endAngle);
var dist = Math.sqrt(dx * dx + dy * dy);
if (dist > 0)
{
var pe = new mxPoint(endX, endY);
endMarker = mxMarker.createMarker(c, this, endArrow, pe,
dx / dist, dy / dist, endSize, false, this.strokewidth, endFilled);
endX = pe.x;
endY = pe.y;
}
}
// Draw arc
var angDiff = endAngle - startAngle;
if (angDiff < 0)
{
angDiff = angDiff + Math.PI * 2;
}
var bigArc = 0;
if (angDiff > Math.PI)
{
bigArc = 1;
}
c.begin();
var startAngleDiff = startAngleSource % 1;
var endAngleDiff = endAngleSource % 1;
if (startMarker == null && endMarker == null &&
startAngleDiff == 0 && endAngleDiff == 0.5)
{
c.moveTo(startX, startY);
c.arcTo(rx, ry, 0, 0, 1, cx + rx, cy);
c.arcTo(rx, ry, 0, 0, 1, cx, cy + ry);
}
else if (startMarker == null && endMarker == null &&
startAngleDiff == 0.5 && endAngleDiff == 0)
{
c.moveTo(startX, startY);
c.arcTo(rx, ry, 0, 0, 1, cx - rx, cy);
c.arcTo(rx, ry, 0, 0, 1, cx, cy - ry);
}
else
{
c.moveTo(startX, startY);
c.arcTo(rx, ry, 0, bigArc, 1, endX, endY);
}
c.stroke();
// Paint markers
c.setShadow(false);
c.setDashed(false);
if (startMarker != null)
{
c.setFillColor(mxUtils.getValue(this.style,
mxConstants.STYLE_STARTFILLCOLOR, this.stroke));
startMarker();
}
if (endMarker != null)
{
c.setFillColor(mxUtils.getValue(this.style,
mxConstants.STYLE_ENDFILLCOLOR, this.stroke));
endMarker();
}
};
mxCellRenderer.registerShape(mxShapeBasicArc.prototype.cst.ARC, mxShapeBasicArc);
mxShapeBasicArc.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicArc.prototype.cst.ARC] = function(state)
{
var handles = [Graph.createHandle(state, ['startAngle'], function(bounds)
{
var startAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'startAngle', this.startAngle))));
return new mxPoint(bounds.x + bounds.width * 0.5 + Math.sin(startAngle) * bounds.width * 0.5, bounds.y + bounds.height * 0.5 - Math.cos(startAngle) * bounds.height * 0.5);
}, function(bounds, pt)
{
var handleX = Math.round(100 * Math.max(-1, Math.min(1, (pt.x - bounds.x - bounds.width * 0.5) / (bounds.width * 0.5)))) / 100;
var handleY = -Math.round(100 * Math.max(-1, Math.min(1, (pt.y - bounds.y - bounds.height * 0.5) / (bounds.height * 0.5)))) / 100;
var res = 0.5 * Math.atan2(handleX, handleY) / Math.PI;
if (res < 0)
{
res = 1 + res;
}
this.state.style['startAngle'] = res;
})];
var handle2 = Graph.createHandle(state, ['endAngle'], function(bounds)
{
var endAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'endAngle', this.endAngle))));
return new mxPoint(bounds.x + bounds.width * 0.5 + Math.sin(endAngle) * bounds.width * 0.5, bounds.y + bounds.height * 0.5 - Math.cos(endAngle) * bounds.height * 0.5);
}, function(bounds, pt)
{
var handleX = Math.round(100 * Math.max(-1, Math.min(1, (pt.x - bounds.x - bounds.width * 0.5) / (bounds.width * 0.5)))) / 100;
var handleY = -Math.round(100 * Math.max(-1, Math.min(1, (pt.y - bounds.y - bounds.height * 0.5) / (bounds.height * 0.5)))) / 100;
var res = 0.5 * Math.atan2(handleX, handleY) / Math.PI;
if (res < 0)
{
res = 1 + res;
}
this.state.style['endAngle'] = res;
});
handles.push(handle2);
return handles;
};
//**********************************************************************************************************************************************************
//Partial Concentric Ellipse
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicPartConcEllipse(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.startAngle = 0.25;
this.endAngle = 0.75;
this.arcWidth = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicPartConcEllipse, mxActor);
mxShapeBasicPartConcEllipse.prototype.customProperties = [
{name: 'startAngle', dispName: 'Start Angle', type: 'float', min:0, max:1, defVal:0.25},
{name: 'endAngle', dispName: 'End Angle', type: 'float', min:0, max:1, defVal:0.1},
{name: 'arcWidth', dispName: 'Arc Width', type: 'float', min:0, max:1, defVal:0.5}
];
mxShapeBasicPartConcEllipse.prototype.cst = {PART_CONC_ELLIPSE : 'mxgraph.basic.partConcEllipse'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicPartConcEllipse.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var startAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'startAngle', this.startAngle))));
var endAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'endAngle', this.endAngle))));
var arcWidth = 1 - Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'arcWidth', this.arcWidth))));
var rx = w * 0.5;
var ry = h * 0.5;
var rx2 = rx * arcWidth;
var ry2 = ry * arcWidth;
var angDiff = endAngle - startAngle;
if (angDiff < 0)
{
angDiff = angDiff + Math.PI * 2;
}
else if (angDiff == Math.PI)
{
endAngle = endAngle + 0.00001;
}
var startX = rx + Math.sin(startAngle) * rx;
var startY = ry - Math.cos(startAngle) * ry;
var innerStartX = rx + Math.sin(startAngle) * rx2;
var innerStartY = ry - Math.cos(startAngle) * ry2;
var endX = rx + Math.sin(endAngle) * rx;
var endY = ry - Math.cos(endAngle) * ry;
var innerEndX = rx + Math.sin(endAngle) * rx2;
var innerEndY = ry - Math.cos(endAngle) * ry2;
var bigArc = 0;
if (angDiff >= Math.PI)
{
bigArc = 1;
}
c.begin();
c.moveTo(startX, startY);
c.arcTo(rx, ry, 0, bigArc, 1, endX, endY);
c.lineTo(innerEndX, innerEndY);
c.arcTo(rx2, ry2, 0, bigArc, 0, innerStartX, innerStartY);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicPartConcEllipse.prototype.cst.PART_CONC_ELLIPSE, mxShapeBasicPartConcEllipse);
mxShapeBasicPartConcEllipse.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicPartConcEllipse.prototype.cst.PART_CONC_ELLIPSE] = function(state)
{
var handles = [Graph.createHandle(state, ['startAngle'], function(bounds)
{
var startAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'startAngle', this.startAngle))));
return new mxPoint(bounds.x + bounds.width * 0.5 + Math.sin(startAngle) * bounds.width * 0.5, bounds.y + bounds.height * 0.5 - Math.cos(startAngle) * bounds.height * 0.5);
}, function(bounds, pt)
{
var handleX = Math.round(100 * Math.max(-1, Math.min(1, (pt.x - bounds.x - bounds.width * 0.5) / (bounds.width * 0.5)))) / 100;
var handleY = -Math.round(100 * Math.max(-1, Math.min(1, (pt.y - bounds.y - bounds.height * 0.5) / (bounds.height * 0.5)))) / 100;
var res = 0.5 * Math.atan2(handleX, handleY) / Math.PI;
if (res < 0)
{
res = 1 + res;
}
this.state.style['startAngle'] = res;
})];
var handle2 = Graph.createHandle(state, ['endAngle'], function(bounds)
{
var endAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'endAngle', this.endAngle))));
return new mxPoint(bounds.x + bounds.width * 0.5 + Math.sin(endAngle) * bounds.width * 0.5, bounds.y + bounds.height * 0.5 - Math.cos(endAngle) * bounds.height * 0.5);
}, function(bounds, pt)
{
var handleX = Math.round(100 * Math.max(-1, Math.min(1, (pt.x - bounds.x - bounds.width * 0.5) / (bounds.width * 0.5)))) / 100;
var handleY = -Math.round(100 * Math.max(-1, Math.min(1, (pt.y - bounds.y - bounds.height * 0.5) / (bounds.height * 0.5)))) / 100;
var res = 0.5 * Math.atan2(handleX, handleY) / Math.PI;
if (res < 0)
{
res = 1 + res;
}
this.state.style['endAngle'] = res;
});
handles.push(handle2);
var handle3 = Graph.createHandle(state, ['arcWidth'], function(bounds)
{
var arcWidth = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'arcWidth', this.arcWidth))));
return new mxPoint(bounds.x + bounds.width / 2, bounds.y + arcWidth * bounds.height * 0.5);
}, function(bounds, pt)
{
this.state.style['arcWidth'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, (pt.y - bounds.y) / (bounds.height * 0.5)))) / 100;
});
handles.push(handle3);
return handles;
};
//**********************************************************************************************************************************************************
//Numbered entry (vertical)
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicNumEntryVert(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dy = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicNumEntryVert, mxActor);
mxShapeBasicNumEntryVert.prototype.cst = {NUM_ENTRY_VERT : 'mxgraph.basic.numberedEntryVert'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicNumEntryVert.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dy = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
var inset = 5;
var d = Math.min(dy, w - 2 * inset, h - inset);
c.ellipse(w * 0.5 - d * 0.5, 0, d, d);
c.fillAndStroke();
c.begin();
c.moveTo(0, d * 0.5);
c.lineTo(w * 0.5 - d * 0.5 - inset, d * 0.5);
c.arcTo(d * 0.5 + inset, d * 0.5 + inset, 0, 0, 0, w * 0.5 + d * 0.5 + inset, d * 0.5);
c.lineTo(w, d * 0.5);
c.lineTo(w, h);
c.lineTo(0, h);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicNumEntryVert.prototype.cst.NUM_ENTRY_VERT, mxShapeBasicNumEntryVert);
mxShapeBasicNumEntryVert.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicNumEntryVert.prototype.cst.NUM_ENTRY_VERT] = function(state)
{
var handles = [Graph.createHandle(state, ['dy'], function(bounds)
{
var dy = Math.max(0, Math.min(bounds.width, bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
return new mxPoint(bounds.x + bounds.width / 2, bounds.y + dy);
}, function(bounds, pt)
{
this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(bounds.height, bounds.width, pt.y - bounds.y))) / 100;
})];
return handles;
};
//**********************************************************************************************************************************************************
//Bending Arch
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicBendingArch(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.startAngle = 0.25;
this.endAngle = 0.75;
this.arcWidth = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicBendingArch, mxActor);
mxShapeBasicBendingArch.prototype.cst = {BENDING_ARCH : 'mxgraph.basic.bendingArch'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicBendingArch.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var startAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'startAngle', this.startAngle))));
var endAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'endAngle', this.endAngle))));
var arcWidth = 1 - Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'arcWidth', this.arcWidth))));
var rx = w * 0.5;
var ry = h * 0.5;
var rx2 = rx * arcWidth;
var ry2 = ry * arcWidth;
var startX = rx + Math.sin(startAngle) * rx;
var startY = ry - Math.cos(startAngle) * ry;
var innerStartX = rx + Math.sin(startAngle) * rx2;
var innerStartY = ry - Math.cos(startAngle) * ry2;
var endX = rx + Math.sin(endAngle) * rx;
var endY = ry - Math.cos(endAngle) * ry;
var innerEndX = rx + Math.sin(endAngle) * rx2;
var innerEndY = ry - Math.cos(endAngle) * ry2;
var angDiff = endAngle - startAngle;
if (angDiff < 0)
{
angDiff = angDiff + Math.PI * 2;
}
var bigArc = 0;
if (angDiff > Math.PI)
{
bigArc = 1;
}
var rx3 = rx2 - 5;
var ry3 = ry2 - 5;
c.ellipse(w * 0.5 - rx3, h * 0.5 - ry3, 2 * rx3, 2 * ry3);
c.fillAndStroke();
c.begin();
c.moveTo(startX, startY);
c.arcTo(rx, ry, 0, bigArc, 1, endX, endY);
c.lineTo(innerEndX, innerEndY);
c.arcTo(rx2, ry2, 0, bigArc, 0, innerStartX, innerStartY);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicBendingArch.prototype.cst.BENDING_ARCH, mxShapeBasicBendingArch);
mxShapeBasicBendingArch.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicBendingArch.prototype.cst.BENDING_ARCH] = function(state)
{
var handles = [Graph.createHandle(state, ['startAngle'], function(bounds)
{
var startAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'startAngle', this.startAngle))));
return new mxPoint(bounds.x + bounds.width * 0.5 + Math.sin(startAngle) * bounds.width * 0.5, bounds.y + bounds.height * 0.5 - Math.cos(startAngle) * bounds.height * 0.5);
}, function(bounds, pt)
{
var handleX = Math.round(100 * Math.max(-1, Math.min(1, (pt.x - bounds.x - bounds.width * 0.5) / (bounds.width * 0.5)))) / 100;
var handleY = -Math.round(100 * Math.max(-1, Math.min(1, (pt.y - bounds.y - bounds.height * 0.5) / (bounds.height * 0.5)))) / 100;
var res = 0.5 * Math.atan2(handleX, handleY) / Math.PI;
if (res < 0)
{
res = 1 + res;
}
this.state.style['startAngle'] = res;
})];
var handle2 = Graph.createHandle(state, ['endAngle'], function(bounds)
{
var endAngle = 2 * Math.PI * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'endAngle', this.endAngle))));
return new mxPoint(bounds.x + bounds.width * 0.5 + Math.sin(endAngle) * bounds.width * 0.5, bounds.y + bounds.height * 0.5 - Math.cos(endAngle) * bounds.height * 0.5);
}, function(bounds, pt)
{
var handleX = Math.round(100 * Math.max(-1, Math.min(1, (pt.x - bounds.x - bounds.width * 0.5) / (bounds.width * 0.5)))) / 100;
var handleY = -Math.round(100 * Math.max(-1, Math.min(1, (pt.y - bounds.y - bounds.height * 0.5) / (bounds.height * 0.5)))) / 100;
var res = 0.5 * Math.atan2(handleX, handleY) / Math.PI;
if (res < 0)
{
res = 1 + res;
}
this.state.style['endAngle'] = res;
});
handles.push(handle2);
var handle3 = Graph.createHandle(state, ['arcWidth'], function(bounds)
{
var arcWidth = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'arcWidth', this.arcWidth))));
return new mxPoint(bounds.x + bounds.width / 2, bounds.y + arcWidth * bounds.height * 0.5);
}, function(bounds, pt)
{
this.state.style['arcWidth'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2, bounds.width / 2, (pt.y - bounds.y) / (bounds.height * 0.5)))) / 100;
});
handles.push(handle3);
return handles;
};
//**********************************************************************************************************************************************************
//Three Corner Round Rectangle
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicThreeCornerRoundRect(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicThreeCornerRoundRect, mxActor);
mxShapeBasicThreeCornerRoundRect.prototype.customProperties = [
{name: 'dx', dispName: 'Rounding Size', type: 'float', min:0, defVal:6}
];
mxShapeBasicThreeCornerRoundRect.prototype.cst = {THREE_CORNER_ROUND_RECT : 'mxgraph.basic.three_corner_round_rect'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicThreeCornerRoundRect.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx)))) * 2;
dx = Math.min(w * 0.5, h * 0.5, dx);
c.begin();
c.moveTo(dx, 0);
c.lineTo(w - dx, 0);
c.arcTo(dx, dx, 0, 0, 1, w, dx);
c.lineTo(w, h - dx);
c.arcTo(dx, dx, 0, 0, 1, w - dx, h);
c.lineTo(0, h);
c.lineTo(0, dx);
c.arcTo(dx, dx, 0, 0, 1, dx, 0);
c.close();
c.fillAndStroke();
};
mxCellRenderer.registerShape(mxShapeBasicThreeCornerRoundRect.prototype.cst.THREE_CORNER_ROUND_RECT, mxShapeBasicThreeCornerRoundRect);
mxShapeBasicThreeCornerRoundRect.prototype.constraints = null;
Graph.handleFactory[mxShapeBasicThreeCornerRoundRect.prototype.cst.THREE_CORNER_ROUND_RECT] = function(state)
{
var handles = [Graph.createHandle(state, ['dx'], function(bounds)
{
var dx = Math.max(0, Math.min(bounds.width / 4, bounds.width / 4, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
return new mxPoint(bounds.x + dx, bounds.y + dx);
}, function(bounds, pt)
{
this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 4, bounds.width / 4, pt.x - bounds.x))) / 100;
})];
return handles;
};
mxShapeBasicThreeCornerRoundRect.prototype.getConstraints = function(style, w, h)
{
var constr = [];
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
return (constr);
}
//**********************************************************************************************************************************************************
//Polygon
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicPolygon(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
this.dy = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicPolygon, mxActor);
mxShapeBasicPolygon.prototype.customProperties = [
{name: 'polyline', dispName: 'Polyline', type: 'bool', defVal:false},
{name: 'polyCurves', dispName: 'Curves', type: 'string', defVal: '[]'}
];
mxShapeBasicPolygon.prototype.cst = {POLYGON : 'mxgraph.basic.polygon'};
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicPolygon.prototype.paintVertexShape = function(c, x, y, w, h)
{
try
{
c.translate(x, y);
var coords = JSON.parse(mxUtils.getValue(this.state.style, 'polyCoords', '[]'));
var curves = JSON.parse(mxUtils.getValue(this.state.style, 'polyCurves', '[]'));
var polyline = mxUtils.getValue(this.style, 'polyline', false);
if (coords.length > 0)
{
c.begin();
c.moveTo(coords[0][0] * w, coords[0][1] * h);
for (var i = 1; i < coords.length; i++)
{
var ci = (curves.length > i - 1) ? curves[i - 1] : null;
if (ci != null && ci.length >= 3 && ci[0] === 'Q')
{
c.quadTo(ci[1] * w, ci[2] * h, coords[i][0] * w, coords[i][1] * h);
}
else
{
c.lineTo(coords[i][0] * w, coords[i][1] * h);
}
}
if (polyline == false)
{
var closeCurve = (curves.length >= coords.length) ? curves[coords.length - 1] : null;
if (closeCurve != null && closeCurve.length >= 3 && closeCurve[0] === 'Q')
{
c.quadTo(closeCurve[1] * w, closeCurve[2] * h, coords[0][0] * w, coords[0][1] * h);
}
c.close();
}
c.end();
c.fillAndStroke();
}
}
catch (e)
{
// ignore
}
};
mxCellRenderer.registerShape(mxShapeBasicPolygon.prototype.cst.POLYGON, mxShapeBasicPolygon);
mxShapeBasicPolygon.prototype.constraints = null;
// The vertices and the middle of each side (of the curve on a curved side); a
// polyline has no closing side. Lists that are not arrays of number pairs or
// are longer than 100 vertices get no points.
mxShapeBasicPolygon.prototype.getConstraints = function(style, w, h)
{
var constr = [];
try
{
var coords = JSON.parse(mxUtils.getValue(style, 'polyCoords', '[]'));
var curves = JSON.parse(mxUtils.getValue(style, 'polyCurves', '[]'));
var polyline = mxUtils.getValue(style, 'polyline', false);
var isPoint = function(p)
{
return Array.isArray(p) && typeof p[0] === 'number' && typeof p[1] === 'number' &&
isFinite(p[0]) && isFinite(p[1]);
};
if (Array.isArray(coords) && coords.length <= 100 && coords.every(isPoint))
{
var n = coords.length;
var sides = (polyline == false) ? n : n - 1;
curves = (Array.isArray(curves)) ? curves : [];
for (var i = 0; i < n; i++)
{
constr.push(new mxConnectionConstraint(new mxPoint(coords[i][0], coords[i][1]), false));
}
for (var i = 0; i < sides && n > 1; i++)
{
var p0 = coords[i];
var p1 = coords[(i + 1) % n];
var ci = (curves.length > i) ? curves[i] : null;
var mx = (p0[0] + p1[0]) / 2;
var my = (p0[1] + p1[1]) / 2;
if (Array.isArray(ci) && ci.length >= 3 && ci[0] === 'Q' &&
isPoint([ci[1], ci[2]]))
{
mx = (p0[0] + p1[0]) / 4 + ci[1] / 2;
my = (p0[1] + p1[1]) / 4 + ci[2] / 2;
}
constr.push(new mxConnectionConstraint(new mxPoint(mx, my), false));
}
}
}
catch (e)
{
// ignore
}
return constr;
};
(function()
{
function createPolygonHandles(state)
{
var handles = [];
try
{
var coords = JSON.parse(mxUtils.getValue(state.style, 'polyCoords', '[]'));
var curves = JSON.parse(mxUtils.getValue(state.style, 'polyCurves', '[]'));
var polyline = mxUtils.getValue(state.style, 'polyline', 0);
var isPolyline = polyline == 1 || polyline === true || polyline === 'true' || polyline === '1';
var minPoints = isPolyline ? 2 : 3;
// Ignores coordinates that are not arrays, e.g. {"length":1e9}
if (!Array.isArray(coords))
{
return handles;
}
// Ensure curves array matches coords length
while (Array.isArray(curves) && curves.length < coords.length)
{
curves.push([]);
}
// Helper to refresh handler after structural changes
function refreshHandler()
{
var handler = state.view.graph.selectionCellsHandler.getHandler(state.cell);
if (handler != null)
{
handler.refresh(state);
}
}
// Vertex handles (move existing points)
for (var i = 0; i < coords.length; i++)
{
(function(index)
{
var handle = Graph.createHandle(state, ['polyCoords', 'polyCurves'], function(bounds)
{
return new mxPoint(bounds.x + coords[index][0] * bounds.width,
bounds.y + coords[index][1] * bounds.height);
}, function(bounds, pt)
{
var x = Math.round(100000 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100000;
var y = Math.round(100000 * Math.max(0, Math.min(1, (pt.y - bounds.y) / bounds.height))) / 100000;
coords[index] = [x, y];
state.style['polyCoords'] = JSON.stringify(coords);
state.style['polyCurves'] = JSON.stringify(curves);
}, false);
// Collinear removal on mouse up only (not during drag)
var vertexOrigExecute = handle.execute;
handle.execute = function(me)
{
if (coords.length > minPoints)
{
var n = coords.length;
var prevIdx = (index - 1 + n) % n;
var nextIdx = (index + 1) % n;
var canRemove = !isPolyline || (index > 0 && index < n - 1);
if (canRemove)
{
var bounds = this.state.getPaintBounds();
var px = coords[prevIdx][0] * bounds.width;
var py = coords[prevIdx][1] * bounds.height;
var nx = coords[nextIdx][0] * bounds.width;
var ny = coords[nextIdx][1] * bounds.height;
var cx = coords[index][0] * bounds.width;
var cy = coords[index][1] * bounds.height;
if (mxUtils.ptSegDistSq(px, py, nx, ny, cx, cy) < 4)
{
coords.splice(index, 1);
curves.splice(index, 1);
state.style['polyCoords'] = JSON.stringify(coords);
state.style['polyCurves'] = JSON.stringify(curves);
vertexOrigExecute.apply(this, arguments);
refreshHandler();
return;
}
}
}
vertexOrigExecute.apply(this, arguments);
};
handles.push(handle);
})(i);
}
// Control point handles (adjust bezier control points)
for (var i = 0; i < curves.length && i < coords.length; i++)
{
(function(segIndex)
{
if (curves[segIndex] != null && curves[segIndex].length >= 3 && curves[segIndex][0] === 'Q')
{
var cpHandle = Graph.createHandle(state, ['polyCurves'], function(bounds)
{
return new mxPoint(bounds.x + curves[segIndex][1] * bounds.width,
bounds.y + curves[segIndex][2] * bounds.height);
}, function(bounds, pt)
{
var x = Math.round(100000 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100000;
var y = Math.round(100000 * Math.max(0, Math.min(1, (pt.y - bounds.y) / bounds.height))) / 100000;
curves[segIndex] = ['Q', x, y];
state.style['polyCurves'] = JSON.stringify(curves);
}, false);
// Visually distinct: override shape color
var cpOrigRedraw = cpHandle.redraw;
cpHandle.redraw = function()
{
cpOrigRedraw.apply(this, arguments);
if (this.shape != null && this.shape.node != null)
{
this.shape.node.setAttribute('fill', '#fca000');
if (this.shape.node.firstChild != null)
{
this.shape.node.firstChild.setAttribute('fill', '#fca000');
}
}
};
handles.push(cpHandle);
}
})(i);
}
}
catch (e)
{
// ignore
}
return handles;
}
Graph.handleFactory[mxShapeBasicPolygon.prototype.cst.POLYGON] = createPolygonHandles;
})();
//**********************************************************************************************************************************************************
//Rectangle with pattern fill
//**********************************************************************************************************************************************************
/**
* Extends mxShape.
*/
function mxShapeBasicPatternFillRect(bounds, fill, stroke, strokewidth)
{
mxShape.call(this);
this.bounds = bounds;
this.fill = fill;
this.stroke = stroke;
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
this.dx = 0.5;
};
/**
* Extends mxShape.
*/
mxUtils.extend(mxShapeBasicPatternFillRect, mxActor);
mxShapeBasicPatternFillRect.prototype.cst = {PATTERN_FILL_RECT : 'mxgraph.basic.patternFillRect'};
mxShapeBasicPatternFillRect.prototype.customProperties = [
{name: 'step', dispName: 'Fill Step', type: 'float', min:0, defVal:5},
{name: 'fillStyle', dispName: 'Fill Style', type: 'enum', defVal:'none',
enumList:[
{val: 'none', dispName: 'None'},
{val: 'diag', dispName: 'Diagonal'},
{val: 'diagRev', dispName: 'Diagonal Reverse'},
{val: 'vert', dispName: 'Vertical'},
{val: 'hor', dispName: 'Horizontal'},
{val: 'grid', dispName: 'Grid'},
{val: 'diagGrid', dispName: 'Diagonal Grid'}
]},
{name: 'fillStrokeWidth', dispName: 'Fill Stroke Width', type: 'float', min:0, defVal:1},
{name: 'fillStrokeColor', dispName: 'Fill Stroke Color', type: 'color', defVal:'#cccccc'},
{name: 'top', dispName: 'Top Line', type: 'bool', defVal:true},
{name: 'right', dispName: 'Right Line', type: 'bool', defVal:true},
{name: 'bottom', dispName: 'Bottom Line', type: 'bool', defVal:true},
{name: 'left', dispName: 'Left Line', type: 'bool', defVal:true}
];
/**
* Variable: maxLines
*
* Maximum number of lines per direction of the fill. Default is 10000.
*/
mxShapeBasicPatternFillRect.prototype.maxLines = 10000;
/**
* Function: paintVertexShape
*
* Paints the vertex shape.
*/
mxShapeBasicPatternFillRect.prototype.paintVertexShape = function(c, x, y, w, h)
{
c.translate(x, y);
var strokeColor = mxUtils.getValue(this.style, 'strokeColor', '#000000');
var strokeWidth = mxUtils.getValue(this.style, 'strokeWidth', '1');
c.rect(0, 0, w, h);
c.fill();
var fillStrokeColor = mxUtils.getValue(this.style, 'fillStrokeColor', '#cccccc');
var fillStrokeWidth = parseFloat(mxUtils.getValue(this.style, 'fillStrokeWidth', 1));
c.setStrokeColor(fillStrokeColor);
c.setStrokeWidth(fillStrokeWidth);
var step = parseFloat(mxUtils.getValue(this.style, 'step', 5));
var fillStyle = mxUtils.getValue(this.style, 'fillStyle', 'none');
if (fillStyle == 'diag' || fillStyle == 'diagGrid')
{
step = step * 1.41;
var i = 0;
var n = 0;
c.begin();
while (i < (h + w) && n < this.maxLines)
{
var cx = 0;
var cy = 0;
if (i <= h)
{
c.moveTo(0, i);
if(i <= w)
{
c.lineTo(i, 0);
}
else
{
c.lineTo(w, i - w);
}
}
else
{
c.moveTo(i - h, h);
if(i <= w)
{
c.lineTo(i, 0);
}
else
{
c.lineTo(w, i - w);
}
}
i = i + step;
n++;
}
c.stroke();
}
else if (fillStyle == 'vert' || fillStyle == 'grid')
{
c.begin();
var i = 0;
var n = 0;
while (i <= w && n < this.maxLines)
{
var cx = 0;
var cy = 0;
c.moveTo(i, 0);
c.lineTo(i, h);
i = i + step;
n++;
}
c.stroke();
}
if (fillStyle == 'diagRev' || fillStyle == 'diagGrid')
{
if (fillStyle == 'diagRev')
{
step = step * 1.41;
}
var i = 0;
var n = 0;
c.begin();
while (i < (h + w) && n < this.maxLines)
{
var cx = 0;
var cy = 0;
if (i <= h)
{
c.moveTo(w, i);
if(i <= w)
{
c.lineTo(w - i, 0);
}
else
{
c.lineTo(w - w, i - w);
}
}
else
{
c.moveTo(w - i + h, h);
if(i <= w)
{
c.lineTo(w - i, 0);
}
else
{
c.lineTo(0, i - w);
}
}
i = i + step;
n++;
}
c.stroke();
}
else if (fillStyle == 'hor' || fillStyle == 'grid')
{
c.begin();
var i = 0;
var n = 0;
while (i <= h && n < this.maxLines)
{
var cx = 0;
var cy = 0;
c.moveTo(0, i);
c.lineTo(w, i);
i = i + step;
n++;
}
c.stroke();
}
c.setStrokeColor(strokeColor);
c.setStrokeWidth(strokeWidth);
c.begin();
c.moveTo(0, 0);
if (mxUtils.getValue(this.style, 'top', '1') == '1')
{
c.lineTo(w, 0);
}
else
{
c.moveTo(w, 0);
}
if (mxUtils.getValue(this.style, 'right', '1') == '1')
{
c.lineTo(w, h);
}
else
{
c.moveTo(w, h);
}
if (mxUtils.getValue(this.style, 'bottom', '1') == '1')
{
c.lineTo(0, h);
}
else
{
c.moveTo(0, h);
}
if (mxUtils.getValue(this.style, 'left', '1') == '1')
{
c.lineTo(0, 0);
}
c.end();
c.stroke();
};
mxCellRenderer.registerShape(mxShapeBasicPatternFillRect.prototype.cst.PATTERN_FILL_RECT, mxShapeBasicPatternFillRect);
mxShapeBasicPatternFillRect.prototype.getConstraints = function(style, w, h)
{
var constr = [];
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.25), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.75), false));
constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.75, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0.25, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.75), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.25), false));
return (constr);
}