2091 lines
55 KiB
JavaScript
Vendored
2091 lines
55 KiB
JavaScript
Vendored
/**
|
|
* $Id: mxElectrical.js,v 1.0 2016/10/25 17:05:39 mate Exp $
|
|
* Copyright (c) 2006-2016, JGraph Ltd
|
|
*/
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Test Point
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalTestPoint(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(mxShapeElectricalTestPoint, mxShape);
|
|
|
|
mxShapeElectricalTestPoint.prototype.cst = {
|
|
SHAPE_TEST_POINT : 'mxgraph.electrical.transmission.testPoint'
|
|
};
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalTestPoint.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
var strokeColor = mxUtils.getValue(this.style, mxConstants.STYLE_STROKECOLOR, '#000000');
|
|
|
|
var size = Math.min(w, h);
|
|
|
|
c.setFillColor(strokeColor);
|
|
c.begin();
|
|
c.ellipse(w * 0.5 - size / 2, 0, size, size);
|
|
c.fillAndStroke();
|
|
|
|
if (h > w)
|
|
{
|
|
c.begin();
|
|
c.moveTo(w * 0.5, size);
|
|
c.lineTo(w * 0.5, h);
|
|
c.stroke();
|
|
}
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalTestPoint.prototype.cst.SHAPE_TEST_POINT, mxShapeElectricalTestPoint);
|
|
|
|
mxShapeElectricalTestPoint.prototype.constraints = [
|
|
new mxConnectionConstraint(new mxPoint(0.5, 0), true),
|
|
new mxConnectionConstraint(new mxPoint(0.5, 1), true)
|
|
];
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Straight Bus
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalStraightBus(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(mxShapeElectricalStraightBus, mxShape);
|
|
|
|
mxShapeElectricalStraightBus.prototype.cst = {
|
|
SHAPE_STRAIGHT_BUS : 'mxgraph.electrical.transmission.straightBus'
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalStraightBus.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
|
|
var x1 = w * 0.2;
|
|
var y1 = 0;
|
|
|
|
if (w > h)
|
|
{
|
|
y1 = h * 0.5;
|
|
}
|
|
else
|
|
{
|
|
y1 = w / 2;
|
|
}
|
|
|
|
c.begin();
|
|
c.moveTo(w - x1, 0);
|
|
c.lineTo(w - x1, h - y1);
|
|
c.lineTo(w, h - y1);
|
|
c.lineTo(w * 0.5, h);
|
|
c.lineTo(0, h - y1);
|
|
c.lineTo(x1, h - y1);
|
|
c.lineTo(x1, 0);
|
|
c.fillAndStroke();
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalStraightBus.prototype.cst.SHAPE_STRAIGHT_BUS, mxShapeElectricalStraightBus);
|
|
|
|
mxShapeElectricalStraightBus.prototype.constraints = [
|
|
new mxConnectionConstraint(new mxPoint(0.5, 0), true),
|
|
new mxConnectionConstraint(new mxPoint(0.5, 1), true)
|
|
];
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Two-Line Bus Elbow
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalTwoLineBusElbow(bounds, fill, stroke, strokewidth)
|
|
{
|
|
mxShape.call(this);
|
|
this.bounds = bounds;
|
|
this.fill = fill;
|
|
this.stroke = stroke;
|
|
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
|
|
this.notch = 0;
|
|
};
|
|
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
mxUtils.extend(mxShapeElectricalTwoLineBusElbow, mxShape);
|
|
|
|
mxShapeElectricalTwoLineBusElbow.prototype.cst = {
|
|
SHAPE_TWO_LINE_BUS_ELBOW : 'mxgraph.electrical.transmission.twoLineBusElbow'
|
|
};
|
|
|
|
mxShapeElectricalTwoLineBusElbow.prototype.customProperties = [
|
|
{name:'notch', dispName:'Spacing', type:'float', min:0, defVal:25}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalTwoLineBusElbow.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
var notch = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'notch', this.notch))));
|
|
|
|
c.translate(x, y);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h);
|
|
c.lineTo(w, h);
|
|
c.lineTo(w, 0);
|
|
c.stroke();
|
|
|
|
var wn = Math.min(w, notch);
|
|
var hn = Math.min(h, notch);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn);
|
|
c.lineTo(w - wn, h - hn);
|
|
c.lineTo(w - wn, 0);
|
|
c.stroke();
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalTwoLineBusElbow.prototype.cst.SHAPE_TWO_LINE_BUS_ELBOW, mxShapeElectricalTwoLineBusElbow);
|
|
|
|
mxShapeElectricalTwoLineBusElbow.prototype.constraints = null;
|
|
|
|
Graph.handleFactory[mxShapeElectricalTwoLineBusElbow.prototype.cst.SHAPE_TWO_LINE_BUS_ELBOW] = function(state)
|
|
{
|
|
var handles = [Graph.createHandle(state, ['notch'], function(bounds)
|
|
{
|
|
var notch = Math.max(Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))), 0);
|
|
|
|
return new mxPoint(bounds.x + bounds.width / 4, bounds.y + bounds.height - notch);
|
|
}, function(bounds, pt)
|
|
{
|
|
this.state.style['notch'] = Math.round(0.2 * Math.max(0, bounds.width - pt.y + bounds.y)) / 0.2;
|
|
})];
|
|
|
|
return handles;
|
|
|
|
}
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Three-Line Bus Elbow
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalThreeLineBusElbow(bounds, fill, stroke, strokewidth)
|
|
{
|
|
mxShape.call(this);
|
|
this.bounds = bounds;
|
|
this.fill = fill;
|
|
this.stroke = stroke;
|
|
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
|
|
this.notch = 0;
|
|
};
|
|
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
mxUtils.extend(mxShapeElectricalThreeLineBusElbow, mxShape);
|
|
|
|
mxShapeElectricalThreeLineBusElbow.prototype.cst = {
|
|
SHAPE_THREE_LINE_BUS_ELBOW : 'mxgraph.electrical.transmission.threeLineBusElbow'
|
|
};
|
|
|
|
mxShapeElectricalThreeLineBusElbow.prototype.customProperties = [
|
|
{name:'notch', dispName:'Spacing', type:'float', min:0, defVal:30}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalThreeLineBusElbow.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
var notch = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'notch', this.notch))));
|
|
|
|
c.translate(x, y);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h);
|
|
c.lineTo(w, h);
|
|
c.lineTo(w, 0);
|
|
c.stroke();
|
|
|
|
var wn = Math.min(w, notch);
|
|
var hn = Math.min(h, notch);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn);
|
|
c.lineTo(w - wn, h - hn);
|
|
c.lineTo(w - wn, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn / 2);
|
|
c.lineTo(w - wn / 2, h - hn / 2);
|
|
c.lineTo(w - wn / 2, 0);
|
|
c.stroke();
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalThreeLineBusElbow.prototype.cst.SHAPE_THREE_LINE_BUS_ELBOW, mxShapeElectricalThreeLineBusElbow);
|
|
|
|
mxShapeElectricalThreeLineBusElbow.prototype.constraints = null;
|
|
|
|
Graph.handleFactory[mxShapeElectricalThreeLineBusElbow.prototype.cst.SHAPE_THREE_LINE_BUS_ELBOW] = function(state)
|
|
{
|
|
var handles = [Graph.createHandle(state, ['notch'], function(bounds)
|
|
{
|
|
var notch = Math.max(Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))), 0);
|
|
|
|
return new mxPoint(bounds.x + bounds.width / 4, bounds.y + bounds.height - notch);
|
|
}, function(bounds, pt)
|
|
{
|
|
this.state.style['notch'] = Math.round(0.2 * Math.max(0, bounds.width - pt.y + bounds.y)) / 0.2;
|
|
})];
|
|
|
|
return handles;
|
|
|
|
}
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Four-Line Bus Elbow
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalFourLineBusElbow(bounds, fill, stroke, strokewidth)
|
|
{
|
|
mxShape.call(this);
|
|
this.bounds = bounds;
|
|
this.fill = fill;
|
|
this.stroke = stroke;
|
|
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
|
|
this.notch = 0;
|
|
};
|
|
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
mxUtils.extend(mxShapeElectricalFourLineBusElbow, mxShape);
|
|
|
|
mxShapeElectricalFourLineBusElbow.prototype.cst = {
|
|
SHAPE_FOUR_LINE_BUS_ELBOW : 'mxgraph.electrical.transmission.fourLineBusElbow'
|
|
};
|
|
|
|
mxShapeElectricalFourLineBusElbow.prototype.customProperties = [
|
|
{name:'notch', dispName:'Spacing', type:'float', min:0, defVal:75}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalFourLineBusElbow.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
var notch = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'notch', this.notch))));
|
|
|
|
c.translate(x, y);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h);
|
|
c.lineTo(w, h);
|
|
c.lineTo(w, 0);
|
|
c.stroke();
|
|
|
|
var wn = Math.min(w, notch);
|
|
var hn = Math.min(h, notch);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn);
|
|
c.lineTo(w - wn, h - hn);
|
|
c.lineTo(w - wn, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn / 3);
|
|
c.lineTo(w - wn / 3, h - hn / 3);
|
|
c.lineTo(w - wn / 3, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn * 2 / 3);
|
|
c.lineTo(w - wn * 2 / 3, h - hn * 2 / 3);
|
|
c.lineTo(w - wn * 2 / 3, 0);
|
|
c.stroke();
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalFourLineBusElbow.prototype.cst.SHAPE_FOUR_LINE_BUS_ELBOW, mxShapeElectricalFourLineBusElbow);
|
|
|
|
mxShapeElectricalFourLineBusElbow.prototype.constraints = null;
|
|
|
|
Graph.handleFactory[mxShapeElectricalFourLineBusElbow.prototype.cst.SHAPE_FOUR_LINE_BUS_ELBOW] = function(state)
|
|
{
|
|
var handles = [Graph.createHandle(state, ['notch'], function(bounds)
|
|
{
|
|
var notch = Math.max(Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))), 0);
|
|
|
|
return new mxPoint(bounds.x + bounds.width / 4, bounds.y + bounds.height - notch);
|
|
}, function(bounds, pt)
|
|
{
|
|
this.state.style['notch'] = Math.round(0.2 * Math.max(0, bounds.width - pt.y + bounds.y)) / 0.2;
|
|
})];
|
|
|
|
return handles;
|
|
}
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Four-Line Bus Elbow
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalEightLineBusElbow(bounds, fill, stroke, strokewidth)
|
|
{
|
|
mxShape.call(this);
|
|
this.bounds = bounds;
|
|
this.fill = fill;
|
|
this.stroke = stroke;
|
|
this.strokewidth = (strokewidth != null) ? strokewidth : 1;
|
|
this.notch = 0;
|
|
};
|
|
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
mxUtils.extend(mxShapeElectricalEightLineBusElbow, mxShape);
|
|
|
|
mxShapeElectricalEightLineBusElbow.prototype.cst = {
|
|
SHAPE_EIGHT_LINE_BUS_ELBOW : 'mxgraph.electrical.transmission.eightLineBusElbow'
|
|
};
|
|
|
|
mxShapeElectricalEightLineBusElbow.prototype.customProperties = [
|
|
{name:'notch', dispName:'Spacing', type:'float', min:0, defVal:180}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalEightLineBusElbow.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
var notch = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'notch', this.notch))));
|
|
|
|
c.translate(x, y);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h);
|
|
c.lineTo(w, h);
|
|
c.lineTo(w, 0);
|
|
c.stroke();
|
|
|
|
var wn = Math.min(w, notch);
|
|
var hn = Math.min(h, notch);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn);
|
|
c.lineTo(w - wn, h - hn);
|
|
c.lineTo(w - wn, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn / 7);
|
|
c.lineTo(w - wn / 7, h - hn / 7);
|
|
c.lineTo(w - wn / 7, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn * 2 / 7);
|
|
c.lineTo(w - wn * 2 / 7, h - hn * 2 / 7);
|
|
c.lineTo(w - wn * 2 / 7, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn * 3 / 7);
|
|
c.lineTo(w - wn * 3 / 7, h - hn * 3 / 7);
|
|
c.lineTo(w - wn * 3 / 7, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn * 4 / 7);
|
|
c.lineTo(w - wn * 4 / 7, h - hn * 4 / 7);
|
|
c.lineTo(w - wn * 4 / 7, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn * 5 / 7);
|
|
c.lineTo(w - wn * 5 / 7, h - hn * 5 / 7);
|
|
c.lineTo(w - wn * 5 / 7, 0);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(0, h - hn * 6 / 7);
|
|
c.lineTo(w - wn * 6 / 7, h - hn * 6 / 7);
|
|
c.lineTo(w - wn * 6 / 7, 0);
|
|
c.stroke();
|
|
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalEightLineBusElbow.prototype.cst.SHAPE_EIGHT_LINE_BUS_ELBOW, mxShapeElectricalEightLineBusElbow);
|
|
|
|
mxShapeElectricalEightLineBusElbow.prototype.constraints = null;
|
|
|
|
Graph.handleFactory[mxShapeElectricalEightLineBusElbow.prototype.cst.SHAPE_EIGHT_LINE_BUS_ELBOW] = function(state)
|
|
{
|
|
var handles = [Graph.createHandle(state, ['notch'], function(bounds)
|
|
{
|
|
var notch = Math.max(Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))), 0);
|
|
|
|
return new mxPoint(bounds.x + bounds.width / 4, bounds.y + bounds.height - notch);
|
|
}, function(bounds, pt)
|
|
{
|
|
this.state.style['notch'] = Math.round(0.2 * Math.max(0, bounds.width - pt.y + bounds.y)) / 0.2;
|
|
})];
|
|
|
|
return handles;
|
|
}
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Logic Gate
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalLogicGate(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(mxShapeElectricalLogicGate, mxShape);
|
|
|
|
mxShapeElectricalLogicGate.prototype.cst = {
|
|
SHAPE_LOGIC_GATE : 'mxgraph.electrical.logic_gates.logic_gate'
|
|
};
|
|
|
|
mxShapeElectricalLogicGate.prototype.customProperties = [
|
|
{name: 'operation', dispName: 'Operation', type: 'enum', defVal:'and',
|
|
enumList:[
|
|
{val:'and', dispName:'And'},
|
|
{val:'or', dispName:'Or'},
|
|
{val:'xor', dispName:'Xor'}
|
|
]},
|
|
{name: 'numInputs', dispName: 'Inputs', type: 'int', min:2, defVal:2},
|
|
{name: 'negating', dispName: 'Negating', type: 'bool', defVal:0}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalLogicGate.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
var numInputs = parseInt(mxUtils.getValue(this.style, 'numInputs', '2'));
|
|
var spacing = h / numInputs;
|
|
var currH = spacing * 0.5;
|
|
|
|
c.begin();
|
|
c.moveTo(w * 0.8, h * 0.5);
|
|
c.lineTo(w, h * 0.5);
|
|
|
|
var operation = mxUtils.getValue(this.style, 'operation', 'and');
|
|
|
|
for (var i = 0; i < numInputs; i++)
|
|
{
|
|
c.moveTo(0, currH);
|
|
|
|
if (operation == 'and')
|
|
{
|
|
c.lineTo(w * 0.2, currH);
|
|
}
|
|
else
|
|
{
|
|
c.lineTo(w * 0.23, currH);
|
|
}
|
|
|
|
currH = currH + spacing;
|
|
}
|
|
|
|
c.stroke();
|
|
|
|
|
|
switch(operation) {
|
|
case 'xor':
|
|
c.begin();
|
|
c.moveTo(w * 0.1, 0);
|
|
c.arcTo(w * 0.6, h, 0, 0, 1, w * 0.1, h);
|
|
c.stroke();
|
|
//no break operation needed, XOR needs to draw an OR shape too
|
|
case 'or':
|
|
c.begin();
|
|
c.moveTo(w * 0.4, 0);
|
|
c.arcTo(w * 0.45, h * 0.83, 0, 0, 1, w * 0.8, h * 0.5);
|
|
c.arcTo(w * 0.45, h * 0.83, 0, 0, 1, w * 0.4, h);
|
|
c.lineTo(w * 0.15, h);
|
|
c.arcTo(w * 0.6, h, 0, 0, 0, w * 0.15, 0);
|
|
c.close();
|
|
c.fillAndStroke();
|
|
break;
|
|
default:
|
|
c.begin();
|
|
c.moveTo(w * 0.2, 0);
|
|
c.lineTo(w * 0.5, 0);
|
|
c.arcTo(w * 0.3, h * 0.5, 0, 0, 1, w * 0.5, h);
|
|
c.lineTo(w * 0.2, h);
|
|
c.close();
|
|
c.fillAndStroke();
|
|
};
|
|
|
|
|
|
var negating = mxUtils.getValue(this.style, 'negating', '0');
|
|
|
|
if (negating == '1')
|
|
{
|
|
var negSize;
|
|
|
|
if(this.style.negSize)
|
|
{
|
|
var tmpSize = parseFloat(mxUtils.getValue(this.style, 'negSize', '0.13'));
|
|
negSize = Math.min(w * tmpSize * 0.5, h * tmpSize);
|
|
}
|
|
else
|
|
{
|
|
negSize = Math.min(w * 0.04, h * 0.07);
|
|
}
|
|
|
|
c.begin();
|
|
c.ellipse(w * 0.8, h * 0.5 - negSize * 0.5, negSize, negSize);
|
|
c.fillAndStroke();
|
|
}
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalLogicGate.prototype.cst.SHAPE_LOGIC_GATE, mxShapeElectricalLogicGate);
|
|
|
|
mxShapeElectricalLogicGate.prototype.getConstraints = function(style)
|
|
{
|
|
var constr = [new mxConnectionConstraint(new mxPoint(1, 0.5), false)];
|
|
|
|
var numInputs = parseInt(mxUtils.getValue(style, 'numInputs', '2'));
|
|
var spacing = 1 / numInputs;
|
|
var currH = spacing * 0.5;
|
|
|
|
for (var i = 0; i < numInputs; i++)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, currH), false));
|
|
currH = currH + spacing;
|
|
}
|
|
|
|
return (constr);
|
|
}
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Buffer
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalBuffer(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(mxShapeElectricalBuffer, mxShape);
|
|
|
|
mxShapeElectricalBuffer.prototype.cst = {
|
|
SHAPE_BUFFER2 : 'mxgraph.electrical.logic_gates.buffer2'
|
|
};
|
|
|
|
mxShapeElectricalBuffer.prototype.customProperties = [
|
|
{name: 'negating', dispName: 'Negating', type: 'bool', defVal:0}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalBuffer.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
|
|
c.begin();
|
|
c.moveTo(0, h * 0.5);
|
|
c.lineTo(w * 0.2, h * 0.5);
|
|
c.moveTo(w * 0.8, h * 0.5);
|
|
c.lineTo(w, h * 0.5);
|
|
c.stroke();
|
|
|
|
c.begin();
|
|
c.moveTo(w * 0.2, 0);
|
|
c.lineTo(w * 0.8, h * 0.5);
|
|
c.lineTo(w * 0.2, h);
|
|
c.close();
|
|
c.fillAndStroke();
|
|
|
|
var negating = mxUtils.getValue(this.style, 'negating', '0');
|
|
|
|
if (negating == '1')
|
|
{
|
|
var negSize = Math.min(w * 0.04, h * 0.07);
|
|
c.begin();
|
|
c.ellipse(w * 0.8, h * 0.5 - negSize * 0.5, negSize, negSize);
|
|
c.fillAndStroke();
|
|
}
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalBuffer.prototype.cst.SHAPE_BUFFER2, mxShapeElectricalBuffer);
|
|
|
|
mxShapeElectricalBuffer.prototype.constraints = [
|
|
new mxConnectionConstraint(new mxPoint(0, 0.5), true),
|
|
new mxConnectionConstraint(new mxPoint(1, 0.5), true)
|
|
];
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Dual In-Line IC
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalDualInLineIC(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(mxShapeElectricalDualInLineIC, mxShape);
|
|
|
|
mxShapeElectricalDualInLineIC.prototype.cst = {
|
|
SHAPE_DUAL_INLINE_IC : 'mxgraph.electrical.logic_gates.dual_inline_ic'
|
|
};
|
|
|
|
mxShapeElectricalDualInLineIC.prototype.customProperties = [
|
|
{name: 'pinStyle', dispName: 'Pin Style', type: 'enum', defVal:'line',
|
|
enumList:[
|
|
{val:'line', dispName:'Line'},
|
|
{val:'square', dispName:'Square'}
|
|
]},
|
|
{name: 'startPin', dispName: 'Starting Pin', type: 'enum', defVal:'n',
|
|
enumList:[
|
|
{val:'n', dispName:'N'},
|
|
{val:'e', dispName:'E'},
|
|
{val:'s', dispName:'S'},
|
|
{val:'w', dispName:'W'}
|
|
]},
|
|
{name: 'pinSpacing', dispName: 'Pin Spacing', type: 'float', min:1, defVal:20},
|
|
{name: 'pinLabelType', dispName: 'Pin Label Type', type: 'enum', defVal:'gen',
|
|
enumList:[
|
|
{val:'gen', dispName:'Generated'},
|
|
{val:'cust', dispName:'Custom'}
|
|
]},
|
|
{name: 'labelCount', dispName: 'Number of Labels', type: 'int', defVal: 20, dependentProps: ['labelNames']},
|
|
{name: 'labelNames', dispName: 'Label Names', type: 'staticArr', subType: 'string', sizeProperty: 'labelCount', subDefVal: 'a'}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalDualInLineIC.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
var fontColor = mxUtils.getValue(this.style, 'fontColor', '#000000');
|
|
c.setFontColor(fontColor);
|
|
var startPin = mxUtils.getValue(this.style, 'startPin', 'n');
|
|
var pinLabelType = mxUtils.getValue(this.style, 'pinLabelType', 'gen');
|
|
var labelNames = decodeURIComponent(mxUtils.getValue(this.style, 'labelNames', '').toString()).split(',');
|
|
|
|
c.begin();
|
|
|
|
if (startPin == 'n' || startPin == 's')
|
|
{
|
|
c.rect(10, 0, w - 20, h);
|
|
}
|
|
else
|
|
{
|
|
c.rect(0, 10, w, h - 20);
|
|
}
|
|
|
|
c.fillAndStroke();
|
|
|
|
var pinSpacing = parseFloat(mxUtils.getValue(this.style, 'pinSpacing', '20'));
|
|
var pinStyle = mxUtils.getValue(this.style, 'pinStyle', 'line');
|
|
var fontSize = parseFloat(mxUtils.getValue(this.style, 'fontSize', '12'));
|
|
|
|
if (startPin == 'n' || startPin == 's')
|
|
{
|
|
var pinsOne = parseInt(h / pinSpacing);
|
|
}
|
|
else
|
|
{
|
|
var pinsOne = parseInt(w / pinSpacing);
|
|
}
|
|
|
|
if (pinStyle == 'line')
|
|
{
|
|
c.setFontSize(fontSize * 0.8);
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5;
|
|
|
|
c.begin();
|
|
|
|
if (startPin == 'n' || startPin == 's')
|
|
{
|
|
while (pinCount * pinSpacing <= h)
|
|
{
|
|
c.moveTo(0, currH);
|
|
c.lineTo(10, currH);
|
|
c.moveTo(w - 10, currH);
|
|
c.lineTo(w, currH);
|
|
|
|
if (startPin == 'n')
|
|
{
|
|
var currPinNum = pinCount;
|
|
}
|
|
else
|
|
{
|
|
var currPinNum = pinsOne + pinCount;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(20, currH, 0, 0, currPinNum.toString(), mxConstants.ALIGN_LEFT, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (currPinNum - 1 < labelNames.length)
|
|
{
|
|
c.text(20, currH, 0, 0, labelNames[currPinNum - 1].toString(), mxConstants.ALIGN_LEFT, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
if (startPin == 'n')
|
|
{
|
|
var pc2 = 2 * pinsOne - pinCount + 1;
|
|
}
|
|
else
|
|
{
|
|
var pc2 = pinsOne - pinCount + 1;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(w - 20, currH, 0, 0, pc2.toString(), mxConstants.ALIGN_RIGHT, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (pc2 - 1 < labelNames.length)
|
|
{
|
|
c.text(w - 20, currH, 0, 0, labelNames[pc2 - 1].toString(), mxConstants.ALIGN_RIGHT, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (pinCount * pinSpacing <= w)
|
|
{
|
|
c.moveTo(currH, 0);
|
|
c.lineTo(currH, 10);
|
|
c.moveTo(currH, h - 10);
|
|
c.lineTo(currH, h);
|
|
|
|
if (startPin == 'e')
|
|
{
|
|
var currPinNum = pinsOne - pinCount + 1;
|
|
}
|
|
else
|
|
{
|
|
var currPinNum = 2 * pinsOne - pinCount + 1;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(currH, 20, 0, 0, currPinNum.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (currPinNum - 1 < labelNames.length)
|
|
{
|
|
c.text(currH, 20, 0, 0, labelNames[currPinNum - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
if (startPin == 'e')
|
|
{
|
|
var pc2 = pinsOne + pinCount;
|
|
}
|
|
else
|
|
{
|
|
var pc2 = pinCount;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(currH, h - 20, 0, 0, pc2.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (pc2 - 1 < labelNames.length)
|
|
{
|
|
c.text(currH, h - 20, 0, 0, labelNames[pc2 - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
}
|
|
|
|
c.stroke();
|
|
}
|
|
else
|
|
{
|
|
c.setFontSize(fontSize * 0.5);
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5;
|
|
|
|
if (startPin == 'n' || startPin == 's')
|
|
{
|
|
while (pinCount * pinSpacing <= h)
|
|
{
|
|
c.begin();
|
|
c.rect(0, currH - pinSpacing * 0.25, 10, pinSpacing * 0.5);
|
|
c.fillAndStroke();
|
|
|
|
c.begin();
|
|
c.rect(w - 10, currH - pinSpacing * 0.25, 10, pinSpacing * 0.5);
|
|
c.fillAndStroke();
|
|
|
|
if (startPin == 'n')
|
|
{
|
|
var currPinNum = pinCount;
|
|
}
|
|
else
|
|
{
|
|
var currPinNum = pinsOne + pinCount;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(5, currH + 1, 0, 0, currPinNum.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (currPinNum - 1 < labelNames.length)
|
|
{
|
|
c.text(5, currH + 1, 0, 0, labelNames[currPinNum - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
if (startPin == 'n')
|
|
{
|
|
var pc2 = 2 * pinsOne - pinCount + 1;
|
|
}
|
|
else
|
|
{
|
|
var pc2 = pinsOne - pinCount + 1;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(w - 5, currH + 1, 0, 0, pc2.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (pc2 - 1 < labelNames.length)
|
|
{
|
|
c.text(w - 5, currH + 1, 0, 0, labelNames[pc2 - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (pinCount * pinSpacing <= w)
|
|
{
|
|
c.begin();
|
|
c.rect(currH - pinSpacing * 0.25, 0, pinSpacing * 0.5, 10);
|
|
c.fillAndStroke();
|
|
|
|
c.begin();
|
|
c.rect(currH - pinSpacing * 0.25, h - 10, pinSpacing * 0.5, 10);
|
|
c.fillAndStroke();
|
|
|
|
if (startPin == 'e')
|
|
{
|
|
var currPinNum = pinsOne - pinCount + 1;
|
|
}
|
|
else
|
|
{
|
|
var currPinNum = 2 * pinsOne - pinCount + 1;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(currH, 5, 0, 0, currPinNum.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (currPinNum - 1 < labelNames.length)
|
|
{
|
|
c.text(currH, 5, 0, 0, labelNames[currPinNum - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
if (startPin == 'e')
|
|
{
|
|
var pc2 = pinsOne + pinCount;
|
|
}
|
|
else
|
|
{
|
|
var pc2 = pinCount;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(currH, h - 5, 0, 0, pc2.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (pc2 - 1 < labelNames.length)
|
|
{
|
|
c.text(currH, h - 5, 0, 0, labelNames[pc2 - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
c.setShadow(false);
|
|
|
|
c.begin();
|
|
|
|
switch(startPin) {
|
|
case 'e':
|
|
if (h > 40)
|
|
{
|
|
c.moveTo(w, h * 0.5 - 10);
|
|
c.arcTo(12, 12, 0, 0, 0, w, h * 0.5 + 10);
|
|
}
|
|
break;
|
|
case 's':
|
|
if (w > 40)
|
|
{
|
|
c.moveTo(w * 0.5 - 10, h);
|
|
c.arcTo(12, 12, 0, 0, 1, w * 0.5 + 10, h);
|
|
}
|
|
break;
|
|
case 'w':
|
|
if (h > 40)
|
|
{
|
|
c.moveTo(0, h * 0.5 - 10);
|
|
c.arcTo(12, 12, 0, 0, 1, 0, h * 0.5 + 10);
|
|
}
|
|
break;
|
|
default:
|
|
if (w > 40)
|
|
{
|
|
c.moveTo(w * 0.5 - 10, 0);
|
|
c.arcTo(12, 12, 0, 0, 0, w * 0.5 + 10, 0);
|
|
}
|
|
}
|
|
|
|
c.stroke();
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalDualInLineIC.prototype.cst.SHAPE_DUAL_INLINE_IC, mxShapeElectricalDualInLineIC);
|
|
|
|
mxShapeElectricalDualInLineIC.prototype.getConstraints = function(style, w, h)
|
|
{
|
|
var constr = [];
|
|
|
|
var pinSpacing = parseFloat(mxUtils.getValue(this.style, 'pinSpacing', '20'));
|
|
var startPin = mxUtils.getValue(this.style, 'startPin', 'n');
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5;
|
|
var pinsOne = parseInt(h / pinSpacing);
|
|
|
|
if (startPin == 'n' || startPin == 's')
|
|
{
|
|
while (pinCount * pinSpacing <= h)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, currH));
|
|
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, 0, currH));
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (pinCount * pinSpacing <= w)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, currH, 0));
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, currH, 0));
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
}
|
|
|
|
return (constr);
|
|
}
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Quad Flat Package IC
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalQFPIC(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(mxShapeElectricalQFPIC, mxShape);
|
|
|
|
mxShapeElectricalQFPIC.prototype.cst = {
|
|
SHAPE_QFP_IC : 'mxgraph.electrical.logic_gates.qfp_ic'
|
|
};
|
|
|
|
mxShapeElectricalQFPIC.prototype.customProperties = [
|
|
{name: 'pinStyle', dispName: 'Pin Style', type: 'enum', defVal:'line',
|
|
enumList:[
|
|
{val:'line', dispName:'Line'},
|
|
{val:'square', dispName:'Square'}
|
|
]},
|
|
{name: 'startPin', dispName: 'Starting Pin', type: 'enum', defVal:'sw',
|
|
enumList:[
|
|
{val:'sw', dispName:'SW'},
|
|
{val:'nw', dispName:'NW'},
|
|
{val:'ne', dispName:'NE'},
|
|
{val:'se', dispName:'SE'}
|
|
]},
|
|
{name: 'pinSpacing', dispName: 'Pin Spacing', type: 'float', min:1, defVal:20},
|
|
{name: 'pinLabelType', dispName: 'Pin Label Type', type: 'enum', defVal:'gen',
|
|
enumList:[
|
|
{val:'gen', dispName:'Generated'},
|
|
{val:'cust', dispName:'Custom'}
|
|
]},
|
|
{name: 'labelCount', dispName: 'Number of Labels', type: 'int', defVal: 40, dependentProps: ['labelNames']},
|
|
{name: 'labelNames', dispName: 'Label Names', type: 'staticArr', subType: 'string', sizeProperty: 'labelCount', subDefVal: 'a'}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalQFPIC.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
|
|
c.begin();
|
|
c.moveTo(15, 10);
|
|
c.lineTo(w - 15, 10);
|
|
c.lineTo(w - 10, 15);
|
|
c.lineTo(w - 10, h - 15);
|
|
c.lineTo(w - 15, h - 10);
|
|
c.lineTo(15, h - 10);
|
|
c.lineTo(10, h - 15);
|
|
c.lineTo(10, 15);
|
|
c.close();
|
|
c.fillAndStroke();
|
|
|
|
var pinSpacing = parseFloat(mxUtils.getValue(this.style, 'pinSpacing', '20'));
|
|
var pinStyle = mxUtils.getValue(this.style, 'pinStyle', 'line');
|
|
var pinLabelType = mxUtils.getValue(this.style, 'pinLabelType', 'gen');
|
|
var labelNames = decodeURIComponent(mxUtils.getValue(this.style, 'labelNames', '').toString()).split(',');
|
|
var fontSize = parseFloat(mxUtils.getValue(this.style, 'fontSize', '12'));
|
|
var fontColor = mxUtils.getValue(this.style, 'fontColor', '#000000');
|
|
c.setFontColor(fontColor);
|
|
var startPin = mxUtils.getValue(this.style, 'startPin', 'sw');
|
|
|
|
if (pinStyle == 'line')
|
|
{
|
|
c.setFontSize(fontSize * 0.8);
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5 + 20;
|
|
|
|
c.begin();
|
|
|
|
var pinsVOne = parseInt((h - pinSpacing - 40) / pinSpacing) + 1;
|
|
var pinsHOne = parseInt((w - pinSpacing - 40) / pinSpacing) + 1;
|
|
|
|
while (currH <= h - pinSpacing * 0.5 - 20)
|
|
{
|
|
c.moveTo(0, currH);
|
|
c.lineTo(10, currH);
|
|
c.moveTo(w - 10, currH);
|
|
c.lineTo(w, currH);
|
|
|
|
//west pins
|
|
switch(startPin) {
|
|
case 'nw':
|
|
var currPinNum = pinCount;
|
|
break;
|
|
case 'ne':
|
|
var currPinNum = pinsHOne + pinCount;
|
|
break;
|
|
case 'se':
|
|
var currPinNum = pinsVOne + pinsHOne + pinCount;
|
|
break;
|
|
default:
|
|
var currPinNum = pinsVOne + 2 * pinsHOne + pinCount;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(20, currH, 0, 0, currPinNum.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (currPinNum - 1 < labelNames.length)
|
|
{
|
|
c.text(20, currH, 0, 0, labelNames[currPinNum - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
//east pins
|
|
switch(startPin) {
|
|
case 'nw':
|
|
var pc2 = pinsHOne + 2 * pinsVOne - pinCount + 1;
|
|
break;
|
|
case 'ne':
|
|
var pc2 = 2 * pinsHOne + 2 * pinsVOne - pinCount + 1;
|
|
break;
|
|
case 'se':
|
|
var pc2 = pinsVOne - pinCount + 1;
|
|
break;
|
|
default:
|
|
var pc2 = pinsHOne + pinsVOne - pinCount + 1;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(w - 20, currH, 0, 0, pc2.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (pc2 - 1 < labelNames.length)
|
|
{
|
|
c.text(w - 20, currH, 0, 0, labelNames[pc2 - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5 + 20;
|
|
|
|
while (currH <= w - pinSpacing * 0.5 - 20)
|
|
{
|
|
c.moveTo(currH, 0);
|
|
c.lineTo(currH, 10);
|
|
c.moveTo(currH, h - 10);
|
|
c.lineTo(currH, h);
|
|
|
|
//south pins
|
|
switch(startPin) {
|
|
case 'nw':
|
|
var currPinNum = pinsVOne + pinCount;
|
|
break;
|
|
case 'ne':
|
|
var currPinNum = pinsVOne + pinsHOne + pinCount;
|
|
break;
|
|
case 'se':
|
|
var currPinNum = 2 * pinsVOne + pinsHOne + pinCount;
|
|
break;
|
|
default:
|
|
var currPinNum = pinCount;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(currH, h - 20, 0, 0, currPinNum.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (currPinNum - 1 < labelNames.length)
|
|
{
|
|
c.text(currH, h - 20, 0, 0, labelNames[currPinNum - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
//north pins
|
|
switch(startPin) {
|
|
case 'nw':
|
|
var pc2 = 2 * pinsHOne + 2 * pinsVOne - pinCount + 1;
|
|
break;
|
|
case 'ne':
|
|
var pc2 = pinsHOne - pinCount + 1;
|
|
break;
|
|
case 'se':
|
|
var pc2 = pinsHOne + pinsVOne - pinCount + 1;
|
|
break;
|
|
default:
|
|
var pc2 = 2 * pinsHOne + pinsVOne - pinCount + 1;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(currH, 20, 0, 0, pc2.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (pc2 - 1 < labelNames.length)
|
|
{
|
|
c.text(currH, 20, 0, 0, labelNames[pc2 - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
|
|
c.stroke();
|
|
}
|
|
else
|
|
{
|
|
c.setFontSize(fontSize * 0.5);
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5 + 20;
|
|
var pinsVOne = parseInt((h - pinSpacing - 40) / pinSpacing) + 1;
|
|
var pinsHOne = parseInt((w - pinSpacing - 40) / pinSpacing) + 1;
|
|
|
|
while (currH <= h - pinSpacing * 0.5 - 20)
|
|
{
|
|
c.begin();
|
|
c.rect(0, currH - pinSpacing * 0.25, 10, pinSpacing * 0.5);
|
|
c.fillAndStroke();
|
|
|
|
c.begin();
|
|
c.rect(w - 10, currH - pinSpacing * 0.25, 10, pinSpacing * 0.5);
|
|
c.fillAndStroke();
|
|
|
|
//west pins
|
|
switch(startPin) {
|
|
case 'nw':
|
|
var currPinNum = pinCount;
|
|
break;
|
|
case 'ne':
|
|
var currPinNum = pinsHOne + pinCount;
|
|
break;
|
|
case 'se':
|
|
var currPinNum = pinsVOne + pinsHOne + pinCount;
|
|
break;
|
|
default:
|
|
var currPinNum = pinsVOne + 2 * pinsHOne + pinCount;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(5, currH + 1, 0, 0, currPinNum.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (currPinNum - 1 < labelNames.length)
|
|
{
|
|
c.text(5, currH + 1, 0, 0, labelNames[currPinNum - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
//east pins
|
|
switch(startPin) {
|
|
case 'nw':
|
|
var pc2 = pinsHOne + 2 * pinsVOne - pinCount + 1;
|
|
break;
|
|
case 'ne':
|
|
var pc2 = 2 * pinsHOne + 2 * pinsVOne - pinCount + 1;
|
|
break;
|
|
case 'se':
|
|
var pc2 = pinsVOne - pinCount + 1;
|
|
break;
|
|
default:
|
|
var pc2 = pinsHOne + pinsVOne - pinCount + 1;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(w - 5, currH + 1, 0, 0, pc2.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (pc2 - 1 < labelNames.length)
|
|
{
|
|
c.text(w - 5, currH + 1, 0, 0, labelNames[pc2 - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5 + 20;
|
|
|
|
while (currH <= w - pinSpacing * 0.5 - 20)
|
|
{
|
|
c.begin();
|
|
c.rect(currH - pinSpacing * 0.25, 0, pinSpacing * 0.5, 10);
|
|
c.fillAndStroke();
|
|
|
|
c.begin();
|
|
c.rect(currH - pinSpacing * 0.25, h - 10, pinSpacing * 0.5, 10);
|
|
c.fillAndStroke();
|
|
|
|
//south pins
|
|
switch(startPin) {
|
|
case 'nw':
|
|
var currPinNum = pinsVOne + pinCount;
|
|
break;
|
|
case 'ne':
|
|
var currPinNum = pinsVOne + pinsHOne + pinCount;
|
|
break;
|
|
case 'se':
|
|
var currPinNum = 2 * pinsVOne + pinsHOne + pinCount;
|
|
break;
|
|
default:
|
|
var currPinNum = pinCount;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(currH, h - 4, 0, 0, currPinNum.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (currPinNum - 1 < labelNames.length)
|
|
{
|
|
c.text(currH, h - 4, 0, 0, labelNames[currPinNum - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
//north pins
|
|
switch(startPin) {
|
|
case 'nw':
|
|
var pc2 = 2 * pinsHOne + 2 * pinsVOne - pinCount + 1;
|
|
break;
|
|
case 'ne':
|
|
var pc2 = pinsHOne - pinCount + 1;
|
|
break;
|
|
case 'se':
|
|
var pc2 = pinsHOne + pinsVOne - pinCount + 1;
|
|
break;
|
|
default:
|
|
var pc2 = 2 * pinsHOne + pinsVOne - pinCount + 1;
|
|
}
|
|
|
|
if (pinLabelType == 'gen')
|
|
{
|
|
c.text(currH, 6, 0, 0, pc2.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
else if (pc2 - 1 < labelNames.length)
|
|
{
|
|
c.text(currH, 6, 0, 0, labelNames[pc2 - 1].toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, 0);
|
|
}
|
|
|
|
currH = currH + pinSpacing;
|
|
pinCount++;
|
|
}
|
|
}
|
|
|
|
c.setShadow(false);
|
|
|
|
if (w > 40)
|
|
{
|
|
c.setFillColor(mxUtils.getValue(this.style, 'strokeColor', '#000000'));
|
|
|
|
c.begin();
|
|
|
|
switch(startPin) {
|
|
case 'nw':
|
|
c.ellipse(15, 15, 10, 10);
|
|
break;
|
|
case 'ne':
|
|
c.ellipse(w - 25, 15, 10, 10);
|
|
break;
|
|
case 'se':
|
|
c.ellipse(w - 25, h - 25, 10, 10);
|
|
break;
|
|
default:
|
|
c.ellipse(15, h - 25, 10, 10);
|
|
}
|
|
|
|
c.fillAndStroke();
|
|
}
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalQFPIC.prototype.cst.SHAPE_QFP_IC, mxShapeElectricalQFPIC);
|
|
|
|
mxShapeElectricalQFPIC.prototype.getConstraints = function(style, w, h)
|
|
{
|
|
var constr = [];
|
|
|
|
var pinSpacing = parseFloat(mxUtils.getValue(this.style, 'pinSpacing', '20'));
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5 + 20;
|
|
|
|
var pinsOne = parseInt(h / pinSpacing);
|
|
|
|
while (currH <= h - pinSpacing * 0.5 - 20)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, currH));
|
|
constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, 0, currH));
|
|
currH = currH + pinSpacing;
|
|
}
|
|
|
|
var pinCount = 1;
|
|
var currH = pinSpacing * 0.5 + 20;
|
|
|
|
while (currH <= w - pinSpacing * 0.5 - 20)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, currH, 0));
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, currH, 0));
|
|
currH = currH + pinSpacing;
|
|
}
|
|
|
|
|
|
return (constr);
|
|
}
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Mux
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalMux(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(mxShapeElectricalMux, mxShape);
|
|
|
|
mxShapeElectricalMux.prototype.cst = {
|
|
SHAPE_MUX : 'mxgraph.electrical.abstract.mux2'
|
|
};
|
|
|
|
mxShapeElectricalMux.prototype.customProperties = [
|
|
{name: 'operation', dispName: 'Operation', type: 'enum', defVal:'mux',
|
|
enumList:[
|
|
{val:'mux', dispName:'Mux'},
|
|
{val:'demux', dispName:'Demux'}
|
|
]},
|
|
{name: 'selectorPins', dispName: 'Selector Pins', type: 'int', min:1, max:8, defVal:1},
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalMux.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
var selectorPins = parseInt(mxUtils.getValue(this.style, 'selectorPins', '1'));
|
|
var operation = mxUtils.getValue(this.style, 'operation', 'mux');
|
|
var fontSize = parseFloat(mxUtils.getValue(this.style, 'fontSize', '12'));
|
|
c.setFontSize(fontSize * 0.5);
|
|
var fontColor = mxUtils.getValue(this.style, 'fontColor', '#000000');
|
|
c.setFontColor(fontColor);
|
|
var dir = mxUtils.getValue(this.style, 'direction', 'east');
|
|
var txtRot = 0;
|
|
|
|
switch(dir)
|
|
{
|
|
case 'south' :
|
|
txtRot = 270;
|
|
break;
|
|
case 'west' :
|
|
txtRot = 180;
|
|
break;
|
|
case 'north' :
|
|
txtRot = 90;
|
|
break;
|
|
}
|
|
|
|
switch(operation)
|
|
{
|
|
case 'demux':
|
|
c.begin();
|
|
c.moveTo(w - 10, 0);
|
|
c.lineTo(10, h * 0.1);
|
|
c.lineTo(10, h * 0.9 - 10);
|
|
c.lineTo(w - 10, h - 10);
|
|
c.close();
|
|
c.fillAndStroke();
|
|
break;
|
|
default:
|
|
c.begin();
|
|
c.moveTo(10, 0);
|
|
c.lineTo(w - 10, h * 0.1);
|
|
c.lineTo(w - 10, h * 0.9 - 10);
|
|
c.lineTo(10, h - 10);
|
|
c.close();
|
|
c.fillAndStroke();
|
|
};
|
|
|
|
var numInputs = 1;
|
|
var numOutputs = 1;
|
|
|
|
if (operation == 'mux')
|
|
{
|
|
numInputs = Math.pow(2, selectorPins);
|
|
var spacing = (h - 16) / numInputs;
|
|
}
|
|
else
|
|
{
|
|
numOutputs = Math.pow(2, selectorPins);
|
|
var spacing = (h - 16) / numOutputs;
|
|
}
|
|
|
|
var currH = 3 + spacing * 0.5;
|
|
|
|
c.begin();
|
|
|
|
if (numInputs == 1)
|
|
{
|
|
c.moveTo(0, (h - 10) * 0.5);
|
|
c.lineTo(10, (h - 10) * 0.5);
|
|
}
|
|
else
|
|
{
|
|
for (var i = 0; i < numInputs; i++)
|
|
{
|
|
c.moveTo(0, currH);
|
|
c.lineTo(10, currH);
|
|
c.text(14, currH + 1, 0, 0, '' + i.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, txtRot);
|
|
currH = currH + spacing;
|
|
}
|
|
}
|
|
|
|
if (numOutputs == 1)
|
|
{
|
|
c.moveTo(w - 10, (h - 10) * 0.5);
|
|
c.lineTo(w, (h - 10) * 0.5);
|
|
}
|
|
else
|
|
{
|
|
for (var i = 0; i < numOutputs; i++)
|
|
{
|
|
c.moveTo(w - 10, currH);
|
|
c.lineTo(w, currH);
|
|
c.text(w - 14, currH + 1, 0, 0, '' + i.toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, txtRot);
|
|
currH = currH + spacing;
|
|
}
|
|
}
|
|
|
|
var spacing = (w - 20) / selectorPins;
|
|
var currW = 10 + spacing * 0.5;
|
|
|
|
for (var i = 0; i < selectorPins; i++)
|
|
{
|
|
if (operation == 'mux')
|
|
{
|
|
c.moveTo(currW, h - 10 - (currW - 10) / (w - 20) * h * 0.1);
|
|
}
|
|
else
|
|
{
|
|
c.moveTo(currW, h - 10 - (w - currW - 10) / (w - 20) * h * 0.1);
|
|
}
|
|
|
|
c.lineTo(currW, h);
|
|
|
|
c.text(currW + 5, h -4, 0, 0, 'S' + (selectorPins - i - 1).toString(), mxConstants.ALIGN_CENTER, mxConstants.ALIGN_MIDDLE, 0, null, 0, 0, txtRot);
|
|
currW = currW + spacing;
|
|
}
|
|
|
|
c.stroke();
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalMux.prototype.cst.SHAPE_MUX, mxShapeElectricalMux);
|
|
|
|
mxShapeElectricalMux.prototype.getConstraints = function(style, w, h)
|
|
{
|
|
var constr = [];
|
|
var pinRange = (h - 16) / h;
|
|
var selectorPins = parseInt(mxUtils.getValue(this.style, 'selectorPins', '1'));
|
|
var operation = mxUtils.getValue(this.style, 'operation', 'mux');
|
|
|
|
var numInputs = 1;
|
|
var numOutputs = 1;
|
|
|
|
if (operation == 'mux')
|
|
{
|
|
numInputs = Math.pow(2, selectorPins);
|
|
var spacing = pinRange / numInputs;
|
|
}
|
|
else
|
|
{
|
|
numOutputs = Math.pow(2, selectorPins);
|
|
var spacing = pinRange / numOutputs;
|
|
}
|
|
|
|
var currH = spacing * 0.5;
|
|
|
|
if (numInputs == 1)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5 * (h - 10) / h), false, 0, 0));
|
|
}
|
|
else
|
|
{
|
|
for (var i = 0; i < numInputs; i++)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(0, currH), false, null, 0, 3));
|
|
currH = currH + spacing;
|
|
}
|
|
}
|
|
|
|
if (numOutputs == 1)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false, null, 0, -5));
|
|
}
|
|
else
|
|
{
|
|
for (var i = 0; i < numOutputs; i++)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(1, currH), false, null, 0, 3));
|
|
currH = currH + spacing;
|
|
}
|
|
}
|
|
|
|
var spacing = (w - 20) / (w * selectorPins);
|
|
var currW = spacing * 0.5;
|
|
|
|
for (var i = 0; i < selectorPins; i++)
|
|
{
|
|
constr.push(new mxConnectionConstraint(new mxPoint(currW, 1), false, null, 10, 0));
|
|
currW = currW + spacing;
|
|
}
|
|
|
|
return (constr);
|
|
}
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Battery stack
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalBatteryStack(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(mxShapeElectricalBatteryStack, mxShape);
|
|
|
|
mxShapeElectricalBatteryStack.prototype.cst = {
|
|
SHAPE_BATTERY_STACK : 'mxgraph.electrical.miscellaneous.batteryStack'
|
|
};
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalBatteryStack.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
|
|
var bw = h * 0.3;
|
|
var strokeColor = mxUtils.getValue(this.style, mxConstants.STYLE_STROKECOLOR, '#000000');
|
|
var dashed = mxUtils.getValue(this.style, mxConstants.STYLE_DASHED, '0');
|
|
|
|
var bNum = Math.floor((w - 20) / bw);
|
|
var startX = (w - bNum * bw) * 0.5;
|
|
|
|
if (bNum > 0)
|
|
{
|
|
c.begin();
|
|
c.moveTo(0, h * 0.5);
|
|
c.lineTo(startX + bw * 0.2, h * 0.5);
|
|
c.moveTo(w - startX - bw * 0.2, h * 0.5);
|
|
c.lineTo(w, h * 0.5);
|
|
c.stroke();
|
|
|
|
var currX = startX;
|
|
c.setFillColor(strokeColor);
|
|
|
|
for (var i = 0; i < bNum; i++)
|
|
{
|
|
|
|
c.rect(currX + bw * 0.2, h * 0.25, bw * 0.2, h * 0.5);
|
|
c.fillAndStroke();
|
|
|
|
c.begin();
|
|
c.moveTo(currX + bw * 0.8, 0);
|
|
c.lineTo(currX + bw * 0.8, h);
|
|
c.stroke();
|
|
|
|
if (i > 0)
|
|
{
|
|
c.setDashed('1');
|
|
c.begin();
|
|
c.moveTo(currX - bw * 0.2, h * 0.5);
|
|
c.lineTo(currX + bw * 0.2, h * 0.5);
|
|
c.stroke();
|
|
c.setDashed(dashed);
|
|
}
|
|
|
|
currX = currX + bw;
|
|
}
|
|
}
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalBatteryStack.prototype.cst.SHAPE_BATTERY_STACK, mxShapeElectricalBatteryStack);
|
|
|
|
mxShapeElectricalBatteryStack.prototype.constraints = [
|
|
new mxConnectionConstraint(new mxPoint(0, 0.5), true),
|
|
new mxConnectionConstraint(new mxPoint(1, 0.5), true)
|
|
];
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//DC Source 3 v2
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalDCSource3_v2(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(mxShapeElectricalDCSource3_v2, mxShape);
|
|
|
|
mxShapeElectricalDCSource3_v2.prototype.cst = {
|
|
SHAPE_DC_SOURCE_3_V2 : 'mxgraph.electrical.signal_sources.dc_source_3_v2'
|
|
};
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalDCSource3_v2.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
|
|
var ss = Math.max(3, Math.min(h, w) * 0.05); // half of symbol size
|
|
var i = 3; //indent
|
|
c.ellipse(0, 0, w, h);
|
|
c.fillAndStroke();
|
|
|
|
c.begin();
|
|
c.moveTo(w * 0.5 - ss, h * 0.05 + i);
|
|
c.lineTo(w * 0.5 + ss, h * 0.05 + i);
|
|
c.moveTo(w * 0.5, h * 0.05 - ss + i);
|
|
c.lineTo(w * 0.5, h * 0.05 + ss + i);
|
|
c.moveTo(w * 0.5 - ss, h * 0.95 - i);
|
|
c.lineTo(w * 0.5 + ss, h * 0.95 - i);
|
|
c.stroke();
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalDCSource3_v2.prototype.cst.SHAPE_DC_SOURCE_3_V2, mxShapeElectricalDCSource3_v2);
|
|
|
|
mxShapeElectricalDCSource3_v2.prototype.constraints = [
|
|
new mxConnectionConstraint(new mxPoint(0.5, 0), true),
|
|
new mxConnectionConstraint(new mxPoint(0.5, 1), true)
|
|
];
|
|
|
|
//**********************************************************************************************************************************************************
|
|
//Source
|
|
//**********************************************************************************************************************************************************
|
|
/**
|
|
* Extends mxShape.
|
|
*/
|
|
function mxShapeElectricalSource(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(mxShapeElectricalSource, mxShape);
|
|
|
|
mxShapeElectricalSource.prototype.cst = {
|
|
SHAPE_SOURCE : 'mxgraph.electrical.signal_sources.source'
|
|
};
|
|
|
|
mxShapeElectricalSource.prototype.customProperties = [
|
|
{name: 'elSourceType', dispName: 'Source Type', type: 'enum', defVal: 'independent',
|
|
enumList: [{val: 'independent', dispName: 'Independent'},
|
|
{val: 'dependent', dispName: 'Dependent'}]
|
|
},
|
|
{name: 'elSignalType', dispName: 'Signal Type', type: 'enum', defVal: 'ac',
|
|
enumList: [{val: 'ac', dispName: 'AC'},
|
|
{val: 'none', dispName: 'None'},
|
|
{val: 'square', dispName: 'Square'},
|
|
{val: 'triangular', dispName: 'Triangular'},
|
|
{val: 'sawtooth', dispName: 'Sawtooth'},
|
|
{val: 'noise', dispName: 'Noise'},
|
|
{val: 'ideal', dispName: 'Ideal'},
|
|
{val: 'expSquib', dispName: 'Explosive Squib'},
|
|
{val: 'pulse', dispName: 'Pulse'},
|
|
{val: 'invPulse', dispName: 'Inverse Pulse'},
|
|
{val: 'chopSquare', dispName: 'Chopped Square'},
|
|
{val: 'stepOn', dispName: 'Step On'},
|
|
{val: 'stepOff', dispName: 'Step Off'},
|
|
{val: 'dc1', dispName: 'DC Horizontal'},
|
|
{val: 'dc2', dispName: 'DC Vertical'},
|
|
{val: 'dc3', dispName: 'DC Plus minus'}]
|
|
}
|
|
];
|
|
|
|
/**
|
|
* Function: paintVertexShape
|
|
*
|
|
* Paints the vertex shape.
|
|
*/
|
|
mxShapeElectricalSource.prototype.paintVertexShape = function(c, x, y, w, h)
|
|
{
|
|
c.translate(x, y);
|
|
|
|
var sourceType = mxUtils.getValue(this.style, 'elSourceType', 'independent');
|
|
var signalType = mxUtils.getValue(this.style, 'elSignalType', 'none');
|
|
|
|
switch (sourceType)
|
|
{
|
|
case "independent" :
|
|
c.ellipse(0, 0, w, h);
|
|
c.fillAndStroke();
|
|
break;
|
|
case "dependent" :
|
|
c.begin();
|
|
c.moveTo(0, h * 0.5);
|
|
c.lineTo(w * 0.5, 0);
|
|
c.lineTo(w, h * 0.5);
|
|
c.lineTo(w * 0.5, h);
|
|
c.lineTo(0, h * 0.5);
|
|
c.close();
|
|
c.fillAndStroke();
|
|
break;
|
|
}
|
|
|
|
switch (signalType)
|
|
{
|
|
case "ac" :
|
|
c.begin();
|
|
c.moveTo(w * 0.3, h * 0.5);
|
|
c.quadTo(w * 0.34, h * 0.35, w * 0.4, h * 0.35);
|
|
c.quadTo(w * 0.46, h * 0.35, w * 0.5, h * 0.5);
|
|
c.quadTo(w * 0.53, h * 0.65, w * 0.6, h * 0.65);
|
|
c.quadTo(w * 0.66, h * 0.65, w * 0.7, h * 0.5);
|
|
c.stroke();
|
|
break;
|
|
case "square" :
|
|
c.begin();
|
|
c.moveTo(w * 0.3, h * 0.5);
|
|
c.lineTo(w * 0.3, h * 0.35);
|
|
c.lineTo(w * 0.5, h * 0.35);
|
|
c.lineTo(w * 0.5, h * 0.65);
|
|
c.lineTo(w * 0.7, h * 0.65);
|
|
c.lineTo(w * 0.7, h * 0.5);
|
|
c.stroke();
|
|
break;
|
|
case "triangular" :
|
|
c.begin();
|
|
c.moveTo(w * 0.3, h * 0.65);
|
|
c.lineTo(w * 0.4, h * 0.35);
|
|
c.lineTo(w * 0.5, h * 0.65);
|
|
c.lineTo(w * 0.6, h * 0.35);
|
|
c.lineTo(w * 0.7, h * 0.65);
|
|
c.stroke();
|
|
break;
|
|
case "sawtooth" :
|
|
c.begin();
|
|
c.moveTo(w * 0.24, h * 0.65);
|
|
c.lineTo(w * 0.42, h * 0.35);
|
|
c.lineTo(w * 0.42, h * 0.65);
|
|
c.lineTo(w * 0.58, h * 0.35);
|
|
c.lineTo(w * 0.58, h * 0.65);
|
|
c.lineTo(w * 0.76, h * 0.35);
|
|
c.lineTo(w * 0.76, h * 0.65);
|
|
c.stroke();
|
|
break;
|
|
case "noise" :
|
|
c.begin();
|
|
c.moveTo(w * 0.5, h * 0.17);
|
|
c.lineTo(w * 0.5, h * 0.5);
|
|
c.moveTo(w * 0.18, h * 0.42);
|
|
c.lineTo(w * 0.5, h * 0.5);
|
|
c.moveTo(w * 0.32, h * 0.78);
|
|
c.lineTo(w * 0.5, h * 0.5);
|
|
c.moveTo(w * 0.82, h * 0.42);
|
|
c.lineTo(w * 0.5, h * 0.5);
|
|
c.moveTo(w * 0.68, h * 0.78);
|
|
c.lineTo(w * 0.5, h * 0.5);
|
|
c.stroke();
|
|
break;
|
|
case "ideal" :
|
|
c.begin();
|
|
c.moveTo(0, h * 0.5);
|
|
c.lineTo(w, h * 0.5);
|
|
c.stroke();
|
|
break;
|
|
case "expSquib" :
|
|
c.ellipse(0, h * 0.43, w * 0.14, h * 0.14);
|
|
c.stroke();
|
|
c.ellipse(w * 0.86, h * 0.43, w * 0.14, h * 0.14);
|
|
c.stroke();
|
|
c.begin();
|
|
c.moveTo(w * 0.83, h * 0.63);
|
|
c.lineTo(w * 0.73, h * 0.73);
|
|
c.lineTo(w * 0.27, h * 0.27);
|
|
c.lineTo(w * 0.17, h * 0.37);
|
|
c.stroke();
|
|
c.begin();
|
|
|
|
var strokeColor = mxUtils.getValue(this.style, mxConstants.STYLE_STROKECOLOR, '#000000');
|
|
c.setFillColor(strokeColor);
|
|
|
|
c.moveTo(w * 0.2, h * 0.25);
|
|
c.lineTo(w * 0.13, h * 0.4);
|
|
c.lineTo(w * 0.28, h * 0.33);
|
|
c.close();
|
|
c.fillAndStroke();
|
|
break;
|
|
case "pulse" :
|
|
c.begin();
|
|
c.moveTo(w * 0.3, h * 0.65);
|
|
c.lineTo(w * 0.4, h * 0.65);
|
|
c.lineTo(w * 0.4, h * 0.35);
|
|
c.lineTo(w * 0.6, h * 0.35);
|
|
c.lineTo(w * 0.6, h * 0.65);
|
|
c.lineTo(w * 0.7, h * 0.65);
|
|
c.stroke();
|
|
break;
|
|
case "invPulse" :
|
|
c.begin();
|
|
c.moveTo(w * 0.3, h * 0.35);
|
|
c.lineTo(w * 0.4, h * 0.35);
|
|
c.lineTo(w * 0.4, h * 0.65);
|
|
c.lineTo(w * 0.6, h * 0.65);
|
|
c.lineTo(w * 0.6, h * 0.35);
|
|
c.lineTo(w * 0.7, h * 0.35);
|
|
c.stroke();
|
|
break;
|
|
case "chopSquare" :
|
|
c.begin();
|
|
c.moveTo(w * 0.3, h * 0.5);
|
|
c.lineTo(w * 0.33, h * 0.35);
|
|
c.lineTo(w * 0.47, h * 0.35);
|
|
c.lineTo(w * 0.53, h * 0.65);
|
|
c.lineTo(w * 0.67, h * 0.65);
|
|
c.lineTo(w * 0.7, h * 0.5);
|
|
c.stroke();
|
|
break;
|
|
case "stepOn" :
|
|
c.begin();
|
|
c.moveTo(w * 0.3, h * 0.65);
|
|
c.lineTo(w * 0.5, h * 0.65);
|
|
c.lineTo(w * 0.5, h * 0.35);
|
|
c.lineTo(w * 0.7, h * 0.35);
|
|
c.stroke();
|
|
break;
|
|
case "stepOff" :
|
|
c.begin();
|
|
c.moveTo(w * 0.3, h * 0.35);
|
|
c.lineTo(w * 0.5, h * 0.35);
|
|
c.lineTo(w * 0.5, h * 0.65);
|
|
c.lineTo(w * 0.7, h * 0.65);
|
|
c.stroke();
|
|
break;
|
|
case "dc1" :
|
|
c.begin();
|
|
c.moveTo(w * 0.17, h * 0.5);
|
|
c.lineTo(w * 0.83, h * 0.5);
|
|
c.moveTo(w * 0.67, h * 0.42);
|
|
c.lineTo(w * 0.83, h * 0.5);
|
|
c.lineTo(w * 0.67, h * 0.58);
|
|
c.stroke();
|
|
break;
|
|
case "dc2" :
|
|
c.begin();
|
|
c.moveTo(w * 0.5, h * 0.17);
|
|
c.lineTo(w * 0.5, h * 0.83);
|
|
c.moveTo(w * 0.42, h * 0.67);
|
|
c.lineTo(w * 0.5, h * 0.83);
|
|
c.lineTo(w * 0.58, h * 0.67);
|
|
c.stroke();
|
|
break;
|
|
case "dc3" :
|
|
var ss = Math.max(3, Math.min(h, w) * 0.05); // half of symbol size
|
|
var i = 3; //indent
|
|
|
|
if (sourceType == 'dependent')
|
|
{
|
|
i += 3;
|
|
}
|
|
|
|
c.begin();
|
|
c.moveTo(w * 0.5 - ss, h * 0.05 + i);
|
|
c.lineTo(w * 0.5 + ss, h * 0.05 + i);
|
|
c.moveTo(w * 0.5, h * 0.05 - ss + i);
|
|
c.lineTo(w * 0.5, h * 0.05 + ss + i);
|
|
c.moveTo(w * 0.5 - ss, h * 0.95 - i);
|
|
c.lineTo(w * 0.5 + ss, h * 0.95 - i);
|
|
c.stroke();
|
|
break;
|
|
}
|
|
};
|
|
|
|
mxCellRenderer.registerShape(mxShapeElectricalSource.prototype.cst.SHAPE_SOURCE, mxShapeElectricalSource);
|