chore: 格式化代码

@@ -9,8 +9,7 @@
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2Arrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2Arrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -27,15 +26,15 @@ function mxShapeArrows2Arrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2Arrow, mxActor);
 
 mxShapeArrows2Arrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 40},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, max:1, defVal: 0.6},
-	{name: 'notch', dispName: 'Notch', type: 'float', min:0, defVal: 0},
-	{name: 'headCrossline', dispName: 'Head Crossline', type: 'bool', defVal: false},
-	{name: 'tailCrossline', dispName: 'Tail Crossline', type: 'bool', defVal: false}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 40 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, max: 1, defVal: 0.6 },
+	{ name: 'notch', dispName: 'Notch', type: 'float', min: 0, defVal: 0 },
+	{ name: 'headCrossline', dispName: 'Head Crossline', type: 'bool', defVal: false },
+	{ name: 'tailCrossline', dispName: 'Tail Crossline', type: 'bool', defVal: false }
 ];
 
 mxShapeArrows2Arrow.prototype.cst = {
-		ARROW : 'mxgraph.arrows2.arrow'
+	ARROW: 'mxgraph.arrows2.arrow'
 };
 
 /**
@@ -43,8 +42,7 @@ mxShapeArrows2Arrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2Arrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2Arrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -64,19 +62,17 @@ mxShapeArrows2Arrow.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(notch, h * 0.5);
 	c.close();
 	c.fillAndStroke();
-	
+
 	c.setShadow(false);
-	
-	if (headCrossline)
-	{
+
+	if (headCrossline) {
 		c.begin();
 		c.moveTo(w - dx, dy);
 		c.lineTo(w - dx, h - dy);
 		c.stroke();
 	}
-	
-	if (tailCrossline)
-	{
+
+	if (tailCrossline) {
 		c.begin();
 		c.moveTo(notch, dy);
 		c.lineTo(notch, h - dy);
@@ -84,99 +80,83 @@ mxShapeArrows2Arrow.prototype.paintVertexShape = function(c, x, y, w, h)
 	}
 };
 
-mxShapeArrows2Arrow.prototype.getLabelBounds = function(rect)
-{
-	if (mxUtils.getValue(this.style, 'boundedLbl', false))
-	{
+mxShapeArrows2Arrow.prototype.getLabelBounds = function (rect) {
+	if (mxUtils.getValue(this.style, 'boundedLbl', false)) {
 		var w = rect.width;
 		var h = rect.height;
-		
+
 		var dy, dx;
 		var direction = this.direction || mxConstants.DIRECTION_EAST;
-		
-		if (mxUtils.getValue(this.style, 'flipH', false))
-		{
+
+		if (mxUtils.getValue(this.style, 'flipH', false)) {
 			if (direction == mxConstants.DIRECTION_WEST)
 				direction = mxConstants.DIRECTION_EAST;
 			else if (direction == mxConstants.DIRECTION_EAST)
 				direction = mxConstants.DIRECTION_WEST;
 		}
-		
-		if (mxUtils.getValue(this.style, 'flipV', false))
-		{
+
+		if (mxUtils.getValue(this.style, 'flipV', false)) {
 			if (direction == mxConstants.DIRECTION_NORTH)
 				direction = mxConstants.DIRECTION_SOUTH;
 			else if (direction == mxConstants.DIRECTION_SOUTH)
 				direction = mxConstants.DIRECTION_NORTH;
 		}
-		
+
 		if (direction == mxConstants.DIRECTION_NORTH
-				|| direction == mxConstants.DIRECTION_SOUTH)
-		{
+			|| direction == mxConstants.DIRECTION_SOUTH) {
 			dy = w * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 			dx = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
 		}
-		else
-		{
+		else {
 			dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 			dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
 		}
-		
-		if (direction == mxConstants.DIRECTION_EAST)
-		{
+
+		if (direction == mxConstants.DIRECTION_EAST) {
 			return new mxRectangle(rect.x, rect.y + dy, w - dx, h - 2 * dy);
 		}
-		else if (direction == mxConstants.DIRECTION_WEST)
-		{
+		else if (direction == mxConstants.DIRECTION_WEST) {
 			return new mxRectangle(rect.x + dx, rect.y + dy, w - dx, h - 2 * dy);
 		}
-		else if (direction == mxConstants.DIRECTION_NORTH)
-		{
+		else if (direction == mxConstants.DIRECTION_NORTH) {
 			return new mxRectangle(rect.x + dy, rect.y + dx, w - 2 * dy, h - dx);
 		}
-		else
-		{
+		else {
 			return new mxRectangle(rect.x + dy, rect.y, w - 2 * dy, h - dx);
 		}
 	}
-	
+
 	return rect;
 };
 
 mxCellRenderer.registerShape(mxShapeArrows2Arrow.prototype.cst.ARROW, mxShapeArrows2Arrow);
 
-Graph.handleFactory[mxShapeArrows2Arrow.prototype.cst.ARROW] = 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(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + dy * bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2Arrow.prototype.cst.ARROW] = 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(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + dy * bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x))) / 100;
+	});
+
 	handles.push(handle2);
-	
+
 	return handles;
 
 }
 
-mxShapeArrows2Arrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2Arrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -202,8 +182,7 @@ mxShapeArrows2Arrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2TwoWayArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2TwoWayArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -219,12 +198,12 @@ function mxShapeArrows2TwoWayArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2TwoWayArrow, mxActor);
 
 mxShapeArrows2TwoWayArrow.prototype.cst = {
-		TWO_WAY_ARROW : 'mxgraph.arrows2.twoWayArrow'
+	TWO_WAY_ARROW: 'mxgraph.arrows2.twoWayArrow'
 };
 
 mxShapeArrows2TwoWayArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal: 35},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, max:1, defVal: 0.6}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 35 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, max: 1, defVal: 0.6 }
 ];
 
 /**
@@ -232,8 +211,7 @@ mxShapeArrows2TwoWayArrow.prototype.customProperties = [
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2TwoWayArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2TwoWayArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -254,38 +232,32 @@ mxShapeArrows2TwoWayArrow.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.fillAndStroke();
 };
 
-mxShapeArrows2TwoWayArrow.prototype.getLabelBounds = function(rect)
-{
-	if (mxUtils.getValue(this.style, 'boundedLbl', false))
-	{
+mxShapeArrows2TwoWayArrow.prototype.getLabelBounds = function (rect) {
+	if (mxUtils.getValue(this.style, 'boundedLbl', false)) {
 		var w = rect.width;
 		var h = rect.height;
 		var vertical = this.direction == mxConstants.DIRECTION_NORTH
-						|| this.direction == mxConstants.DIRECTION_SOUTH;
+			|| this.direction == mxConstants.DIRECTION_SOUTH;
 
 		var dy, dx;
-		
-		if (vertical)
-		{
+
+		if (vertical) {
 			dy = w * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 			dx = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
 		}
-		else
-		{
+		else {
 			dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 			dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
 		}
-		
-		if (vertical)
-		{
+
+		if (vertical) {
 			return new mxRectangle(rect.x + dy, rect.y + dx, w - 2 * dy, h - 2 * dx);
 		}
-		else
-		{
+		else {
 			return new mxRectangle(rect.x + dx, rect.y + dy, w - 2 * dx, h - 2 * dy);
 		}
 	}
-	
+
 	return rect;
 };
 
@@ -293,26 +265,22 @@ mxCellRenderer.registerShape(mxShapeArrows2TwoWayArrow.prototype.cst.TWO_WAY_ARR
 
 mxShapeArrows2TwoWayArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2TwoWayArrow.prototype.cst.TWO_WAY_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var dx = Math.max(0, Math.min(bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
-				var dy = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + dy * bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width / 2, bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
-			})];
-	
+Graph.handleFactory[mxShapeArrows2TwoWayArrow.prototype.cst.TWO_WAY_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var dx = Math.max(0, Math.min(bounds.width / 2, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
+		var dy = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + dy * bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width / 2, bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
+	})];
+
 	return handles;
 
 }
 
-mxShapeArrows2TwoWayArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2TwoWayArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -339,8 +307,7 @@ mxShapeArrows2TwoWayArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2StylisedArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2StylisedArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -358,14 +325,14 @@ function mxShapeArrows2StylisedArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2StylisedArrow, mxActor);
 
 mxShapeArrows2StylisedArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:40},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, max:1, defVal:0.6},
-	{name: 'notch', dispName: 'Notch', type: 'float', min:0, defVal:0},
-	{name: 'feather', dispName: 'Feather', type: 'float', min:0, max:1, defVal:0.4},
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 40 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, max: 1, defVal: 0.6 },
+	{ name: 'notch', dispName: 'Notch', type: 'float', min: 0, defVal: 0 },
+	{ name: 'feather', dispName: 'Feather', type: 'float', min: 0, max: 1, defVal: 0.4 },
 ];
 
 mxShapeArrows2StylisedArrow.prototype.cst = {
-		STYLISED_ARROW : 'mxgraph.arrows2.stylisedArrow'
+	STYLISED_ARROW: 'mxgraph.arrows2.stylisedArrow'
 };
 
 /**
@@ -373,8 +340,7 @@ mxShapeArrows2StylisedArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2StylisedArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2StylisedArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -399,50 +365,42 @@ mxCellRenderer.registerShape(mxShapeArrows2StylisedArrow.prototype.cst.STYLISED_
 
 mxShapeArrows2StylisedArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2StylisedArrow.prototype.cst.STYLISED_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var dx = Math.max(0, Math.min(bounds.width - 10, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
-				var dy = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + dy * bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - 10, bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2StylisedArrow.prototype.cst.STYLISED_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var dx = Math.max(0, Math.min(bounds.width - 10, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
+		var dy = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + dy * bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - 10, bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x))) / 100;
+	});
+
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['feather'], function(bounds)
-			{
-				var feather = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'feather', this.dy))));
-
-				return new mxPoint(bounds.x, bounds.y + feather * bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['feather'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
-			});
-	
+
+	var handle3 = Graph.createHandle(state, ['feather'], function (bounds) {
+		var feather = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'feather', this.dy))));
+
+		return new mxPoint(bounds.x, bounds.y + feather * bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['feather'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
+	});
+
 	handles.push(handle3);
-	
+
 	return handles;
 
 }
 
-mxShapeArrows2StylisedArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2StylisedArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -469,8 +427,7 @@ mxShapeArrows2StylisedArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2SharpArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2SharpArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -488,14 +445,14 @@ function mxShapeArrows2SharpArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2SharpArrow, mxActor);
 
 mxShapeArrows2SharpArrow.prototype.cst = {
-		SHARP_ARROW : 'mxgraph.arrows2.sharpArrow'
+	SHARP_ARROW: 'mxgraph.arrows2.sharpArrow'
 };
 
 mxShapeArrows2SharpArrow.prototype.customProperties = [
-	{name: 'dx1', dispName: 'Arrowhead Arrow Width', type: 'float', min:0, defVal:18},
-	{name: 'dy1', dispName: 'Arrow Arrow Width', type: 'float', min:0, max:1, defVal:0.67},
-	{name: 'dx2', dispName: 'Arrowhead Angle', type: 'float', min:0, defVal:18},
-	{name: 'notch', dispName: 'Notch', type: 'float', min:0, defVal:0}
+	{ name: 'dx1', dispName: 'Arrowhead Arrow Width', type: 'float', min: 0, defVal: 18 },
+	{ name: 'dy1', dispName: 'Arrow Arrow Width', type: 'float', min: 0, max: 1, defVal: 0.67 },
+	{ name: 'dx2', dispName: 'Arrowhead Angle', type: 'float', min: 0, defVal: 18 },
+	{ name: 'notch', dispName: 'Notch', type: 'float', min: 0, defVal: 0 }
 ];
 
 /**
@@ -503,8 +460,7 @@ mxShapeArrows2SharpArrow.prototype.customProperties = [
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2SharpArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2SharpArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy1 = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
@@ -514,12 +470,11 @@ mxShapeArrows2SharpArrow.prototype.paintVertexShape = function(c, x, y, w, h)
 	var dx1a = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
 	var dy1a = h * 0.5 * Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
 	var x2 = 0;
-	
-	if (h != 0)
-	{
+
+	if (h != 0) {
 		x2 = dx1a + dx2 * dy1a * 2 / h;
 	}
-	
+
 	c.begin();
 	c.moveTo(0, dy1);
 	c.lineTo(w - dx1, dy1);
@@ -539,49 +494,41 @@ mxCellRenderer.registerShape(mxShapeArrows2SharpArrow.prototype.cst.SHARP_ARROW,
 
 mxShapeArrows2SharpArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2SharpArrow.prototype.cst.SHARP_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function(bounds)
-			{
-				var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
-				var dy1 = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
-
-				return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + dy1 * bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2SharpArrow.prototype.cst.SHARP_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function (bounds) {
+		var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
+		var dy1 = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
+
+		return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + dy1 * bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
+	});
+
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['dx2'], function(bounds)
-			{
-				var dx2 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
-
-				return new mxPoint(bounds.x + bounds.width - dx2, bounds.y);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-			});
-	
+
+	var handle3 = Graph.createHandle(state, ['dx2'], function (bounds) {
+		var dx2 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
+
+		return new mxPoint(bounds.x + bounds.width - dx2, bounds.y);
+	}, function (bounds, pt) {
+		this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+	});
+
 	handles.push(handle3);
-	
+
 	return handles;
 };
 
-mxShapeArrows2SharpArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2SharpArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy1 = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
 	var dx1 = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
@@ -590,12 +537,11 @@ mxShapeArrows2SharpArrow.prototype.getConstraints = function(style, w, h)
 	var dx1a = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
 	var dy1a = h * 0.5 * Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
 	var x2 = 0;
-	
-	if (h != 0)
-	{
+
+	if (h != 0) {
 		x2 = dx1a + dx2 * dy1a * 2 / h;
 	}
-	
+
 	constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, notch, 0));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, dy1));
@@ -618,8 +564,7 @@ mxShapeArrows2SharpArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2SharpArrow2(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2SharpArrow2(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -640,16 +585,16 @@ function mxShapeArrows2SharpArrow2(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2SharpArrow2, mxActor);
 
 mxShapeArrows2SharpArrow2.prototype.customProperties = [
-	{name: 'dx1', dispName: 'Arrowhead Arrow Width', type: 'float', min:0, defVal:18},
-	{name: 'dy1', dispName: 'Arrow Width', type: 'float', min:0, max:1, defVal:0.67},
-	{name: 'dx2', dispName: 'Arrowhead Angle', type: 'float', min:0, defVal:18},
-	{name: 'dx3', dispName: 'Arrowhead Edge X', type: 'float', min:0, defVal:27},
-	{name: 'dy3', dispName: 'Arrowhead Edge Y', type: 'float', min:0, max:1, defVal:0.15},
-	{name: 'notch', dispName: 'Notch', type: 'float', min:0, defVal:0}
+	{ name: 'dx1', dispName: 'Arrowhead Arrow Width', type: 'float', min: 0, defVal: 18 },
+	{ name: 'dy1', dispName: 'Arrow Width', type: 'float', min: 0, max: 1, defVal: 0.67 },
+	{ name: 'dx2', dispName: 'Arrowhead Angle', type: 'float', min: 0, defVal: 18 },
+	{ name: 'dx3', dispName: 'Arrowhead Edge X', type: 'float', min: 0, defVal: 27 },
+	{ name: 'dy3', dispName: 'Arrowhead Edge Y', type: 'float', min: 0, max: 1, defVal: 0.15 },
+	{ name: 'notch', dispName: 'Notch', type: 'float', min: 0, defVal: 0 }
 ];
 
 mxShapeArrows2SharpArrow2.prototype.cst = {
-		SHARP_ARROW2 : 'mxgraph.arrows2.sharpArrow2'
+	SHARP_ARROW2: 'mxgraph.arrows2.sharpArrow2'
 };
 
 /**
@@ -657,8 +602,7 @@ mxShapeArrows2SharpArrow2.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2SharpArrow2.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2SharpArrow2.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy1 = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
@@ -689,63 +633,53 @@ mxCellRenderer.registerShape(mxShapeArrows2SharpArrow2.prototype.cst.SHARP_ARROW
 
 mxShapeArrows2SharpArrow2.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2SharpArrow2.prototype.cst.SHARP_ARROW2] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function(bounds)
-			{
-				var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
-				var dy1 = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
-
-				return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + dy1 * bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2SharpArrow2.prototype.cst.SHARP_ARROW2] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function (bounds) {
+		var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
+		var dy1 = Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
+
+		return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + dy1 * bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
+	});
+
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['dx2'], function(bounds)
-			{
-				var dx2 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
-
-				return new mxPoint(bounds.x + bounds.width - dx2, bounds.y);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-			});
-	
+
+	var handle3 = Graph.createHandle(state, ['dx2'], function (bounds) {
+		var dx2 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
+
+		return new mxPoint(bounds.x + bounds.width - dx2, bounds.y);
+	}, function (bounds, pt) {
+		this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+	});
+
 	handles.push(handle3);
 
-	var handle4 = Graph.createHandle(state, ['dx3', 'dy3'], function(bounds)
-			{
-				var dx3 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx3', this.dx3))));
-				var dy3 = Math.max(0, Math.min(1 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy3', this.dy3))));
+	var handle4 = Graph.createHandle(state, ['dx3', 'dy3'], function (bounds) {
+		var dx3 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx3', this.dx3))));
+		var dy3 = Math.max(0, Math.min(1 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy3', this.dy3))));
 
-				return new mxPoint(bounds.x + bounds.width - dx3, bounds.y + dy3 * bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx3'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), Math.min(bounds.width, bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy3'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
-			});
+		return new mxPoint(bounds.x + bounds.width - dx3, bounds.y + dy3 * bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['dx3'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), Math.min(bounds.width, bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy3'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
+	});
 
 	handles.push(handle4);
 
 	return handles;
 };
 
-mxShapeArrows2SharpArrow2.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2SharpArrow2.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy1 = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
 	var dx1 = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
@@ -778,8 +712,7 @@ mxShapeArrows2SharpArrow2.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2CalloutArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2CalloutArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -797,14 +730,14 @@ function mxShapeArrows2CalloutArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2CalloutArrow, mxActor);
 
 mxShapeArrows2CalloutArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:20},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:10},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal:10},
-	{name: 'notch', dispName: 'Rectangle Width', type: 'float', min:0, defVal:60}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 20 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'notch', dispName: 'Rectangle Width', type: 'float', min: 0, defVal: 60 }
 ];
 
 mxShapeArrows2CalloutArrow.prototype.cst = {
-		CALLOUT_ARROW : 'mxgraph.arrows2.calloutArrow'
+	CALLOUT_ARROW: 'mxgraph.arrows2.calloutArrow'
 };
 
 /**
@@ -812,8 +745,7 @@ mxShapeArrows2CalloutArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2CalloutArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2CalloutArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -841,53 +773,45 @@ mxCellRenderer.registerShape(mxShapeArrows2CalloutArrow.prototype.cst.CALLOUT_AR
 
 mxShapeArrows2CalloutArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2CalloutArrow.prototype.cst.CALLOUT_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				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 / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x))) / 100;
-			});
+Graph.handleFactory[mxShapeArrows2CalloutArrow.prototype.cst.CALLOUT_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		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 / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x))) / 100;
+	});
 
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy - arrowHead);
-			}, function(bounds, pt)
-			{
-			this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) - pt.y))) / 100;
-			});
+
+	var handle3 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy - arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) - pt.y))) / 100;
+	});
 
 	handles.push(handle3);
-	
+
 	return handles;
 };
 
-mxShapeArrows2CalloutArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2CalloutArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -896,7 +820,7 @@ mxShapeArrows2CalloutArrow.prototype.getConstraints = function(style, w, h)
 
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, notch, 0));
-	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null,notch, h * 0.5 - dy));
+	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, notch, h * 0.5 - dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, h * 0.5 - dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, h * 0.5 - dy - arrowHead));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w, h * 0.5));
@@ -905,8 +829,8 @@ mxShapeArrows2CalloutArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, notch, h * 0.5 + dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, notch, h));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, h));
-	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, notch * 0.5 , 0));
-	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, notch * 0.5 , h));
+	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, notch * 0.5, 0));
+	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, notch * 0.5, h));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, (notch + w - dx) * 0.5, -dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, (notch + w - dx) * 0.5, dy));
 
@@ -919,8 +843,7 @@ mxShapeArrows2CalloutArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2BendArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2BendArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -938,15 +861,15 @@ function mxShapeArrows2BendArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2BendArrow, mxActor);
 
 mxShapeArrows2BendArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal: 38},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal: 15},
-	{name: 'notch', dispName: 'Notch', type: 'float', min:0, defVal: 0},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:55},
-	{name: 'rounded', dispName: 'Rounded', type: 'boolean', defVal: false}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 38 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 15 },
+	{ name: 'notch', dispName: 'Notch', type: 'float', min: 0, defVal: 0 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 55 },
+	{ name: 'rounded', dispName: 'Rounded', type: 'boolean', defVal: false }
 ];
 
 mxShapeArrows2BendArrow.prototype.cst = {
-		BEND_ARROW : 'mxgraph.arrows2.bendArrow'
+	BEND_ARROW: 'mxgraph.arrows2.bendArrow'
 };
 
 /**
@@ -954,8 +877,7 @@ mxShapeArrows2BendArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2BendArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2BendArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -969,28 +891,24 @@ mxShapeArrows2BendArrow.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(w, arrowHead * 0.5);
 	c.lineTo(w - dx, arrowHead);
 	c.lineTo(w - dx, arrowHead / 2 + dy);
-	
-	if (rounded == '1')
-	{
+
+	if (rounded == '1') {
 		c.lineTo(dy * 2.2, arrowHead / 2 + dy);
 		c.arcTo(dy * 0.2, dy * 0.2, 0, 0, 0, dy * 2, arrowHead / 2 + dy * 1.2);
 	}
-	else
-	{
+	else {
 		c.lineTo(dy * 2, arrowHead / 2 + dy);
 	}
-	
+
 	c.lineTo(dy * 2, h);
 	c.lineTo(dy, h - notch);
 	c.lineTo(0, h);
-	
-	if (rounded == '1')
-	{
+
+	if (rounded == '1') {
 		c.lineTo(0, arrowHead / 2 + dy);
 		c.arcTo(dy * 2, dy * 2, 0, 0, 1, dy * 2, arrowHead / 2 - dy);
 	}
-	else
-	{
+	else {
 		c.lineTo(0, arrowHead / 2 - dy);
 	}
 
@@ -1003,55 +921,47 @@ mxCellRenderer.registerShape(mxShapeArrows2BendArrow.prototype.cst.BEND_ARROW, m
 
 mxShapeArrows2BendArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2BendArrow.prototype.cst.BEND_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				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(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-		
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead / 2 - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) * 2.2, bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				
-				var notch = Math.max(0, Math.min(bounds.height - arrowHead / 2 - dy, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + dy, bounds.y + bounds.height - notch);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height - pt.y))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2BendArrow.prototype.cst.BEND_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		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(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead / 2 - dy);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) * 2.2, bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		var notch = Math.max(0, Math.min(bounds.height - arrowHead / 2 - dy, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + dy, bounds.y + bounds.height - notch);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height - pt.y))) / 100;
+	});
+
 	handles.push(handle2);
 
-	var handle3 = Graph.createHandle(state, ['arrowHead'], function(bounds)
-			{
-				var dx = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(bounds.height, pt.y - bounds.y))) / 100;
-			});
-	
+	var handle3 = Graph.createHandle(state, ['arrowHead'], function (bounds) {
+		var dx = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(bounds.height, pt.y - bounds.y))) / 100;
+	});
+
 	handles.push(handle3);
 
 	return handles;
 };
 
-mxShapeArrows2BendArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2BendArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -1072,17 +982,15 @@ mxShapeArrows2BendArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, h));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, (h - arrowHead / 2 - dy) * 0.5 + arrowHead / 2 + dy));
 
-	if (rounded == '1')
-	{
+	if (rounded == '1') {
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dy * 0.586, arrowHead / 2 - dy * 0.414));
-		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 2 * dy  + dy * 0.0586, arrowHead / 2 + dy + dy * 0.0586));
+		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 2 * dy + dy * 0.0586, arrowHead / 2 + dy + dy * 0.0586));
 	}
-	else
-	{
+	else {
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, arrowHead / 2 - dy));
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dy * 2, arrowHead / 2 + dy));
 	}
-	
+
 	return (constr);
 };
 
@@ -1092,8 +1000,7 @@ mxShapeArrows2BendArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2BendDoubleArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2BendDoubleArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1111,14 +1018,14 @@ function mxShapeArrows2BendDoubleArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2BendDoubleArrow, mxActor);
 
 mxShapeArrows2BendDoubleArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:38},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal:15},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:55},
-	{name: 'rounded', dispName: 'Rounded', type: 'boolean', defVal:false}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 38 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 15 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 55 },
+	{ name: 'rounded', dispName: 'Rounded', type: 'boolean', defVal: false }
 ];
 
 mxShapeArrows2BendDoubleArrow.prototype.cst = {
-		BEND_DOUBLE_ARROW : 'mxgraph.arrows2.bendDoubleArrow'
+	BEND_DOUBLE_ARROW: 'mxgraph.arrows2.bendDoubleArrow'
 };
 
 /**
@@ -1126,8 +1033,7 @@ mxShapeArrows2BendDoubleArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2BendDoubleArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2BendDoubleArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -1141,29 +1047,25 @@ mxShapeArrows2BendDoubleArrow.prototype.paintVertexShape = function(c, x, y, w,
 	c.lineTo(w - dx, arrowHead);
 	c.lineTo(w - dx, arrowHead / 2 + dy);
 
-	if (rounded == '1')
-	{
+	if (rounded == '1') {
 		c.lineTo(arrowHead / 2 + dy * 1.2, arrowHead / 2 + dy);
-		c.arcTo(dy * 0.2, dy * 0.2, 0, 0, 0, arrowHead /2 + dy, arrowHead / 2 + dy * 1.2);
+		c.arcTo(dy * 0.2, dy * 0.2, 0, 0, 0, arrowHead / 2 + dy, arrowHead / 2 + dy * 1.2);
 	}
-	else
-	{
+	else {
 		c.lineTo(arrowHead / 2 + dy, arrowHead / 2 + dy);
 	}
-	
+
 	c.lineTo(arrowHead / 2 + dy, h - dx);
 	c.lineTo(arrowHead, h - dx);
 	c.lineTo(arrowHead / 2, h);
 	c.lineTo(0, h - dx);
 	c.lineTo(arrowHead / 2 - dy, h - dx);
-	
-	if (rounded == '1')
-	{
+
+	if (rounded == '1') {
 		c.lineTo(arrowHead / 2 - dy, arrowHead / 2 + dy);
 		c.arcTo(dy * 2, dy * 2, 0, 0, 1, arrowHead / 2 + dy, arrowHead / 2 - dy);
 	}
-	else
-	{
+	else {
 		c.lineTo(arrowHead / 2 - dy, arrowHead / 2 - dy);
 	}
 
@@ -1176,47 +1078,41 @@ mxCellRenderer.registerShape(mxShapeArrows2BendDoubleArrow.prototype.cst.BEND_DO
 
 mxShapeArrows2BendDoubleArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2BendDoubleArrow.prototype.cst.BEND_DOUBLE_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(Math.min(bounds.height, bounds.width) - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dx = Math.max(0, Math.min(Math.min(bounds.width, bounds.height) - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
-				var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-		
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead / 2 - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(Math.min(bounds.width, bounds.height) - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['arrowHead'], function(bounds)
-			{
-				var dx = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
-				var arrowHead = Math.max(0, Math.min(Math.min(bounds.height, bounds.width) - dx, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(Math.min(bounds.height, bounds.width) - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.y - bounds.y))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2BendDoubleArrow.prototype.cst.BEND_DOUBLE_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(Math.min(bounds.height, bounds.width) - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dx = Math.max(0, Math.min(Math.min(bounds.width, bounds.height) - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
+		var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead / 2 - dy);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(Math.min(bounds.width, bounds.height) - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['arrowHead'], function (bounds) {
+		var dx = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
+		var arrowHead = Math.max(0, Math.min(Math.min(bounds.height, bounds.width) - dx, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(Math.min(bounds.height, bounds.width) - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.y - bounds.y))) / 100;
+	});
+
 	handles.push(handle2);
 
 	return handles;
 };
 
-mxShapeArrows2BendDoubleArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2BendDoubleArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
 	var arrowHead = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'arrowHead', this.arrowHead))));
 	var rounded = mxUtils.getValue(this.style, 'rounded', '0');
 
-	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx , 0));
+	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, 0));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w, arrowHead * 0.5));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, arrowHead));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, arrowHead / 2 + dy));
@@ -1230,17 +1126,15 @@ mxShapeArrows2BendDoubleArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, h - dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, arrowHead / 2 - dy, h - dx));
 
-	if (rounded == '1')
-	{
+	if (rounded == '1') {
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, arrowHead / 2 - dy * 0.414, arrowHead / 2 - dy * 0.414));
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, arrowHead / 2 + dy + dy * 0.0586, arrowHead / 2 + dy + dy * 0.0586));
 	}
-	else
-	{
+	else {
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, arrowHead / 2 - dy, arrowHead / 2 - dy));
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, arrowHead / 2 + dy, arrowHead / 2 + dy));
 	}
-	
+
 	return (constr);
 };
 
@@ -1250,8 +1144,7 @@ mxShapeArrows2BendDoubleArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2CalloutDoubleArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2CalloutDoubleArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1269,14 +1162,14 @@ function mxShapeArrows2CalloutDoubleArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2CalloutDoubleArrow, mxActor);
 
 mxShapeArrows2CalloutDoubleArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:20},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal:10},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:10},
-	{name: 'notch', dispName: 'Rect Size', type: 'float', min:0, defVal:24}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 20 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'notch', dispName: 'Rect Size', type: 'float', min: 0, defVal: 24 }
 ];
 
 mxShapeArrows2CalloutDoubleArrow.prototype.cst = {
-		CALLOUT_DOUBLE_ARROW : 'mxgraph.arrows2.calloutDoubleArrow'
+	CALLOUT_DOUBLE_ARROW: 'mxgraph.arrows2.calloutDoubleArrow'
 };
 
 /**
@@ -1284,8 +1177,7 @@ mxShapeArrows2CalloutDoubleArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2CalloutDoubleArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2CalloutDoubleArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -1320,53 +1212,45 @@ mxCellRenderer.registerShape(mxShapeArrows2CalloutDoubleArrow.prototype.cst.CALL
 
 mxShapeArrows2CalloutDoubleArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2CalloutDoubleArrow.prototype.cst.CALLOUT_DOUBLE_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				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 / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width / 2 - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + bounds.width / 2 + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x - bounds.width / 2))) / 100;
-			});
+Graph.handleFactory[mxShapeArrows2CalloutDoubleArrow.prototype.cst.CALLOUT_DOUBLE_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		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 / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width / 2 - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + bounds.width / 2 + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x - bounds.width / 2))) / 100;
+	});
 
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy - arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) - pt.y))) / 100;
-			});
+
+	var handle3 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy - arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) - pt.y))) / 100;
+	});
 
 	handles.push(handle3);
-	
+
 	return handles;
 };
 
-mxShapeArrows2CalloutDoubleArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2CalloutDoubleArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -1389,7 +1273,7 @@ mxShapeArrows2CalloutDoubleArrow.prototype.getConstraints = function(style, w, h
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w * 1.5 - dx + notch) * 0.5, h * 0.5 + dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w * 0.5 + dx - notch) * 0.5, h * 0.5 - dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w * 0.5 + dx - notch) * 0.5, h * 0.5 + dy));
-	
+
 	return (constr);
 };
 
@@ -1399,8 +1283,7 @@ mxShapeArrows2CalloutDoubleArrow.prototype.getConstraints = function(style, w, h
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2CalloutQuadArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2CalloutQuadArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1418,14 +1301,14 @@ function mxShapeArrows2CalloutQuadArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2CalloutQuadArrow, mxActor);
 
 mxShapeArrows2CalloutQuadArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:20},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal: 10},
-	{name: 'notch', dispName: 'Rect Size', type: 'float', min:0, defVal:24},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:10}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 20 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'notch', dispName: 'Rect Size', type: 'float', min: 0, defVal: 24 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 10 }
 ];
 
 mxShapeArrows2CalloutQuadArrow.prototype.cst = {
-		CALLOUT_QUAD_ARROW : 'mxgraph.arrows2.calloutQuadArrow'
+	CALLOUT_QUAD_ARROW: 'mxgraph.arrows2.calloutQuadArrow'
 };
 
 /**
@@ -1433,8 +1316,7 @@ mxShapeArrows2CalloutQuadArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2CalloutQuadArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2CalloutQuadArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -1483,53 +1365,45 @@ mxCellRenderer.registerShape(mxShapeArrows2CalloutQuadArrow.prototype.cst.CALLOU
 
 mxShapeArrows2CalloutQuadArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2CalloutQuadArrow.prototype.cst.CALLOUT_QUAD_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				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 + bounds.width - dx, bounds.y + bounds.height / 2 - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(Math.min(bounds.width, bounds.height) / 2 - Math.max(parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(Math.min(bounds.width, bounds.height), parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + bounds.width / 2 + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(Math.min(bounds.width, bounds.height) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x - bounds.width / 2))) / 100;
-			});
+Graph.handleFactory[mxShapeArrows2CalloutQuadArrow.prototype.cst.CALLOUT_QUAD_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		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 + bounds.width - dx, bounds.y + bounds.height / 2 - dy);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(Math.min(bounds.width, bounds.height) / 2 - Math.max(parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(Math.min(bounds.width, bounds.height), parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + bounds.width / 2 + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(Math.min(bounds.width, bounds.height) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x - bounds.width / 2))) / 100;
+	});
 
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy - arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-			});
+
+	var handle3 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy - arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+	});
 
 	handles.push(handle3);
-	
+
 	return handles;
 };
 
-mxShapeArrows2CalloutQuadArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2CalloutQuadArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -1568,7 +1442,7 @@ mxShapeArrows2CalloutQuadArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w * 0.25 - (notch - dx) * 0.5, h * 0.5 + dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w * 0.5 - dy, h * 0.25 - (notch - dx) * 0.5));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w * 0.5 + dy, h * 0.25 - (notch - dx) * 0.5));
-	
+
 	return (constr);
 };
 
@@ -1578,8 +1452,7 @@ mxShapeArrows2CalloutQuadArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2CalloutDouble90Arrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2CalloutDouble90Arrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1598,15 +1471,15 @@ function mxShapeArrows2CalloutDouble90Arrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2CalloutDouble90Arrow, mxActor);
 
 mxShapeArrows2CalloutDouble90Arrow.prototype.customProperties = [
-	{name: 'dx1', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:20},
-	{name: 'dy1', dispName: 'Arrow Width', type: 'float', min:0, defVal: 10},
-	{name: 'dx2', dispName: 'Callout Width', type: 'float', min:0, defVal:70},
-	{name: 'dy2', dispName: 'Callout Height', type: 'float', min:0, defVal:70},
-	{name: 'arrowHead', dispName: 'ArrowHead Width', type: 'float', min:0, defVal:10}
+	{ name: 'dx1', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 20 },
+	{ name: 'dy1', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'dx2', dispName: 'Callout Width', type: 'float', min: 0, defVal: 70 },
+	{ name: 'dy2', dispName: 'Callout Height', type: 'float', min: 0, defVal: 70 },
+	{ name: 'arrowHead', dispName: 'ArrowHead Width', type: 'float', min: 0, defVal: 10 }
 ];
 
 mxShapeArrows2CalloutDouble90Arrow.prototype.cst = {
-		CALLOUT_DOUBLE_90_ARROW : 'mxgraph.arrows2.calloutDouble90Arrow'
+	CALLOUT_DOUBLE_90_ARROW: 'mxgraph.arrows2.calloutDouble90Arrow'
 };
 
 /**
@@ -1614,8 +1487,7 @@ mxShapeArrows2CalloutDouble90Arrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2CalloutDouble90Arrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2CalloutDouble90Arrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy1 = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
@@ -1651,55 +1523,47 @@ mxCellRenderer.registerShape(mxShapeArrows2CalloutDouble90Arrow.prototype.cst.CA
 
 mxShapeArrows2CalloutDouble90Arrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2CalloutDouble90Arrow.prototype.cst.CALLOUT_DOUBLE_90_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dx1 = Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
-				var dy1 = Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
-
-				return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - dy1);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['dx2', 'dy2'], function(bounds)
-			{
-				var dx2 = Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
-				var dy2 = Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2))));
-
-				return new mxPoint(bounds.x + dx2, bounds.y + dy2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
-				this.state.style['dy2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.y - bounds.y))) / 100;
-			});
+Graph.handleFactory[mxShapeArrows2CalloutDouble90Arrow.prototype.cst.CALLOUT_DOUBLE_90_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dx1 = Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
+		var dy1 = Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
+
+		return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - dy1);
+	}, function (bounds, pt) {
+		this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['dx2', 'dy2'], function (bounds) {
+		var dx2 = Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
+		var dy2 = Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2))));
+
+		return new mxPoint(bounds.x + dx2, bounds.y + dy2);
+	}, function (bounds, pt) {
+		this.state.style['dx2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
+		this.state.style['dy2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.y - bounds.y))) / 100;
+	});
 
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['arrowHead'], function(bounds)
-			{
-				var dx1 = 		Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
-				var dy1 =        Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
-				var arrowHead = Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - dy1 - arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) - pt.y))) / 100;
-			});
+
+	var handle3 = Graph.createHandle(state, ['arrowHead'], function (bounds) {
+		var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
+		var dy1 = Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
+		var arrowHead = Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - dy1 - arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) - pt.y))) / 100;
+	});
 
 	handles.push(handle3);
-	
+
 	return handles;
 };
 
-mxShapeArrows2CalloutDouble90Arrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2CalloutDouble90Arrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy1 = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
 	var dx1 = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
@@ -1722,7 +1586,7 @@ mxShapeArrows2CalloutDouble90Arrow.prototype.getConstraints = function(style, w,
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx2 / 2, h));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx2 / 2 - dy1 - arrowHead, h - dx1));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, dy2));
-	
+
 	return (constr);
 };
 
@@ -1732,8 +1596,7 @@ mxShapeArrows2CalloutDouble90Arrow.prototype.getConstraints = function(style, w,
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2QuadArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2QuadArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1751,13 +1614,13 @@ function mxShapeArrows2QuadArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2QuadArrow, mxActor);
 
 mxShapeArrows2QuadArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:20},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal:10},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:10}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 20 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 10 }
 ];
 
 mxShapeArrows2QuadArrow.prototype.cst = {
-		QUAD_ARROW : 'mxgraph.arrows2.quadArrow'
+	QUAD_ARROW: 'mxgraph.arrows2.quadArrow'
 };
 
 /**
@@ -1765,8 +1628,7 @@ mxShapeArrows2QuadArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2QuadArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2QuadArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -1806,41 +1668,35 @@ mxCellRenderer.registerShape(mxShapeArrows2QuadArrow.prototype.cst.QUAD_ARROW, m
 
 mxShapeArrows2QuadArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2QuadArrow.prototype.cst.QUAD_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(Math.min(bounds.width, bounds.height) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy - arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-			});
+Graph.handleFactory[mxShapeArrows2QuadArrow.prototype.cst.QUAD_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(Math.min(bounds.width, bounds.height) / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)) - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height / 2 - dy - arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+	});
 
 	handles.push(handle2);
-	
+
 	return handles;
 };
 
-mxShapeArrows2QuadArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2QuadArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -1866,7 +1722,7 @@ mxShapeArrows2QuadArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (dx - dy) * 0.5 + w * 0.25, h * 0.5 + dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (dy - dx) * 0.5 + w * 0.75, h * 0.5 - dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (dy - dx) * 0.5 + w * 0.75, h * 0.5 + dy));
-	
+
 	return (constr);
 };
 
@@ -1876,8 +1732,7 @@ mxShapeArrows2QuadArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2TriadArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2TriadArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1894,13 +1749,13 @@ function mxShapeArrows2TriadArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2TriadArrow, mxActor);
 
 mxShapeArrows2TriadArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:20},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal:10},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:40}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 20 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 40 }
 ];
 
 mxShapeArrows2TriadArrow.prototype.cst = {
-		TRIAD_ARROW : 'mxgraph.arrows2.triadArrow'
+	TRIAD_ARROW: 'mxgraph.arrows2.triadArrow'
 };
 
 /**
@@ -1908,8 +1763,7 @@ mxShapeArrows2TriadArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2TriadArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2TriadArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -1942,41 +1796,35 @@ mxCellRenderer.registerShape(mxShapeArrows2TriadArrow.prototype.cst.TRIAD_ARROW,
 
 mxShapeArrows2TriadArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2TriadArrow.prototype.cst.TRIAD_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				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(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.width / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + bounds.height - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height - arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)) * 2, bounds.y + bounds.height - pt.y))) / 100;
-			});
+Graph.handleFactory[mxShapeArrows2TriadArrow.prototype.cst.TRIAD_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		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(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height - dy);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), bounds.width / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + bounds.height - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['arrowHead'], 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 / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + bounds.height - arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(bounds.height - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)) * 2, bounds.y + bounds.height - pt.y))) / 100;
+	});
 
 	handles.push(handle2);
-	
+
 	return handles;
 };
 
-mxShapeArrows2TriadArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2TriadArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -1998,7 +1846,7 @@ mxShapeArrows2TriadArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w * 0.5 + dx - arrowHead * 0.5 + dy) * 0.5, h - dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w * 0.5 - arrowHead * 0.5 + dy, (dx + h - arrowHead + dy) * 0.5));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w * 0.5 + arrowHead * 0.5 - dy, (dx + h - arrowHead + dy) * 0.5));
-	
+
 	return (constr);
 };
 
@@ -2008,8 +1856,7 @@ mxShapeArrows2TriadArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2TailedArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2TailedArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2027,16 +1874,16 @@ function mxShapeArrows2TailedArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2TailedArrow, mxActor);
 
 mxShapeArrows2TailedArrow.prototype.customProperties = [
-	{name: 'dx1', dispName: 'Arrowhead Length', type: 'float', min:0, defVal: 20},
-	{name: 'dy1', dispName: 'Arrow Width', type: 'float', min:0, defVal: 10},
-	{name: 'dx2', dispName: 'Tail Length', type: 'float', min:0, defVal: 25},
-	{name: 'dy2', dispName: 'Tail Width', type: 'float', min:0, defVal:30},
-	{name: 'notch', dispName: 'Notch', type: 'float', min:0, defVal: 0},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:20}
+	{ name: 'dx1', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 20 },
+	{ name: 'dy1', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'dx2', dispName: 'Tail Length', type: 'float', min: 0, defVal: 25 },
+	{ name: 'dy2', dispName: 'Tail Width', type: 'float', min: 0, defVal: 30 },
+	{ name: 'notch', dispName: 'Notch', type: 'float', min: 0, defVal: 0 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 20 }
 ];
 
 mxShapeArrows2TailedArrow.prototype.cst = {
-		TAILED_ARROW : 'mxgraph.arrows2.tailedArrow'
+	TAILED_ARROW: 'mxgraph.arrows2.tailedArrow'
 };
 
 /**
@@ -2044,8 +1891,7 @@ mxShapeArrows2TailedArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2TailedArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2TailedArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy1 = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
@@ -2055,9 +1901,8 @@ mxShapeArrows2TailedArrow.prototype.paintVertexShape = function(c, x, y, w, h)
 	var notch = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'notch', this.notch))));
 	var arrowHead = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'arrowHead', this.arrowHead))));
 	var x2 = 0;
-	
-	if (dy2 != 0)
-	{
+
+	if (dy2 != 0) {
 		x2 = dx2 + dy2 * (dy2 - dy1) / dy2;
 	}
 
@@ -2082,68 +1927,58 @@ mxCellRenderer.registerShape(mxShapeArrows2TailedArrow.prototype.cst.TAILED_ARRO
 
 mxShapeArrows2TailedArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2TailedArrow.prototype.cst.TAILED_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
-				var dy1 = Math.max(0, Math.min(bounds.height / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
-
-				return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + bounds.height / 2 - dy1);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), pt.x - bounds.x))) / 100;
-			});
+Graph.handleFactory[mxShapeArrows2TailedArrow.prototype.cst.TAILED_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
+		var dy1 = Math.max(0, Math.min(bounds.height / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
+
+		return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + bounds.height / 2 - dy1);
+	}, function (bounds, pt) {
+		this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), pt.x - bounds.x))) / 100;
+	});
 
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['arrowHead'], function(bounds)
-			{
-				var dx1 = 		Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
-				var dy1 =        Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + bounds.height / 2 - dy1 - arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-			});
+
+	var handle3 = Graph.createHandle(state, ['arrowHead'], function (bounds) {
+		var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
+		var dy1 = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + bounds.height / 2 - dy1 - arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+	});
 
 	handles.push(handle3);
-	
-	var handle4 = Graph.createHandle(state, ['dx2', 'dy2'], function(bounds)
-			{
-				var dx2 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
-				var dy2 = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2))));
-
-				return new mxPoint(bounds.x + dx2, bounds.y + bounds.height / 2 - dy2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)) - parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) + parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) - 1, pt.x - bounds.x))) / 100;
-				this.state.style['dy2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), Math.min(bounds.height / 2, bounds.y + bounds.height / 2 - pt.y))) / 100;
-				
-			});
+
+	var handle4 = Graph.createHandle(state, ['dx2', 'dy2'], function (bounds) {
+		var dx2 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
+		var dy2 = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2))));
+
+		return new mxPoint(bounds.x + dx2, bounds.y + bounds.height / 2 - dy2);
+	}, function (bounds, pt) {
+		this.state.style['dx2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)) - parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)) + parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)) - 1, pt.x - bounds.x))) / 100;
+		this.state.style['dy2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), Math.min(bounds.height / 2, bounds.y + bounds.height / 2 - pt.y))) / 100;
+
+	});
 
 	handles.push(handle4);
 
 	return handles;
 };
 
-mxShapeArrows2TailedArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2TailedArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy1 = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
 	var dx1 = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
@@ -2152,9 +1987,8 @@ mxShapeArrows2TailedArrow.prototype.getConstraints = function(style, w, h)
 	var notch = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'notch', this.notch))));
 	var arrowHead = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'arrowHead', this.arrowHead))));
 	var x2 = 0;
-	
-	if (dy2 != 0)
-	{
+
+	if (dy2 != 0) {
 		x2 = dx2 + dy2 * (dy2 - dy1) / dy2;
 	}
 
@@ -2168,7 +2002,7 @@ mxShapeArrows2TailedArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - dx1 + x2) * 0.5, h * 0.5 + dy1));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx1, h * 0.5 + dy1 + arrowHead));
 	constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
-	
+
 	return (constr);
 };
 
@@ -2178,8 +2012,7 @@ mxShapeArrows2TailedArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2TailedNotchedArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2TailedNotchedArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2197,16 +2030,16 @@ function mxShapeArrows2TailedNotchedArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2TailedNotchedArrow, mxActor);
 
 mxShapeArrows2TailedNotchedArrow.prototype.customProperties = [
-	{name: 'dx1', dispName: 'Arrowhead Length', type: 'float', mix:0, defVal:20},
-	{name: 'dy1', dispName: 'Arrow Width', type: 'float', min:0, defVal:10},
-	{name: 'dx2', dispName: 'Tail Length', type: 'float', min:0, defVal:25},
-	{name: 'dy2', dispName: 'Tail Width', type: 'float', min:0, defVal:30},
-	{name: 'notch', dispName: 'Notch', type: 'float', min:0, defVal:20},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:20}
+	{ name: 'dx1', dispName: 'Arrowhead Length', type: 'float', mix: 0, defVal: 20 },
+	{ name: 'dy1', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 10 },
+	{ name: 'dx2', dispName: 'Tail Length', type: 'float', min: 0, defVal: 25 },
+	{ name: 'dy2', dispName: 'Tail Width', type: 'float', min: 0, defVal: 30 },
+	{ name: 'notch', dispName: 'Notch', type: 'float', min: 0, defVal: 20 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 20 }
 ];
 
 mxShapeArrows2TailedNotchedArrow.prototype.cst = {
-		TAILED_NOTCHED_ARROW : 'mxgraph.arrows2.tailedNotchedArrow'
+	TAILED_NOTCHED_ARROW: 'mxgraph.arrows2.tailedNotchedArrow'
 };
 
 /**
@@ -2214,8 +2047,7 @@ mxShapeArrows2TailedNotchedArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2TailedNotchedArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2TailedNotchedArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy1 = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
@@ -2225,9 +2057,8 @@ mxShapeArrows2TailedNotchedArrow.prototype.paintVertexShape = function(c, x, y,
 	var notch = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'notch', this.notch))));
 	var arrowHead = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'arrowHead', this.arrowHead))));
 	var x2 = 0;
-	
-	if (dy2 != 0)
-	{
+
+	if (dy2 != 0) {
 		x2 = dx2 + notch * (dy2 - dy1) / dy2;
 	}
 
@@ -2252,68 +2083,58 @@ mxCellRenderer.registerShape(mxShapeArrows2TailedNotchedArrow.prototype.cst.TAIL
 
 mxShapeArrows2TailedNotchedArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2TailedNotchedArrow.prototype.cst.TAILED_NOTCHED_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
-				var dy1 = Math.max(0, Math.min(bounds.height / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
-
-				return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + bounds.height / 2 - dy1);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))- parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
-			});
+Graph.handleFactory[mxShapeArrows2TailedNotchedArrow.prototype.cst.TAILED_NOTCHED_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx1', 'dy1'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
+		var dy1 = Math.max(0, Math.min(bounds.height / 2 - arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
+
+		return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + bounds.height / 2 - dy1);
+	}, function (bounds, pt) {
+		this.state.style['dx1'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)) - parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy1'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)), parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
+	});
 
 	handles.push(handle2);
-	
-	var handle3 = Graph.createHandle(state, ['arrowHead'], function(bounds)
-			{
-				var dx1 = 		Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
-				var dy1 =        Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
-				var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + bounds.height / 2 - dy1 - arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), bounds.y + bounds.height / 2 - pt.y))) / 100;
-			});
+
+	var handle3 = Graph.createHandle(state, ['arrowHead'], function (bounds) {
+		var dx1 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1))));
+		var dy1 = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1))));
+		var arrowHead = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx1, bounds.y + bounds.height / 2 - dy1 - arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(0, Math.min(bounds.height / 2 - parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), bounds.y + bounds.height / 2 - pt.y))) / 100;
+	});
 
 	handles.push(handle3);
-	
-	var handle4 = Graph.createHandle(state, ['dx2', 'dy2'], function(bounds)
-			{
-				var dx2 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
-				var dy2 = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2))));
-
-				return new mxPoint(bounds.x + dx2, bounds.y + bounds.height / 2 - dy2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)) - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
-				this.state.style['dy2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), Math.min(bounds.height / 2, bounds.y + bounds.height / 2 - pt.y))) / 100;
-				
-			});
+
+	var handle4 = Graph.createHandle(state, ['dx2', 'dy2'], function (bounds) {
+		var dx2 = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
+		var dy2 = Math.max(0, Math.min(bounds.height / 2, parseFloat(mxUtils.getValue(this.state.style, 'dy2', this.dy2))));
+
+		return new mxPoint(bounds.x + dx2, bounds.y + bounds.height / 2 - dy2);
+	}, function (bounds, pt) {
+		this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)) - parseFloat(mxUtils.getValue(this.state.style, 'dx1', this.dx1)), pt.x - bounds.x))) / 100;
+		this.state.style['dy2'] = Math.round(100 * Math.max(parseFloat(mxUtils.getValue(this.state.style, 'dy1', this.dy1)), Math.min(bounds.height / 2, bounds.y + bounds.height / 2 - pt.y))) / 100;
+
+	});
 
 	handles.push(handle4);
 
 	return handles;
 };
 
-mxShapeArrows2TailedNotchedArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2TailedNotchedArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy1 = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy1', this.dy1))));
 	var dx1 = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx1', this.dx1))));
@@ -2322,9 +2143,8 @@ mxShapeArrows2TailedNotchedArrow.prototype.getConstraints = function(style, w, h
 	var notch = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'notch', this.notch))));
 	var arrowHead = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'arrowHead', this.arrowHead))));
 	var x2 = 0;
-	
-	if (dy2 != 0)
-	{
+
+	if (dy2 != 0) {
 		x2 = dx2 + notch * (dy2 - dy1) / dy2;
 	}
 
@@ -2338,7 +2158,7 @@ mxShapeArrows2TailedNotchedArrow.prototype.getConstraints = function(style, w, h
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - dx1 + x2) * 0.5, h * 0.5 + dy1));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx1, h * 0.5 + dy1 + arrowHead));
 	constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
-	
+
 	return (constr);
 };
 
@@ -2348,8 +2168,7 @@ mxShapeArrows2TailedNotchedArrow.prototype.getConstraints = function(style, w, h
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2StripedArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2StripedArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2366,13 +2185,13 @@ function mxShapeArrows2StripedArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2StripedArrow, mxActor);
 
 mxShapeArrows2StripedArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:40},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, max:1, defVal:0.6},
-	{name: 'notch', dispName: 'Stripes Length', type: 'float', min:0, defVal:25}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 40 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, max: 1, defVal: 0.6 },
+	{ name: 'notch', dispName: 'Stripes Length', type: 'float', min: 0, defVal: 25 }
 ];
 
 mxShapeArrows2StripedArrow.prototype.cst = {
-		STRIPED_ARROW : 'mxgraph.arrows2.stripedArrow'
+	STRIPED_ARROW: 'mxgraph.arrows2.stripedArrow'
 };
 
 /**
@@ -2380,8 +2199,7 @@ mxShapeArrows2StripedArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2StripedArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2StripedArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -2414,37 +2232,31 @@ mxCellRenderer.registerShape(mxShapeArrows2StripedArrow.prototype.cst.STRIPED_AR
 
 mxShapeArrows2StripedArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2StripedArrow.prototype.cst.STRIPED_ARROW] = 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(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + dy * bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['notch'], function(bounds)
-			{
-				var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
-
-				return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
-			}, function(bounds, pt)
-			{
-				this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2StripedArrow.prototype.cst.STRIPED_ARROW] = 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(1, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + dy * bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch)), bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(1, (((pt.y - bounds.y) / bounds.height) * 2)))) / 100;
+	})];
+
+	var handle2 = Graph.createHandle(state, ['notch'], function (bounds) {
+		var notch = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'notch', this.notch))));
+
+		return new mxPoint(bounds.x + notch, bounds.y + bounds.height / 2);
+	}, function (bounds, pt) {
+		this.state.style['notch'] = Math.round(100 * Math.max(0, Math.min(bounds.width - parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx)), pt.x - bounds.x))) / 100;
+	});
+
 	handles.push(handle2);
-	
+
 	return handles;
 };
 
-mxShapeArrows2StripedArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2StripedArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = h * 0.5 * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -2460,7 +2272,7 @@ mxShapeArrows2StripedArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, h));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - dx) * 0.5, dy));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - dx) * 0.5, h - dy));
-	
+
 	return (constr);
 };
 
@@ -2470,8 +2282,7 @@ mxShapeArrows2StripedArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2JumpInArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2JumpInArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2488,13 +2299,13 @@ function mxShapeArrows2JumpInArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2JumpInArrow, mxActor);
 
 mxShapeArrows2JumpInArrow.prototype.customProperties = [
-	{name: 'dx', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:38},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal:15},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:55}
+	{ name: 'dx', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 38 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 15 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 55 }
 ];
 
 mxShapeArrows2JumpInArrow.prototype.cst = {
-		JUMP_IN_ARROW : 'mxgraph.arrows2.jumpInArrow'
+	JUMP_IN_ARROW: 'mxgraph.arrows2.jumpInArrow'
 };
 
 /**
@@ -2502,8 +2313,7 @@ mxShapeArrows2JumpInArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2JumpInArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2JumpInArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
@@ -2525,40 +2335,34 @@ mxCellRenderer.registerShape(mxShapeArrows2JumpInArrow.prototype.cst.JUMP_IN_ARR
 
 mxShapeArrows2JumpInArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2JumpInArrow.prototype.cst.JUMP_IN_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				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(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-		
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead / 2 - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width, bounds.x + bounds.width - pt.x))) / 100;
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - pt.y))) / 100;
-				
-			})];
-			
-	var handle2 = Graph.createHandle(state, ['arrowHead'], function(bounds)
-			{
-				var dx = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-
-				return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(bounds.height, pt.y - bounds.y))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2JumpInArrow.prototype.cst.JUMP_IN_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dx', 'dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		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(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead / 2 - dy);
+	}, function (bounds, pt) {
+		this.state.style['dx'] = Math.round(100 * Math.max(0, Math.min(bounds.width, bounds.x + bounds.width - pt.x))) / 100;
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['arrowHead'], function (bounds) {
+		var dx = Math.max(0, Math.min(bounds.width, parseFloat(mxUtils.getValue(this.state.style, 'dx', this.dx))));
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+
+		return new mxPoint(bounds.x + bounds.width - dx, bounds.y + arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(bounds.height, pt.y - bounds.y))) / 100;
+	});
+
 	handles.push(handle2);
 
 	return handles;
 };
 
-mxShapeArrows2JumpInArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2JumpInArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var dx = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
@@ -2568,7 +2372,7 @@ mxShapeArrows2JumpInArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, 0));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w, arrowHead * 0.5));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, arrowHead));
-	
+
 	return (constr);
 };
 
@@ -2578,8 +2382,7 @@ mxShapeArrows2JumpInArrow.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeArrows2UTurnArrow(bounds, fill, stroke, strokewidth)
-{
+function mxShapeArrows2UTurnArrow(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2596,13 +2399,13 @@ function mxShapeArrows2UTurnArrow(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeArrows2UTurnArrow, mxActor);
 
 mxShapeArrows2UTurnArrow.prototype.customProperties = [
-	{name: 'dx2', dispName: 'Arrowhead Length', type: 'float', min:0, defVal:25},
-	{name: 'dy', dispName: 'Arrow Width', type: 'float', min:0, defVal:11},
-	{name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min:0, defVal:43}
+	{ name: 'dx2', dispName: 'Arrowhead Length', type: 'float', min: 0, defVal: 25 },
+	{ name: 'dy', dispName: 'Arrow Width', type: 'float', min: 0, defVal: 11 },
+	{ name: 'arrowHead', dispName: 'Arrowhead Width', type: 'float', min: 0, defVal: 43 }
 ];
 
 mxShapeArrows2UTurnArrow.prototype.cst = {
-		U_TURN_ARROW : 'mxgraph.arrows2.uTurnArrow'
+	U_TURN_ARROW: 'mxgraph.arrows2.uTurnArrow'
 };
 
 /**
@@ -2610,15 +2413,14 @@ mxShapeArrows2UTurnArrow.prototype.cst = {
 * 
 * Paints the vertex shape.
 */
-mxShapeArrows2UTurnArrow.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+mxShapeArrows2UTurnArrow.prototype.paintVertexShape = function (c, x, y, w, h) {
 	c.translate(x, y);
 
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var arrowHead = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'arrowHead', this.arrowHead))));
 	var dx = (h - arrowHead / 2 + dy) / 2;
 	var dx2 = Math.max(0, parseFloat(mxUtils.getValue(this.style, 'dx2', this.dx2)));
-	
+
 	c.begin();
 	c.moveTo(dx, 0);
 	c.lineTo(dx + dx2, arrowHead * 0.5);
@@ -2637,65 +2439,57 @@ mxCellRenderer.registerShape(mxShapeArrows2UTurnArrow.prototype.cst.U_TURN_ARROW
 
 mxShapeArrows2UTurnArrow.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeArrows2UTurnArrow.prototype.cst.U_TURN_ARROW] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dy'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var dx = (bounds.height - arrowHead / 2 + dy) / 2;
-
-				return new mxPoint(bounds.x + dx, bounds.y + arrowHead / 2 - dy);
-			}, function(bounds, pt)
-			{
-				this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - pt.y))) / 100;
-				
-			})];
-
-	var handle2 = Graph.createHandle(state, ['dx2'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var dx = (bounds.height - arrowHead / 2 + dy) / 2;
-				
-				var dx2 = Math.max(0, Math.min(bounds.width - dx, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
-
-				return new mxPoint(bounds.x + dx + dx2, bounds.y + arrowHead / 2);
-			}, function(bounds, pt)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var dx = (bounds.height - arrowHead / 2 + dy) / 2;
-				this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(Math.max(bounds.width, dx), pt.x - bounds.x - dx))) / 100;
-			});
-	
+Graph.handleFactory[mxShapeArrows2UTurnArrow.prototype.cst.U_TURN_ARROW] = function (state) {
+	var handles = [Graph.createHandle(state, ['dy'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var dx = (bounds.height - arrowHead / 2 + dy) / 2;
+
+		return new mxPoint(bounds.x + dx, bounds.y + arrowHead / 2 - dy);
+	}, function (bounds, pt) {
+		this.state.style['dy'] = Math.round(100 * Math.max(0, Math.min(parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2, bounds.y + parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead)) / 2 - pt.y))) / 100;
+
+	})];
+
+	var handle2 = Graph.createHandle(state, ['dx2'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var dx = (bounds.height - arrowHead / 2 + dy) / 2;
+
+		var dx2 = Math.max(0, Math.min(bounds.width - dx, parseFloat(mxUtils.getValue(this.state.style, 'dx2', this.dx2))));
+
+		return new mxPoint(bounds.x + dx + dx2, bounds.y + arrowHead / 2);
+	}, function (bounds, pt) {
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var dx = (bounds.height - arrowHead / 2 + dy) / 2;
+		this.state.style['dx2'] = Math.round(100 * Math.max(0, Math.min(Math.max(bounds.width, dx), pt.x - bounds.x - dx))) / 100;
+	});
+
 	handles.push(handle2);
 
-	var handle3 = Graph.createHandle(state, ['arrowHead'], function(bounds)
-			{
-				var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
-				var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
-				var dx = (bounds.height - arrowHead / 2 + dy) / 2;
-
-				return new mxPoint(bounds.x + dx, bounds.y + arrowHead);
-			}, function(bounds, pt)
-			{
-				this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(bounds.height / 2, pt.y - bounds.y))) / 100;
-			});
-	
+	var handle3 = Graph.createHandle(state, ['arrowHead'], function (bounds) {
+		var arrowHead = Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(this.state.style, 'arrowHead', this.arrowHead))));
+		var dy = Math.max(0, Math.min(arrowHead, parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy))));
+		var dx = (bounds.height - arrowHead / 2 + dy) / 2;
+
+		return new mxPoint(bounds.x + dx, bounds.y + arrowHead);
+	}, function (bounds, pt) {
+		this.state.style['arrowHead'] = Math.round(100 * Math.max(2 * parseFloat(mxUtils.getValue(this.state.style, 'dy', this.dy)), Math.min(bounds.height / 2, pt.y - bounds.y))) / 100;
+	});
+
 	handles.push(handle3);
 
 	return handles;
 };
 
-mxShapeArrows2UTurnArrow.prototype.getConstraints = function(style, w, h)
-{
+mxShapeArrows2UTurnArrow.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var arrowHead = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'arrowHead', this.arrowHead))));
 	var dx = (h - arrowHead / 2 + dy) / 2;
 	var dx2 = Math.max(0, parseFloat(mxUtils.getValue(this.style, 'dx2', this.dx2)));
-	
+
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, 0));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx + dx2, arrowHead * 0.5));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, arrowHead));
@@ -2707,15 +2501,14 @@ mxShapeArrows2UTurnArrow.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, h));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, (h + arrowHead * 0.5 - dy) * 0.5));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, arrowHead - 2 * dy, (h + arrowHead * 0.5 - dy) * 0.5));
-	
+
 	return (constr);
 };
 
 //**********************************************************************************************************************************************************
 //Wedge Arrow
 //**********************************************************************************************************************************************************
-function mxShapeArrowsWedgeArrow()
-{
+function mxShapeArrowsWedgeArrow() {
 	mxArrow.call(this);
 };
 
@@ -2724,11 +2517,10 @@ mxUtils.extend(mxShapeArrowsWedgeArrow, mxArrow);
 mxShapeArrowsWedgeArrow.prototype.useSvgBoundingBox = true;
 
 mxShapeArrowsWedgeArrow.prototype.customProperties = [
-	{name: 'startWidth', dispName: 'Wedge Width', type: 'float', min:0, defVal:25}
+	{ name: 'startWidth', dispName: 'Wedge Width', type: 'float', min: 0, defVal: 25 }
 ];
 
-mxShapeArrowsWedgeArrow.prototype.paintEdgeShape = function(c, pts)
-{
+mxShapeArrowsWedgeArrow.prototype.paintEdgeShape = function (c, pts) {
 	var sw = Math.max(0, parseFloat(mxUtils.getValue(this.style, 'startWidth', 20)));
 
 	// Base vector (between end points)
@@ -2737,7 +2529,7 @@ mxShapeArrowsWedgeArrow.prototype.paintEdgeShape = function(c, pts)
 
 	var dx = pe.x - p0.x;
 	var dy = pe.y - p0.y;
-	var dist = Math.sqrt(dx * dx + dy * dy);	
+	var dist = Math.sqrt(dx * dx + dy * dy);
 	var nx = dx * sw / dist;
 	var ny = dy * sw / dist;
 
@@ -2754,8 +2546,7 @@ mxCellRenderer.registerShape('mxgraph.arrows2.wedgeArrow', mxShapeArrowsWedgeArr
 //**********************************************************************************************************************************************************
 //Wedge Arrow Dashed
 //**********************************************************************************************************************************************************
-function mxShapeArrowsWedgeArrowDashed()
-{
+function mxShapeArrowsWedgeArrowDashed() {
 	mxArrowConnector.call(this);
 };
 
@@ -2764,11 +2555,10 @@ mxUtils.extend(mxShapeArrowsWedgeArrowDashed, mxArrow);
 mxShapeArrowsWedgeArrowDashed.prototype.useSvgBoundingBox = true;
 
 mxShapeArrowsWedgeArrowDashed.prototype.customProperties = [
-	{name: 'startWidth', dispName: 'Wedge Width', type: 'float', min:0, defVal:25}
+	{ name: 'startWidth', dispName: 'Wedge Width', type: 'float', min: 0, defVal: 25 }
 ];
 
-mxShapeArrowsWedgeArrowDashed.prototype.paintEdgeShape = function(c, pts)
-{
+mxShapeArrowsWedgeArrowDashed.prototype.paintEdgeShape = function (c, pts) {
 	var startWidth = Math.max(0, parseFloat(mxUtils.getValue(this.style, 'startWidth', 20)));
 	var steps = 8;
 	// Base vector (between end points)
@@ -2777,7 +2567,7 @@ mxShapeArrowsWedgeArrowDashed.prototype.paintEdgeShape = function(c, pts)
 
 	var dx = pe.x - p0.x;
 	var dy = pe.y - p0.y;
-	var dist = Math.sqrt(dx * dx + dy * dy);	
+	var dist = Math.sqrt(dx * dx + dy * dy);
 	var nx = dx * startWidth / dist;
 	var ny = dy * startWidth / dist;
 	var cnx = nx; // current nx
@@ -2786,30 +2576,28 @@ mxShapeArrowsWedgeArrowDashed.prototype.paintEdgeShape = function(c, pts)
 	var pcy = p0.y; // current y on edge
 
 	c.begin();
-	
- 	for (var i = 0; i <= steps; i++)
-	{
+
+	for (var i = 0; i <= steps; i++) {
 		cnx = nx * (steps - i) / steps;
 		cny = ny * (steps - i) / steps;
 
-		if (i == steps)
-		{
+		if (i == steps) {
 			cnx = nx * (steps - i * 0.98) / steps;
 			cny = ny * (steps - i * 0.98) / steps;
 		}
-		
+
 		var px1 = pcx + cny;
 		var py1 = pcy - cnx;
 		var px2 = pcx - cny;
 		var py2 = pcy + cnx;
-			
+
 		c.moveTo(px1, py1);
 		c.lineTo(px2, py2);
-		
+
 		pcx = pcx + dx / steps;
 		pcy = pcy + dy / steps;
-	} 
-	
+	}
+
 	c.stroke();
 };
 
@@ -2818,8 +2606,7 @@ mxCellRenderer.registerShape('mxgraph.arrows2.wedgeArrowDashed', mxShapeArrowsWe
 //**********************************************************************************************************************************************************
 //Wedge Arrow Dashed v2
 //**********************************************************************************************************************************************************
-function mxShapeArrowsWedgeArrowDashed2()
-{
+function mxShapeArrowsWedgeArrowDashed2() {
 	mxArrowConnector.call(this);
 };
 
@@ -2828,12 +2615,11 @@ mxUtils.extend(mxShapeArrowsWedgeArrowDashed2, mxArrow);
 mxShapeArrowsWedgeArrowDashed2.prototype.useSvgBoundingBox = true;
 
 mxShapeArrowsWedgeArrowDashed2.prototype.customProperties = [
-	{name: 'startWidth', dispName: 'Wedge Width', type: 'float', min:0, defVal:25},
-	{name: 'stepSize', dispName: 'Step Size', type: 'float', min:0, defVal:25}
+	{ name: 'startWidth', dispName: 'Wedge Width', type: 'float', min: 0, defVal: 25 },
+	{ name: 'stepSize', dispName: 'Step Size', type: 'float', min: 0, defVal: 25 }
 ];
 
-mxShapeArrowsWedgeArrowDashed2.prototype.paintEdgeShape = function(c, pts)
-{
+mxShapeArrowsWedgeArrowDashed2.prototype.paintEdgeShape = function (c, pts) {
 	var startWidth = Math.max(0, parseFloat(mxUtils.getValue(this.style, 'startWidth', 20)));
 	var stepSize = Math.max(0, parseFloat(mxUtils.getValue(this.style, 'stepSize', 10)));
 
@@ -2843,7 +2629,7 @@ mxShapeArrowsWedgeArrowDashed2.prototype.paintEdgeShape = function(c, pts)
 
 	var dx = pe.x - p0.x;
 	var dy = pe.y - p0.y;
-	var dist = Math.sqrt(dx * dx + dy * dy);	
+	var dist = Math.sqrt(dx * dx + dy * dy);
 	var nx = dx * startWidth / dist;
 	var ny = dy * startWidth / dist;
 	var cnx = nx; // current nx
@@ -2853,30 +2639,28 @@ mxShapeArrowsWedgeArrowDashed2.prototype.paintEdgeShape = function(c, pts)
 	var steps = Math.floor(dist / stepSize);
 
 	c.begin();
-	
- 	for (var i = 0; i <= steps; i++)
-	{
+
+	for (var i = 0; i <= steps; i++) {
 		cnx = nx * (steps - i) / steps;
 		cny = ny * (steps - i) / steps;
 
-		if (i == steps)
-		{
+		if (i == steps) {
 			cnx = nx * (steps - i * 0.98) / steps;
 			cny = ny * (steps - i * 0.98) / steps;
 		}
-		
+
 		var px1 = pcx + cny;
 		var py1 = pcy - cnx;
 		var px2 = pcx - cny;
 		var py2 = pcy + cnx;
-			
+
 		c.moveTo(px1, py1);
 		c.lineTo(px2, py2);
-		
+
 		pcx = pcx + dx / steps;
 		pcy = pcy + dy / steps;
-	} 
-	
+	}
+
 	c.stroke();
 };
 

@@ -8,8 +8,7 @@
 /**
 * Extends mxShape.
 */
-function mxShapeBasicCross(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicCross(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -23,15 +22,14 @@ function mxShapeBasicCross(bounds, fill, stroke, strokewidth)
 */
 mxUtils.extend(mxShapeBasicCross, mxActor);
 
-mxShapeBasicCross.prototype.cst = {CROSS : 'mxgraph.basic.cross2'};
+mxShapeBasicCross.prototype.cst = { CROSS: 'mxgraph.basic.cross2' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicCross.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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))));
@@ -57,18 +55,15 @@ mxCellRenderer.registerShape(mxShapeBasicCross.prototype.cst.CROSS, mxShapeBasic
 
 mxShapeBasicCross.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicCross.prototype.cst.CROSS] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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;
 };
 
@@ -78,8 +73,7 @@ Graph.handleFactory[mxShapeBasicCross.prototype.cst.CROSS] = function(state)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicRectCallout(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicRectCallout(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -95,19 +89,18 @@ function mxShapeBasicRectCallout(bounds, fill, stroke, strokewidth)
 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: 'dx', dispName: 'Callout Position', type: 'float', min: 0, defVal: 30 },
+	{ name: 'dy', dispName: 'Callout Size', type: 'float', min: 0, defVal: 15 }
 ];
 
-mxShapeBasicRectCallout.prototype.cst = {RECT_CALLOUT : 'mxgraph.basic.rectCallout'};
+mxShapeBasicRectCallout.prototype.cst = { RECT_CALLOUT: 'mxgraph.basic.rectCallout' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicRectCallout.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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))));
@@ -125,38 +118,32 @@ mxShapeBasicRectCallout.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.fillAndStroke();
 };
 
-mxShapeBasicRectCallout.prototype.getLabelMargins = function()
-{
-	if (mxUtils.getValue(this.style, 'boundedLbl', false))
-	{
+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)
-	{
+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)
-	{
+	}, 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)
-{
+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))));
@@ -181,8 +168,7 @@ mxShapeBasicRectCallout.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicRoundRectCallout(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicRoundRectCallout(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -198,14 +184,14 @@ function mxShapeBasicRoundRectCallout(bounds, fill, stroke, strokewidth)
 */
 mxUtils.extend(mxShapeBasicRoundRectCallout, mxActor);
 
-mxShapeBasicRoundRectCallout.prototype.cst = {ROUND_RECT_CALLOUT : 'mxgraph.basic.roundRectCallout'};
+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: '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 }
 ];
 
 /**
@@ -213,8 +199,7 @@ mxShapeBasicRoundRectCallout.prototype.customProperties = [
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicRoundRectCallout.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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))));
@@ -224,7 +209,7 @@ mxShapeBasicRoundRectCallout.prototype.paintVertexShape = function(c, x, y, w, h
 	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);
@@ -246,33 +231,27 @@ mxCellRenderer.registerShape(mxShapeBasicRoundRectCallout.prototype.cst.ROUND_RE
 
 mxShapeBasicRoundRectCallout.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicRoundRectCallout.prototype.cst.ROUND_RECT_CALLOUT] = function(state)
-{
-	return [Graph.createHandle(state, ['dx', 'dy'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-	{
+	}), 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)
-	{
+	}, 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)
-{
+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))));
@@ -281,15 +260,13 @@ mxShapeBasicRoundRectCallout.prototype.getConstraints = function(style, w, h)
 	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)
-	{
+
+	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));
 	}
-	
-	if (r < (h - dy) * 0.25)
-	{
+
+	if (r < (h - dy) * 0.25) {
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w, (h - dy) * 0.25));
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w, (h - dy) * 0.75));
 		constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, (h - dy) * 0.25));
@@ -314,8 +291,7 @@ mxShapeBasicRoundRectCallout.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicWave(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicWave(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -330,23 +306,22 @@ function mxShapeBasicWave(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicWave, mxActor);
 
 mxShapeBasicWave.prototype.customProperties = [
-	{name: 'dy', dispName: 'Wave Size', type: 'float', min:0, max:1, defVal: 0.3}
+	{ name: 'dy', dispName: 'Wave Size', type: 'float', min: 0, max: 1, defVal: 0.3 }
 ];
 
-mxShapeBasicWave.prototype.cst = {WAVE : 'mxgraph.basic.wave2'};
+mxShapeBasicWave.prototype.cst = { WAVE: 'mxgraph.basic.wave2' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicWave.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -364,27 +339,23 @@ mxCellRenderer.registerShape(mxShapeBasicWave.prototype.cst.WAVE, mxShapeBasicWa
 
 mxShapeBasicWave.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicWave.prototype.cst.WAVE] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dy'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+mxShapeBasicWave.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dy = h * Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'dy', this.dy))));
 	var fy = 1.4
-	
+
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, dy * 0.5));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w / 6, h * 0.015));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w / 3, dy * 0.5));
@@ -411,8 +382,7 @@ mxShapeBasicWave.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicOctagon(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicOctagon(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -427,24 +397,23 @@ function mxShapeBasicOctagon(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicOctagon, mxActor);
 
 mxShapeBasicOctagon.prototype.customProperties = [
-	{name: 'dx', dispName: 'Cutoff Size', type: 'float', min:0, defVal:15}
+	{ name: 'dx', dispName: 'Cutoff Size', type: 'float', min: 0, defVal: 15 }
 ];
 
-mxShapeBasicOctagon.prototype.cst = {OCTAGON : 'mxgraph.basic.octagon2'};
+mxShapeBasicOctagon.prototype.cst = { OCTAGON: 'mxgraph.basic.octagon2' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicOctagon.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -462,28 +431,24 @@ mxCellRenderer.registerShape(mxShapeBasicOctagon.prototype.cst.OCTAGON, mxShapeB
 
 mxShapeBasicOctagon.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicOctagon.prototype.cst.OCTAGON] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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));
@@ -502,8 +467,7 @@ mxShapeBasicOctagon.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicIsoCube(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicIsoCube(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -518,23 +482,22 @@ function mxShapeBasicIsoCube(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicIsoCube, mxActor);
 
 mxShapeBasicIsoCube.prototype.customProperties = [
-	{name: 'isoAngle', dispName: 'Perspective Angle', type: 'float', min:0, defVal:15}
+	{ name: 'isoAngle', dispName: 'Perspective Angle', type: 'float', min: 0, defVal: 15 }
 ];
 
-mxShapeBasicIsoCube.prototype.cst = {ISO_CUBE : 'mxgraph.basic.isocube'};
+mxShapeBasicIsoCube.prototype.cst = { ISO_CUBE: 'mxgraph.basic.isocube' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicIsoCube.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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 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);
@@ -546,7 +509,7 @@ mxShapeBasicIsoCube.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.fillAndStroke();
 
 	c.setShadow(false);
-	
+
 	c.begin();
 	c.moveTo(0, isoH);
 	c.lineTo(w * 0.5, 2 * isoH);
@@ -560,28 +523,24 @@ mxCellRenderer.registerShape(mxShapeBasicIsoCube.prototype.cst.ISO_CUBE, mxShape
 
 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 ;
+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)
-	{
+	}, 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)
-{
+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 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);
-	
+
 	constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w, isoH));
 	constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false));
@@ -600,8 +559,7 @@ mxShapeBasicIsoCube.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicTriangleAcute(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicTriangleAcute(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -616,22 +574,21 @@ function mxShapeBasicTriangleAcute(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicTriangleAcute, mxActor);
 
 mxShapeBasicTriangleAcute.prototype.customProperties = [
-	{name: 'dx', dispName: 'Top', type: 'float', min:0, max:1, defVal:0.5}
+	{ name: 'dx', dispName: 'Top', type: 'float', min: 0, max: 1, defVal: 0.5 }
 ];
 
-mxShapeBasicTriangleAcute.prototype.cst = {ACUTE_TRIANGLE : 'mxgraph.basic.acute_triangle'};
+mxShapeBasicTriangleAcute.prototype.cst = { ACUTE_TRIANGLE: 'mxgraph.basic.acute_triangle' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicTriangleAcute.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -644,26 +601,22 @@ mxCellRenderer.registerShape(mxShapeBasicTriangleAcute.prototype.cst.ACUTE_TRIAN
 
 mxShapeBasicTriangleAcute.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicTriangleAcute.prototype.cst.ACUTE_TRIANGLE] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+mxShapeBasicTriangleAcute.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dx = w * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
-	
+
 	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));
@@ -680,8 +633,7 @@ mxShapeBasicTriangleAcute.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicTriangleObtuse(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicTriangleObtuse(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -696,22 +648,21 @@ function mxShapeBasicTriangleObtuse(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicTriangleObtuse, mxActor);
 
 mxShapeBasicTriangleObtuse.prototype.customProperties = [
-	{name: 'dx', dispName: 'Bottom', type: 'float', min:0, max:1, defVal:0.25}
+	{ name: 'dx', dispName: 'Bottom', type: 'float', min: 0, max: 1, defVal: 0.25 }
 ];
 
-mxShapeBasicTriangleObtuse.prototype.cst = {OBTUSE_TRIANGLE : 'mxgraph.basic.obtuse_triangle'};
+mxShapeBasicTriangleObtuse.prototype.cst = { OBTUSE_TRIANGLE: 'mxgraph.basic.obtuse_triangle' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicTriangleObtuse.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -724,26 +675,22 @@ mxCellRenderer.registerShape(mxShapeBasicTriangleObtuse.prototype.cst.OBTUSE_TRI
 
 mxShapeBasicTriangleObtuse.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicTriangleObtuse.prototype.cst.OBTUSE_TRIANGLE] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+mxShapeBasicTriangleObtuse.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	var dx = w * Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'dx', this.dx))));
-	
+
 	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, 0), false, null, w * 0.5, h * 0.5));
@@ -760,8 +707,7 @@ mxShapeBasicTriangleObtuse.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicDrop(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicDrop(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -774,26 +720,25 @@ function mxShapeBasicDrop(bounds, fill, stroke, strokewidth)
 */
 mxUtils.extend(mxShapeBasicDrop, mxActor);
 
-mxShapeBasicDrop.prototype.cst = {DROP : 'mxgraph.basic.drop'};
+mxShapeBasicDrop.prototype.cst = { DROP: 'mxgraph.basic.drop' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicDrop.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -815,8 +760,7 @@ mxShapeBasicDrop.prototype.constraints = null;
 /**
 * Extends mxShape.
 */
-function mxShapeBasicCone2(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicCone2(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -832,41 +776,38 @@ function mxShapeBasicCone2(bounds, fill, stroke, strokewidth)
 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}
+	{ 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'};
+mxShapeBasicCone2.prototype.cst = { CONE2: 'mxgraph.basic.cone2' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicCone2.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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)
-	{
+
+	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
-	{
+	else {
 		c.lineTo(w, h);
 		c.lineTo(0, h);
 	}
-	
+
 	c.close();
 	c.fillAndStroke();
 };
@@ -875,40 +816,34 @@ mxCellRenderer.registerShape(mxShapeBasicCone2.prototype.cst.CONE2, mxShapeBasic
 
 mxShapeBasicCone2.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicCone2.prototype.cst.CONE2] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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 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)
-	{
+	}, 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)
-{
+mxShapeBasicCone2.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	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;
-	
+
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, 0));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w, h - ry));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w * 0.5, h));
@@ -923,8 +858,7 @@ mxShapeBasicCone2.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicPyramid(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicPyramid(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -942,28 +876,27 @@ function mxShapeBasicPyramid(bounds, fill, stroke, strokewidth)
 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}
+	{ 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'};
+mxShapeBasicPyramid.prototype.cst = { PYRAMID: 'mxgraph.basic.pyramid' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicPyramid.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -971,9 +904,9 @@ mxShapeBasicPyramid.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(0, dy1);
 	c.close();
 	c.fillAndStroke();
-	
+
 	c.setShadow(false);
-	
+
 	c.begin();
 	c.moveTo(dx1, 0);
 	c.lineTo(dx2, h);
@@ -984,65 +917,55 @@ mxCellRenderer.registerShape(mxShapeBasicPyramid.prototype.cst.PYRAMID, mxShapeB
 
 mxShapeBasicPyramid.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicPyramid.prototype.cst.PYRAMID] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx1'], function(bounds)
-	{
+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)
-	{
+	}, 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 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)
-	{
+	}, 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 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)
-	{
+	}, 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 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)
-	{
+	}, 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)
-{
+mxShapeBasicPyramid.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 	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))));
-	
+
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx1, 0));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w + dx1) * 0.5, dy2 * 0.5));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w, dy2));
@@ -1061,8 +984,7 @@ mxShapeBasicPyramid.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasic4PointStar2(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasic4PointStar2(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1077,18 +999,17 @@ function mxShapeBasic4PointStar2(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasic4PointStar2, mxActor);
 
 mxShapeBasic4PointStar2.prototype.customProperties = [
-	{name: 'dx', dispName: 'Thickness', type: 'float', min:0, max:1, defVal:0.8}
+	{ 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'};
+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)
-{
+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))));
@@ -1110,23 +1031,19 @@ mxCellRenderer.registerShape(mxShapeBasic4PointStar2.prototype.cst.FOUR_POINT_ST
 
 mxShapeBasic4PointStar2.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasic4PointStar2.prototype.cst.FOUR_POINT_STAR_2] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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))));
 
@@ -1148,8 +1065,7 @@ mxShapeBasic4PointStar2.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicDiagSnipRect(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicDiagSnipRect(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1164,24 +1080,23 @@ function mxShapeBasicDiagSnipRect(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicDiagSnipRect, mxActor);
 
 mxShapeBasicDiagSnipRect.prototype.customProperties = [
-	{name: 'dx', dispName: 'Snip', type: 'float', min:0, deVal:6},
+	{ name: 'dx', dispName: 'Snip', type: 'float', min: 0, deVal: 6 },
 ];
 
-mxShapeBasicDiagSnipRect.prototype.cst = {DIAG_SNIP_RECT : 'mxgraph.basic.diag_snip_rect'};
+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)
-{
+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);
@@ -1197,23 +1112,19 @@ mxCellRenderer.registerShape(mxShapeBasicDiagSnipRect.prototype.cst.DIAG_SNIP_RE
 
 mxShapeBasicDiagSnipRect.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicDiagSnipRect.prototype.cst.DIAG_SNIP_RECT] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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;
 
@@ -1237,8 +1148,7 @@ mxShapeBasicDiagSnipRect.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicDiagRoundRect(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicDiagRoundRect(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1253,24 +1163,23 @@ function mxShapeBasicDiagRoundRect(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicDiagRoundRect, mxActor);
 
 mxShapeBasicDiagRoundRect.prototype.customProperties = [
-	{name: 'dx', dispName: 'Rounding Size', type: 'float', min:0, defVal:6},
+	{ name: 'dx', dispName: 'Rounding Size', type: 'float', min: 0, defVal: 6 },
 ];
 
-mxShapeBasicDiagRoundRect.prototype.cst = {DIAG_ROUND_RECT : 'mxgraph.basic.diag_round_rect'};
+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)
-{
+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);
@@ -1287,23 +1196,19 @@ mxCellRenderer.registerShape(mxShapeBasicDiagRoundRect.prototype.cst.DIAG_ROUND_
 
 mxShapeBasicDiagRoundRect.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicDiagRoundRect.prototype.cst.DIAG_ROUND_RECT] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+mxShapeBasicDiagRoundRect.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 
 	constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
@@ -1322,8 +1227,7 @@ mxShapeBasicDiagRoundRect.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicCornerRoundRect(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicCornerRoundRect(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1338,24 +1242,23 @@ function mxShapeBasicCornerRoundRect(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicCornerRoundRect, mxActor);
 
 mxShapeBasicCornerRoundRect.prototype.customProperties = [
-	{name: 'dx', dispName: 'Rounding Size', type: 'float', min:0, defVal:6},
+	{ name: 'dx', dispName: 'Rounding Size', type: 'float', min: 0, defVal: 6 },
 ];
 
-mxShapeBasicCornerRoundRect.prototype.cst = {CORNER_ROUND_RECT : 'mxgraph.basic.corner_round_rect'};
+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)
-{
+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);
@@ -1371,23 +1274,19 @@ mxCellRenderer.registerShape(mxShapeBasicCornerRoundRect.prototype.cst.CORNER_RO
 
 mxShapeBasicCornerRoundRect.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicCornerRoundRect.prototype.cst.CORNER_ROUND_RECT] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+mxShapeBasicCornerRoundRect.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 
 	constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
@@ -1407,8 +1306,7 @@ mxShapeBasicCornerRoundRect.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicPlaque(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicPlaque(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1423,24 +1321,23 @@ function mxShapeBasicPlaque(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicPlaque, mxActor);
 
 mxShapeBasicPlaque.prototype.customProperties = [
-	{name: 'dx', dispName: 'Cutoff Size', type: 'float', min:0, defVal:6},
+	{ name: 'dx', dispName: 'Cutoff Size', type: 'float', min: 0, defVal: 6 },
 ];
 
-mxShapeBasicPlaque.prototype.cst = {PLAQUE : 'mxgraph.basic.plaque'};
+mxShapeBasicPlaque.prototype.cst = { PLAQUE: 'mxgraph.basic.plaque' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicPlaque.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -1458,23 +1355,19 @@ mxCellRenderer.registerShape(mxShapeBasicPlaque.prototype.cst.PLAQUE, mxShapeBas
 
 mxShapeBasicPlaque.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicPlaque.prototype.cst.PLAQUE] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+mxShapeBasicPlaque.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 
 	constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
@@ -1491,8 +1384,7 @@ mxShapeBasicPlaque.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicFrame(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicFrame(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1507,24 +1399,23 @@ function mxShapeBasicFrame(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicFrame, mxActor);
 
 mxShapeBasicFrame.prototype.customProperties = [
-	{name: 'dx', dispName: 'Width', type: 'float', min:0, defVal:10},
+	{ name: 'dx', dispName: 'Width', type: 'float', min: 0, defVal: 10 },
 ];
 
-mxShapeBasicFrame.prototype.cst = {FRAME : 'mxgraph.basic.frame'};
+mxShapeBasicFrame.prototype.cst = { FRAME: 'mxgraph.basic.frame' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicFrame.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -1543,23 +1434,19 @@ mxCellRenderer.registerShape(mxShapeBasicFrame.prototype.cst.FRAME, mxShapeBasic
 
 mxShapeBasicFrame.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicFrame.prototype.cst.FRAME] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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);
@@ -1581,17 +1468,17 @@ mxShapeBasicFrame.prototype.getConstraints = function(style, w, h)
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, 0, h * 0.25));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, dx));
-	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - 2 * dx)* 0.25 + dx, dx));
+	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - 2 * dx) * 0.25 + dx, dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false, null, 0, dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w * 1.5 - dx) * 0.5, dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(1, 0), false, null, -dx, dx));
-	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, (h - 2 * dx)* 0.25 + dx));
+	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, (h - 2 * dx) * 0.25 + dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(1, 0.5), false, null, -dx, 0));
-	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, (h  - 2 * dx) * 0.75 + dx));
+	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, w - dx, (h - 2 * dx) * 0.75 + dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(1, 1), false, null, -dx, -dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - 2 * dx) * 0.75 + dx, h - dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(0.5, 1), false, null, 0, -dx));
-	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w  - 2 * dx) * 0.25 + dx, h - dx));
+	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - 2 * dx) * 0.25 + dx, h - dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 1), false, null, dx, -dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, dx, (h - 2 * dx) * 0.75 + dx));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0.5), false, null, dx, 0));
@@ -1606,8 +1493,7 @@ mxShapeBasicFrame.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicPlaqueFrame(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicPlaqueFrame(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1621,24 +1507,23 @@ function mxShapeBasicPlaqueFrame(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicPlaqueFrame, mxActor);
 
 mxShapeBasicPlaqueFrame.prototype.customProperties = [
-	{name: 'dx', dispName: 'Width', type: 'float', mix:0, defVal:10},
+	{ name: 'dx', dispName: 'Width', type: 'float', mix: 0, defVal: 10 },
 ];
 
-mxShapeBasicPlaqueFrame.prototype.cst = {PLAQUE_FRAME : 'mxgraph.basic.plaque_frame'};
+mxShapeBasicPlaqueFrame.prototype.cst = { PLAQUE_FRAME: 'mxgraph.basic.plaque_frame' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicPlaqueFrame.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -1649,7 +1534,7 @@ mxShapeBasicPlaqueFrame.prototype.paintVertexShape = function(c, x, y, w, h)
 	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);
@@ -1668,23 +1553,19 @@ mxCellRenderer.registerShape(mxShapeBasicPlaqueFrame.prototype.cst.PLAQUE_FRAME,
 
 mxShapeBasicPlaqueFrame.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicPlaqueFrame.prototype.cst.PLAQUE_FRAME] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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);
@@ -1707,8 +1588,7 @@ mxShapeBasicPlaqueFrame.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicRoundedFrame(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicRoundedFrame(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1723,24 +1603,23 @@ function mxShapeBasicRoundedFrame(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicRoundedFrame, mxActor);
 
 mxShapeBasicRoundedFrame.prototype.customProperties = [
-	{name: 'dx', dispName: 'Width', type: 'float', min:0, defVal:10},
+	{ name: 'dx', dispName: 'Width', type: 'float', min: 0, defVal: 10 },
 ];
 
-mxShapeBasicRoundedFrame.prototype.cst = {ROUNDED_FRAME : 'mxgraph.basic.rounded_frame'};
+mxShapeBasicRoundedFrame.prototype.cst = { ROUNDED_FRAME: 'mxgraph.basic.rounded_frame' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicRoundedFrame.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -1751,7 +1630,7 @@ mxShapeBasicRoundedFrame.prototype.paintVertexShape = function(c, x, y, w, h)
 	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);
@@ -1770,23 +1649,19 @@ mxCellRenderer.registerShape(mxShapeBasicRoundedFrame.prototype.cst.ROUNDED_FRAM
 
 mxShapeBasicRoundedFrame.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicRoundedFrame.prototype.cst.ROUNDED_FRAME] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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);
@@ -1809,8 +1684,7 @@ mxShapeBasicRoundedFrame.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicFrameCorner(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicFrameCorner(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1825,24 +1699,23 @@ function mxShapeBasicFrameCorner(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicFrameCorner, mxActor);
 
 mxShapeBasicFrameCorner.prototype.customProperties = [
-	{name: 'dx', dispName: 'Width', type: 'float', min:0, defVal:10},
+	{ name: 'dx', dispName: 'Width', type: 'float', min: 0, defVal: 10 },
 ];
 
-mxShapeBasicFrameCorner.prototype.cst = {FRAME_CORNER : 'mxgraph.basic.frame_corner'};
+mxShapeBasicFrameCorner.prototype.cst = { FRAME_CORNER: 'mxgraph.basic.frame_corner' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicFrameCorner.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -1858,28 +1731,24 @@ mxCellRenderer.registerShape(mxShapeBasicFrameCorner.prototype.cst.FRAME_CORNER,
 
 mxShapeBasicFrameCorner.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicFrameCorner.prototype.cst.FRAME_CORNER] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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));
@@ -1900,8 +1769,7 @@ mxShapeBasicFrameCorner.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicDiagStripe(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicDiagStripe(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -1916,24 +1784,23 @@ function mxShapeBasicDiagStripe(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicDiagStripe, mxActor);
 
 mxShapeBasicDiagStripe.prototype.customProperties = [
-	{name: 'dx', dispName: 'Width', type: 'float', mix:0, defVal:10},
+	{ name: 'dx', dispName: 'Width', type: 'float', mix: 0, defVal: 10 },
 ];
 
-mxShapeBasicDiagStripe.prototype.cst = {DIAG_STRIPE : 'mxgraph.basic.diag_stripe'};
+mxShapeBasicDiagStripe.prototype.cst = { DIAG_STRIPE: 'mxgraph.basic.diag_stripe' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicDiagStripe.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -1947,27 +1814,23 @@ mxCellRenderer.registerShape(mxShapeBasicDiagStripe.prototype.cst.DIAG_STRIPE, m
 
 mxShapeBasicDiagStripe.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicDiagStripe.prototype.cst.DIAG_STRIPE] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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);
-	
+
 	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));
@@ -1986,8 +1849,7 @@ mxShapeBasicDiagStripe.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicDonut(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicDonut(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2002,24 +1864,23 @@ function mxShapeBasicDonut(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicDonut, mxActor);
 
 mxShapeBasicDonut.prototype.customProperties = [
-	{name: 'dx', dispName: 'Width', type: 'float', min:0, defVal:25}
+	{ name: 'dx', dispName: 'Width', type: 'float', min: 0, defVal: 25 }
 ];
 
-mxShapeBasicDonut.prototype.cst = {DONUT : 'mxgraph.basic.donut'};
+mxShapeBasicDonut.prototype.cst = { DONUT: 'mxgraph.basic.donut' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicDonut.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -2040,18 +1901,15 @@ mxCellRenderer.registerShape(mxShapeBasicDonut.prototype.cst.DONUT, mxShapeBasic
 
 mxShapeBasicDonut.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicDonut.prototype.cst.DONUT] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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;
 };
 
@@ -2061,8 +1919,7 @@ Graph.handleFactory[mxShapeBasicDonut.prototype.cst.DONUT] = function(state)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicLayeredRect(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicLayeredRect(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2077,24 +1934,23 @@ function mxShapeBasicLayeredRect(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicLayeredRect, mxActor);
 
 mxShapeBasicLayeredRect.prototype.customProperties = [
-	{name: 'dx', dispName: 'Layer Distance', type: 'float', mix:0, defVal:10}
+	{ name: 'dx', dispName: 'Layer Distance', type: 'float', mix: 0, defVal: 10 }
 ];
 
-mxShapeBasicLayeredRect.prototype.cst = {LAYERED_RECT : 'mxgraph.basic.layered_rect'};
+mxShapeBasicLayeredRect.prototype.cst = { LAYERED_RECT: 'mxgraph.basic.layered_rect' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicLayeredRect.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -2102,7 +1958,7 @@ mxShapeBasicLayeredRect.prototype.paintVertexShape = function(c, x, y, 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);
@@ -2110,7 +1966,7 @@ mxShapeBasicLayeredRect.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(dx * 0.5, h - dx * 0.5);
 	c.close();
 	c.fillAndStroke();
-	
+
 	c.begin();
 	c.moveTo(0, 0);
 	c.lineTo(w - dx, 0);
@@ -2124,27 +1980,23 @@ mxCellRenderer.registerShape(mxShapeBasicLayeredRect.prototype.cst.LAYERED_RECT,
 
 mxShapeBasicLayeredRect.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicLayeredRect.prototype.cst.LAYERED_RECT] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+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);
-	
+
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - dx) * 0.25, 0));
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false, null, (w - dx) * 0.5, 0));
@@ -2175,8 +2027,7 @@ mxShapeBasicLayeredRect.prototype.getConstraints = function(style, w, h)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicButton(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicButton(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2191,24 +2042,23 @@ function mxShapeBasicButton(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicButton, mxActor);
 
 mxShapeBasicButton.prototype.customProperties = [
-	{name: 'dx', dispName: 'Button Height', type: 'float', min:0, defVal:10}
+	{ name: 'dx', dispName: 'Button Height', type: 'float', min: 0, defVal: 10 }
 ];
 
-mxShapeBasicButton.prototype.cst = {BUTTON : 'mxgraph.basic.button'};
+mxShapeBasicButton.prototype.cst = { BUTTON: 'mxgraph.basic.button' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicButton.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -2216,10 +2066,10 @@ mxShapeBasicButton.prototype.paintVertexShape = function(c, x, y, 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);
@@ -2227,7 +2077,7 @@ mxShapeBasicButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(dx, h - dx);
 	c.close();
 	c.fillAndStroke();
-	
+
 	c.begin();
 	c.moveTo(0, 0);
 	c.lineTo(w, 0);
@@ -2235,7 +2085,7 @@ mxShapeBasicButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(dx, dx);
 	c.close();
 	c.fillAndStroke();
-	
+
 	c.begin();
 	c.moveTo(w, 0);
 	c.lineTo(w, h);
@@ -2243,7 +2093,7 @@ mxShapeBasicButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(w - dx, dx);
 	c.close();
 	c.fillAndStroke();
-	
+
 	c.begin();
 	c.moveTo(0, h);
 	c.lineTo(dx, h - dx);
@@ -2251,7 +2101,7 @@ mxShapeBasicButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(w, h);
 	c.close();
 	c.fillAndStroke();
-	
+
 	c.begin();
 	c.moveTo(0, h);
 	c.lineTo(0, 0);
@@ -2259,26 +2109,23 @@ mxShapeBasicButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	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)
-	{
+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)
-	{
+	}, 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;
 };
 
@@ -2288,8 +2135,7 @@ Graph.handleFactory[mxShapeBasicButton.prototype.cst.BUTTON] = function(state)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicShadedButton(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicShadedButton(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2304,26 +2150,25 @@ function mxShapeBasicShadedButton(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicShadedButton, mxActor);
 
 mxShapeBasicShadedButton.prototype.customProperties = [
-	{name: 'dx', dispName: 'Button Height', type: 'float', min:0, defVal:10}
+	{ name: 'dx', dispName: 'Button Height', type: 'float', min: 0, defVal: 10 }
 ];
 
-mxShapeBasicShadedButton.prototype.cst = {SHADED_BUTTON : 'mxgraph.basic.shaded_button'};
+mxShapeBasicShadedButton.prototype.cst = { SHADED_BUTTON: 'mxgraph.basic.shaded_button' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicShadedButton.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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);
@@ -2331,7 +2176,7 @@ mxShapeBasicShadedButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(0, h);
 	c.close();
 	c.fill();
-	
+
 	c.setFillColor('#ffffff');
 	c.setAlpha(0.25);
 	c.begin();
@@ -2341,7 +2186,7 @@ mxShapeBasicShadedButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(dx, h - dx);
 	c.close();
 	c.fill();
-	
+
 	c.setAlpha(0.5);
 	c.begin();
 	c.moveTo(0, 0);
@@ -2350,7 +2195,7 @@ mxShapeBasicShadedButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(dx, dx);
 	c.close();
 	c.fill();
-	
+
 	c.setFillColor('#000000');
 	c.setAlpha(0.25);
 	c.begin();
@@ -2360,7 +2205,7 @@ mxShapeBasicShadedButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	c.lineTo(w - dx, dx);
 	c.close();
 	c.fill();
-	
+
 	c.setAlpha(0.5);
 	c.begin();
 	c.moveTo(0, h);
@@ -2369,26 +2214,23 @@ mxShapeBasicShadedButton.prototype.paintVertexShape = function(c, x, y, w, h)
 	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)
-	{
+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)
-	{
+	}, 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;
 };
 
@@ -2398,8 +2240,7 @@ Graph.handleFactory[mxShapeBasicShadedButton.prototype.cst.SHADED_BUTTON] = func
 /**
 * Extends mxShape.
 */
-function mxShapeBasicPie(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicPie(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2415,19 +2256,18 @@ function mxShapeBasicPie(bounds, fill, stroke, strokewidth)
 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}
+	{ 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'};
+mxShapeBasicPie.prototype.cst = { PIE: 'mxgraph.basic.pie' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicPie.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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))));
@@ -2435,51 +2275,46 @@ mxShapeBasicPie.prototype.paintVertexShape = function(c, x, y, w, h)
 	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)
-	{
+
+	if (angDiff < 0) {
 		angDiff = angDiff + Math.PI * 2;
 	}
-		
+
 	var bigArc = 0;
-	
-	if (angDiff >= Math.PI)
-	{
+
+	if (angDiff >= Math.PI) {
 		bigArc = 1;
 	}
-		
+
 	c.begin();
 	var startAngleDiff = startAngleSource % 1;
 	var endAngleDiff = endAngleSource % 1;
-	
-	if (startAngleDiff == 0 && endAngleDiff == 0.5)
-	{
+
+	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)
-	{
+	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
-	{
+	else {
 		c.moveTo(rx, ry);
 		c.lineTo(startX, startY);
 		c.arcTo(rx, ry, 0, bigArc, 1, endX, endY);
 	}
-	
+
 	c.close();
 	c.fillAndStroke();
 };
@@ -2488,51 +2323,44 @@ 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)
-	{
+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)
-	{
+	}, 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)
-		{
+
+		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 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)
-	{
+	}, 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)
-		{
+
+		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;
 };
 
@@ -2542,8 +2370,7 @@ Graph.handleFactory[mxShapeBasicPie.prototype.cst.PIE] = function(state)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicArc(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicArc(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2559,19 +2386,18 @@ function mxShapeBasicArc(bounds, fill, stroke, strokewidth)
 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: '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 }
 ];
 
-mxShapeBasicArc.prototype.cst = {ARC : 'mxgraph.basic.arc'};
+mxShapeBasicArc.prototype.cst = { ARC: 'mxgraph.basic.arc' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicArc.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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))));
@@ -2580,45 +2406,40 @@ mxShapeBasicArc.prototype.paintVertexShape = function(c, x, y, w, h)
 	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)
-	{
+
+	if (angDiff < 0) {
 		angDiff = angDiff + Math.PI * 2;
 	}
-		
+
 	var bigArc = 0;
-	
-	if (angDiff > Math.PI)
-	{
+
+	if (angDiff > Math.PI) {
 		bigArc = 1;
 	}
-		
+
 	c.begin();
-	
+
 	var startAngleDiff = startAngleSource % 1;
 	var endAngleDiff = endAngleSource % 1;
-	
-	if (startAngleDiff == 0 && endAngleDiff == 0.5)
-	{
+
+	if (startAngleDiff == 0 && endAngleDiff == 0.5) {
 		c.moveTo(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)
-	{
+	else if (startAngleDiff == 0.5 && endAngleDiff == 0) {
 		c.moveTo(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
-	{
+	else {
 		c.moveTo(startX, startY);
 		c.arcTo(rx, ry, 0, bigArc, 1, endX, endY);
 	}
@@ -2630,51 +2451,44 @@ 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)
-	{
+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)
-	{
+	}, 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)
-		{
+
+		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 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)
-	{
+	}, 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)
-		{
+
+		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;
 };
 
@@ -2684,8 +2498,7 @@ Graph.handleFactory[mxShapeBasicArc.prototype.cst.ARC] = function(state)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicPartConcEllipse(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicPartConcEllipse(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2702,20 +2515,19 @@ function mxShapeBasicPartConcEllipse(bounds, fill, stroke, strokewidth)
 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}
+	{ 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'};
+mxShapeBasicPartConcEllipse.prototype.cst = { PART_CONC_ELLIPSE: 'mxgraph.basic.partConcEllipse' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicPartConcEllipse.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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))));
@@ -2725,18 +2537,16 @@ mxShapeBasicPartConcEllipse.prototype.paintVertexShape = function(c, x, y, w, h)
 	var ry = h * 0.5;
 	var rx2 = rx * arcWidth;
 	var ry2 = ry * arcWidth;
-	
+
 	var angDiff = endAngle - startAngle;
-	
-	if (angDiff < 0)
-	{
+
+	if (angDiff < 0) {
 		angDiff = angDiff + Math.PI * 2;
 	}
-	else if (angDiff == Math.PI)
-	{
+	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;
@@ -2745,15 +2555,14 @@ mxShapeBasicPartConcEllipse.prototype.paintVertexShape = function(c, x, y, w, h)
 	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)
-	{
+
+	if (angDiff >= Math.PI) {
 		bigArc = 1;
 	}
-		
+
 	c.begin();
 	c.moveTo(startX, startY);
 	c.arcTo(rx, ry, 0, bigArc, 1, endX, endY);
@@ -2767,63 +2576,54 @@ mxCellRenderer.registerShape(mxShapeBasicPartConcEllipse.prototype.cst.PART_CONC
 
 mxShapeBasicPartConcEllipse.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicPartConcEllipse.prototype.cst.PART_CONC_ELLIPSE] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['startAngle'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-		{
+
+		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 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)
-	{
+	}, 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)
-		{
+
+		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 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)
-	{
+	}, 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;
 };
 
@@ -2833,8 +2633,7 @@ Graph.handleFactory[mxShapeBasicPartConcEllipse.prototype.cst.PART_CONC_ELLIPSE]
 /**
 * Extends mxShape.
 */
-function mxShapeBasicNumEntryVert(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicNumEntryVert(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2848,15 +2647,14 @@ function mxShapeBasicNumEntryVert(bounds, fill, stroke, strokewidth)
 */
 mxUtils.extend(mxShapeBasicNumEntryVert, mxActor);
 
-mxShapeBasicNumEntryVert.prototype.cst = {NUM_ENTRY_VERT : 'mxgraph.basic.numberedEntryVert'};
+mxShapeBasicNumEntryVert.prototype.cst = { NUM_ENTRY_VERT: 'mxgraph.basic.numberedEntryVert' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicNumEntryVert.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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))));
@@ -2864,10 +2662,10 @@ mxShapeBasicNumEntryVert.prototype.paintVertexShape = function(c, x, y, w, h)
 	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);
@@ -2883,18 +2681,15 @@ mxCellRenderer.registerShape(mxShapeBasicNumEntryVert.prototype.cst.NUM_ENTRY_VE
 
 mxShapeBasicNumEntryVert.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicNumEntryVert.prototype.cst.NUM_ENTRY_VERT] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dy'], function(bounds)
-	{
+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)
-	{
+	}, 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;
 };
 
@@ -2904,8 +2699,7 @@ Graph.handleFactory[mxShapeBasicNumEntryVert.prototype.cst.NUM_ENTRY_VERT] = fun
 /**
 * Extends mxShape.
 */
-function mxShapeBasicBendingArch(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicBendingArch(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -2921,15 +2715,14 @@ function mxShapeBasicBendingArch(bounds, fill, stroke, strokewidth)
 */
 mxUtils.extend(mxShapeBasicBendingArch, mxActor);
 
-mxShapeBasicBendingArch.prototype.cst = {BENDING_ARCH : 'mxgraph.basic.bendingArch'};
+mxShapeBasicBendingArch.prototype.cst = { BENDING_ARCH: 'mxgraph.basic.bendingArch' };
 
 /**
 * Function: paintVertexShape
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicBendingArch.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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))));
@@ -2939,7 +2732,7 @@ mxShapeBasicBendingArch.prototype.paintVertexShape = function(c, x, y, w, h)
 	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;
@@ -2948,18 +2741,16 @@ mxShapeBasicBendingArch.prototype.paintVertexShape = function(c, x, y, w, h)
 	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)
-	{
+
+	if (angDiff < 0) {
 		angDiff = angDiff + Math.PI * 2;
 	}
-		
+
 	var bigArc = 0;
-	
-	if (angDiff > Math.PI)
-	{
+
+	if (angDiff > Math.PI) {
 		bigArc = 1;
 	}
 
@@ -2968,7 +2759,7 @@ mxShapeBasicBendingArch.prototype.paintVertexShape = function(c, x, y, w, h)
 
 	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);
@@ -2982,63 +2773,54 @@ mxCellRenderer.registerShape(mxShapeBasicBendingArch.prototype.cst.BENDING_ARCH,
 
 mxShapeBasicBendingArch.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicBendingArch.prototype.cst.BENDING_ARCH] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['startAngle'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-		{
+
+		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 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)
-	{
+	}, 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)
-		{
+
+		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 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)
-	{
+	}, 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;
 };
 
@@ -3048,8 +2830,7 @@ Graph.handleFactory[mxShapeBasicBendingArch.prototype.cst.BENDING_ARCH] = functi
 /**
 * Extends mxShape.
 */
-function mxShapeBasicThreeCornerRoundRect(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicThreeCornerRoundRect(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -3064,24 +2845,23 @@ function mxShapeBasicThreeCornerRoundRect(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicThreeCornerRoundRect, mxActor);
 
 mxShapeBasicThreeCornerRoundRect.prototype.customProperties = [
-	{name: 'dx', dispName: 'Rounding Size', type: 'float', min:0, defVal:6}
+	{ name: 'dx', dispName: 'Rounding Size', type: 'float', min: 0, defVal: 6 }
 ];
 
-mxShapeBasicThreeCornerRoundRect.prototype.cst = {THREE_CORNER_ROUND_RECT : 'mxgraph.basic.three_corner_round_rect'};
+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)
-{
+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);
@@ -3099,23 +2879,19 @@ mxCellRenderer.registerShape(mxShapeBasicThreeCornerRoundRect.prototype.cst.THRE
 
 mxShapeBasicThreeCornerRoundRect.prototype.constraints = null;
 
-Graph.handleFactory[mxShapeBasicThreeCornerRoundRect.prototype.cst.THREE_CORNER_ROUND_RECT] = function(state)
-{
-	var handles = [Graph.createHandle(state, ['dx'], function(bounds)
-	{
+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)
-	{
+	}, 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)
-{
+mxShapeBasicThreeCornerRoundRect.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 
 	constr.push(new mxConnectionConstraint(new mxPoint(0.5, 0), false));
@@ -3133,8 +2909,7 @@ mxShapeBasicThreeCornerRoundRect.prototype.getConstraints = function(style, w, h
 /**
 * Extends mxShape.
 */
-function mxShapeBasicPolygon(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicPolygon(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -3150,86 +2925,73 @@ function mxShapeBasicPolygon(bounds, fill, stroke, strokewidth)
 mxUtils.extend(mxShapeBasicPolygon, mxActor);
 
 mxShapeBasicPolygon.prototype.customProperties = [
-	{name: 'polyline', dispName: 'Polyline', type: 'bool', defVal:false},
+	{ name: 'polyline', dispName: 'Polyline', type: 'bool', defVal: false },
 ];
 
-mxShapeBasicPolygon.prototype.cst = {POLYGON : 'mxgraph.basic.polygon'};
+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 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++)
-            {
-                c.lineTo(coords[i][0] * w, coords[i][1] * h);
-            }
-       
-            if (polyline == false)
-            {
-                c.close();
-            }
-            
-            c.end();
-            c.fillAndStroke();
-        }
-    }
-    catch (e)
-    {
-        // ignore
-    }
-};
- 
+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 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++) {
+				c.lineTo(coords[i][0] * w, coords[i][1] * h);
+			}
+
+			if (polyline == false) {
+				c.close();
+			}
+
+			c.end();
+			c.fillAndStroke();
+		}
+	}
+	catch (e) {
+		// ignore
+	}
+};
+
 mxCellRenderer.registerShape(mxShapeBasicPolygon.prototype.cst.POLYGON, mxShapeBasicPolygon);
 
 mxShapeBasicPolygon.prototype.constraints = null;
- 
-Graph.handleFactory[mxShapeBasicPolygon.prototype.cst.POLYGON] = function(state)
-{
-    var handles = [];
- 
-    try
-    {
-        var c = JSON.parse(mxUtils.getValue(state.style, 'polyCoords', '[]'));
-               
-        for (var i = 0; i < c.length; i++)
-        {
-            (function(index)
-            {
-                handles.push(Graph.createHandle(state, ['polyCoords'], function(bounds)
-                {
-                    return new mxPoint(bounds.x + c[index][0] * bounds.width, bounds.y + c[index][1] * bounds.height);
-                }, function(bounds, pt)
-                {
-                    var x = Math.round(100 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100;
-                    var y = Math.round(100 * Math.max(0, Math.min(1, (pt.y - bounds.y) / bounds.height))) / 100;
-                   
-                    c[index] = [x, y];
-                    state.style['polyCoords'] = JSON.stringify(c);
-                   
-                }, false));
-            })(i);
-        }
-    }
-    catch (e)
-    {
-        // ignore
-    }
-   
-    return handles;
+
+Graph.handleFactory[mxShapeBasicPolygon.prototype.cst.POLYGON] = function (state) {
+	var handles = [];
+
+	try {
+		var c = JSON.parse(mxUtils.getValue(state.style, 'polyCoords', '[]'));
+
+		for (var i = 0; i < c.length; i++) {
+			(function (index) {
+				handles.push(Graph.createHandle(state, ['polyCoords'], function (bounds) {
+					return new mxPoint(bounds.x + c[index][0] * bounds.width, bounds.y + c[index][1] * bounds.height);
+				}, function (bounds, pt) {
+					var x = Math.round(100 * Math.max(0, Math.min(1, (pt.x - bounds.x) / bounds.width))) / 100;
+					var y = Math.round(100 * Math.max(0, Math.min(1, (pt.y - bounds.y) / bounds.height))) / 100;
+
+					c[index] = [x, y];
+					state.style['polyCoords'] = JSON.stringify(c);
+
+				}, false));
+			})(i);
+		}
+	}
+	catch (e) {
+		// ignore
+	}
+
+	return handles;
 };
 
 //**********************************************************************************************************************************************************
@@ -3238,8 +3000,7 @@ Graph.handleFactory[mxShapeBasicPolygon.prototype.cst.POLYGON] = function(state)
 /**
 * Extends mxShape.
 */
-function mxShapeBasicPatternFillRect(bounds, fill, stroke, strokewidth)
-{
+function mxShapeBasicPatternFillRect(bounds, fill, stroke, strokewidth) {
 	mxShape.call(this);
 	this.bounds = bounds;
 	this.fill = fill;
@@ -3253,26 +3014,28 @@ function mxShapeBasicPatternFillRect(bounds, fill, stroke, strokewidth)
 */
 mxUtils.extend(mxShapeBasicPatternFillRect, mxActor);
 
-mxShapeBasicPatternFillRect.prototype.cst = {PATTERN_FILL_RECT : 'mxgraph.basic.patternFillRect'};
+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}
+	{ 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 }
 ];
 
 /**
@@ -3280,201 +3043,171 @@ mxShapeBasicPatternFillRect.prototype.customProperties = [
 * 
 * Paints the vertex shape.
 */
-mxShapeBasicPatternFillRect.prototype.paintVertexShape = function(c, x, y, w, h)
-{
+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')
-	{
+	if (fillStyle == 'diag' || fillStyle == 'diagGrid') {
 		step = step * 1.41;
 		var i = 0;
-		
+
 		c.begin();
-		
-		while (i < (h + w))
-		{
+
+		while (i < (h + w)) {
 			var cx = 0;
 			var cy = 0;
-			
-			if (i <= h)
-			{
+
+			if (i <= h) {
 				c.moveTo(0, i);
-				
-				if(i <= w)
-				{
+
+				if (i <= w) {
 					c.lineTo(i, 0);
 				}
-				else
-				{
+				else {
 					c.lineTo(w, i - w);
 				}
 			}
-			else
-			{
+			else {
 				c.moveTo(i - h, h);
-				
-				if(i <= w)
-				{
+
+				if (i <= w) {
 					c.lineTo(i, 0);
 				}
-				else
-				{
+				else {
 					c.lineTo(w, i - w);
 				}
 			}
-			
+
 			i = i + step;
 		}
-		
+
 		c.stroke();
 	}
-	else if (fillStyle == 'vert' || fillStyle == 'grid')
-	{
+	else if (fillStyle == 'vert' || fillStyle == 'grid') {
 		c.begin();
 		var i = 0;
-		
-		while (i <= w)
-		{
+
+		while (i <= w) {
 			var cx = 0;
 			var cy = 0;
-			
+
 			c.moveTo(i, 0);
 			c.lineTo(i, h);
-			
+
 			i = i + step;
 		}
-		
+
 		c.stroke();
 	}
-	
-	if (fillStyle == 'diagRev' || fillStyle == 'diagGrid')
-	{
-		if (fillStyle == 'diagRev')
-		{
+
+	if (fillStyle == 'diagRev' || fillStyle == 'diagGrid') {
+		if (fillStyle == 'diagRev') {
 			step = step * 1.41;
 		}
 
 		var i = 0;
-		
+
 		c.begin();
-		
-		while (i < (h + w))
-		{
+
+		while (i < (h + w)) {
 			var cx = 0;
 			var cy = 0;
-			
-			if (i <= h)
-			{
+
+			if (i <= h) {
 				c.moveTo(w, i);
-				
-				if(i <= w)
-				{
+
+				if (i <= w) {
 					c.lineTo(w - i, 0);
 				}
-				else
-				{
+				else {
 					c.lineTo(w - w, i - w);
 				}
 			}
-			else
-			{
+			else {
 				c.moveTo(w - i + h, h);
-				
-				if(i <= w)
-				{
+
+				if (i <= w) {
 					c.lineTo(w - i, 0);
 				}
-				else
-				{
+				else {
 					c.lineTo(0, i - w);
 				}
 			}
-			
+
 			i = i + step;
 		}
-		
+
 		c.stroke();
 	}
-	else if (fillStyle == 'hor' || fillStyle == 'grid')
-	{
+	else if (fillStyle == 'hor' || fillStyle == 'grid') {
 		c.begin();
 		var i = 0;
-		
-		while (i <= h)
-		{
+
+		while (i <= h) {
 			var cx = 0;
 			var cy = 0;
-			
+
 			c.moveTo(0, i);
 			c.lineTo(w, i);
-			
+
 			i = i + step;
 		}
-		
+
 		c.stroke();
 	}
 
 	c.setStrokeColor(strokeColor);
 	c.setStrokeWidth(strokeWidth);
-	
+
 	c.begin();
 	c.moveTo(0, 0);
-	
-	if (mxUtils.getValue(this.style, 'top', '1') == '1')
-	{
+
+	if (mxUtils.getValue(this.style, 'top', '1') == '1') {
 		c.lineTo(w, 0);
 	}
-	else
-	{
+	else {
 		c.moveTo(w, 0);
 	}
-	
-	if (mxUtils.getValue(this.style, 'right', '1') == '1')
-	{
+
+	if (mxUtils.getValue(this.style, 'right', '1') == '1') {
 		c.lineTo(w, h);
 	}
-	else
-	{
+	else {
 		c.moveTo(w, h);
 	}
-	
-	if (mxUtils.getValue(this.style, 'bottom', '1') == '1')
-	{
+
+	if (mxUtils.getValue(this.style, 'bottom', '1') == '1') {
 		c.lineTo(0, h);
 	}
-	else
-	{
+	else {
 		c.moveTo(0, h);
 	}
-	
-	if (mxUtils.getValue(this.style, 'left', '1') == '1')
-	{
+
+	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)
-{
+mxShapeBasicPatternFillRect.prototype.getConstraints = function (style, w, h) {
 	var constr = [];
 
 	constr.push(new mxConnectionConstraint(new mxPoint(0, 0), false));