jruby_activiti 1.2.5 → 2.0.0

data/web/public/diagram-viewer/js/LineBreakMeasurer.js

@@ -0,0 +1,270 @@
+/**
+ * Word wrapping
+ * 
+ * @author (Javascript) Dmitry Farafonov
+ */
+
+		var AttributedStringIterator = function(text){
+				//this.text = this.rtrim(this.ltrim(text));
+				text = text.replace(/(\s)+/, " ");
+				this.text = this.rtrim(text);
+				/*
+				if (beginIndex < 0 || beginIndex > endIndex || endIndex > length()) {
+					throw new IllegalArgumentException("Invalid substring range");
+				}
+				*/
+				this.beginIndex = 0;
+				this.endIndex = this.text.length;
+				this.currentIndex = this.beginIndex;
+				
+				//console.group("[AttributedStringIterator]");
+				var i = 0;
+				var string = this.text;
+				var fullPos = 0;
+				
+				//console.log("string: \"" + string + "\", length: " + string.length);
+				this.startWordOffsets = [];
+				this.startWordOffsets.push(fullPos);
+				
+				// TODO: remove i 1000
+				while (i<1000) {
+					var pos = string.search(/[ \t\n\f-\.\,]/);
+					if (pos == -1)
+						break;
+					
+					// whitespace start
+					fullPos += pos;
+					string = string.substr(pos);
+					////console.log("fullPos: " + fullPos + ", pos: " + pos +  ", string: ", string);
+					
+					// remove whitespaces
+					var pos = string.search(/[^ \t\n\f-\.\,]/);
+					if (pos == -1)
+						break;
+						
+					// whitespace end
+					fullPos += pos;
+					string = string.substr(pos);
+					
+					////console.log("fullPos: " + fullPos);
+					this.startWordOffsets.push(fullPos);
+					
+					i++;
+				}
+				//console.log("startWordOffsets: ", this.startWordOffsets);
+				//console.groupEnd();
+			};
+			AttributedStringIterator.prototype = {
+				getEndIndex: function(pos){
+					if (typeof(pos) == "undefined")
+						return this.endIndex;
+						
+					var string = this.text.substr(pos, this.endIndex - pos);
+					
+					var posEndOfLine = string.search(/[\n]/);
+					if (posEndOfLine == -1)
+						return this.endIndex;
+					else
+						return pos + posEndOfLine;
+				},
+				getBeginIndex: function(){
+					return this.beginIndex;
+				},
+				isWhitespace: function(pos){
+					var str = this.text[pos];
+					var whitespaceChars = " \t\n\f";
+					
+					return (whitespaceChars.indexOf(str) != -1);
+				},
+				isNewLine: function(pos){
+					var str = this.text[pos];
+					var whitespaceChars = "\n";
+					
+					return (whitespaceChars.indexOf(str) != -1);
+				},
+				preceding: function(pos){
+					//console.group("[AttributedStringIterator.preceding]");
+					for(var i in this.startWordOffsets) {
+						var startWordOffset = this.startWordOffsets[i];
+						if (pos < startWordOffset && i>0) {
+							//console.log("startWordOffset: " + this.startWordOffsets[i-1]);
+							//console.groupEnd();
+							return this.startWordOffsets[i-1];
+						}
+					}
+					//console.log("pos: " + pos);
+					//console.groupEnd();
+					return this.startWordOffsets[i];
+				},
+				following: function(pos){
+					//console.group("[AttributedStringIterator.following]");
+					for(var i in this.startWordOffsets) {
+						var startWordOffset = this.startWordOffsets[i];
+						if (pos < startWordOffset && i>0) {
+							//console.log("startWordOffset: " + this.startWordOffsets[i]);
+							//console.groupEnd();
+							return this.startWordOffsets[i];
+						}
+					}
+					//console.log("pos: " + pos);
+					//console.groupEnd();
+					return this.startWordOffsets[i];
+				},
+				ltrim: function(str){
+					var patt2=/^\s+/g;
+					return str.replace(patt2, "");
+				}, 
+				rtrim: function(str){
+					var patt2=/\s+$/g;
+					return str.replace(patt2, "");
+				},
+				getLayout: function(start, limit){
+					return this.text.substr(start, limit - start);
+				},
+				getCharAtPos: function(pos) {
+					return this.text[pos];
+				}
+			};
+
+		var LineBreakMeasurer = function(paper, x, y, text, fontAttrs){
+				this.paper = paper;
+				this.text = new AttributedStringIterator(text);
+				this.fontAttrs = fontAttrs;
+				
+				if (this.text.getEndIndex() - this.text.getBeginIndex() < 1) {
+					throw {message: "Text must contain at least one character.", code: "IllegalArgumentException"};
+				}
+				
+				//this.measurer = new TextMeasurer(paper, this.text, this.fontAttrs);
+				this.limit = this.text.getEndIndex();
+				this.pos = this.start = this.text.getBeginIndex();
+				
+				this.rafaelTextObject = this.paper.text(x, y, this.text.text).attr(fontAttrs).attr("text-anchor", "start");
+				this.svgTextObject = this.rafaelTextObject[0];
+			};
+			LineBreakMeasurer.prototype = {
+				nextOffset: function(wrappingWidth, offsetLimit, requireNextWord) {
+					//console.group("[nextOffset]");
+					var nextOffset = this.pos;
+					if (this.pos < this.limit) {
+						if (offsetLimit <= this.pos) {
+							throw {message: "offsetLimit must be after current position", code: "IllegalArgumentException"};
+						}
+						
+						var charAtMaxAdvance = this.getLineBreakIndex(this.pos, wrappingWidth);
+						//charAtMaxAdvance --;
+						//console.log("charAtMaxAdvance:", charAtMaxAdvance, ", [" + this.text.getCharAtPos(charAtMaxAdvance) + "]");
+						
+						if (charAtMaxAdvance == this.limit) {
+							nextOffset = this.limit;
+							//console.log("charAtMaxAdvance == this.limit");
+						} else if (this.text.isNewLine(charAtMaxAdvance)) {
+							//console.log("isNewLine");
+							nextOffset = charAtMaxAdvance+1;
+						} else if (this.text.isWhitespace(charAtMaxAdvance)) {
+							// TODO: find next noSpaceChar
+							//return nextOffset;
+							nextOffset = this.text.following(charAtMaxAdvance);
+						} else {
+							// Break is in a word;  back up to previous break.
+							/*
+							var testPos = charAtMaxAdvance + 1;
+							if (testPos == this.limit) {
+								console.error("hbz...");
+							} else {
+								nextOffset = this.text.preceding(charAtMaxAdvance);
+							}
+							*/
+							nextOffset = this.text.preceding(charAtMaxAdvance);
+							
+							if (nextOffset <= this.pos) {
+								nextOffset = Math.max(this.pos+1, charAtMaxAdvance);
+							}
+						}
+					}
+					if (nextOffset > offsetLimit) {
+						nextOffset = offsetLimit;
+					}
+					//console.log("nextOffset: " + nextOffset);
+					//console.groupEnd();
+					return nextOffset;
+				},
+				nextLayout: function(wrappingWidth) {
+					//console.groupCollapsed("[nextLayout]");
+					if (this.pos < this.limit) {
+						var requireNextWord = false;
+						var layoutLimit = this.nextOffset(wrappingWidth, this.limit, requireNextWord);
+						//console.log("layoutLimit:", layoutLimit);
+						if (layoutLimit == this.pos) {
+							//console.groupEnd();
+							return null;
+						}
+						var result = this.text.getLayout(this.pos, layoutLimit);
+						//console.log("layout: \"" + result + "\"");
+						
+						// remove end of line
+						
+						//var posEndOfLine = this.text.getEndIndex(this.pos);
+						//if (posEndOfLine < result.length)
+						//	result = result.substr(0, posEndOfLine);
+						
+						this.pos = layoutLimit;
+						
+						//console.groupEnd();
+						return result;
+					} else {
+						//console.groupEnd();
+						return null;
+					}
+				},
+				getLineBreakIndex: function(pos, wrappingWidth) {
+					//console.group("[getLineBreakIndex]");
+					//console.log("pos:"+pos + ", text: \""+ this.text.text.replace(/\n/g, "_").substr(pos, 1) + "\"");
+					
+					var bb = this.rafaelTextObject.getBBox();
+					
+					var charNum = -1;
+					try {
+						var svgPoint = this.svgTextObject.getStartPositionOfChar(pos);
+						//var dot = this.paper.ellipse(svgPoint.x, svgPoint.y, 1, 1).attr({"stroke-width": 0, fill: Color.blue});
+						svgPoint.x = svgPoint.x + wrappingWidth;
+						//svgPoint.y = bb.y;
+						//console.log("svgPoint:", svgPoint);
+					
+						//var dot = this.paper.ellipse(svgPoint.x, svgPoint.y, 1, 1).attr({"stroke-width": 0, fill: Color.red});
+					
+						charNum = this.svgTextObject.getCharNumAtPosition(svgPoint);
+					} catch (e){
+						console.warn("getStartPositionOfChar error, pos:" + pos);
+						/*
+						var testPos = pos + 1;
+						if (testPos < this.limit) {
+							return testPos
+						}
+						*/
+					}
+					//console.log("charNum:", charNum);
+					if (charNum == -1) {
+						//console.groupEnd();
+						return this.text.getEndIndex(pos);
+					} else {
+						// When case there is new line between pos and charnum then use this new line
+						var newLineIndex = this.text.getEndIndex(pos);
+						if (newLineIndex < charNum ) {
+							console.log("newLineIndex <= charNum, newLineIndex:"+newLineIndex+", charNum:"+charNum, "\"" + this.text.text.substr(newLineIndex+1).replace(/\n/g, "?") + "\"");
+							//console.groupEnd();
+							
+							return newLineIndex;
+						}
+							
+						//var charAtMaxAdvance  = this.text.text.substring(charNum, charNum + 1);
+						var charAtMaxAdvance  = this.text.getCharAtPos(charNum);
+						//console.log("!!charAtMaxAdvance: " + charAtMaxAdvance);
+						//console.groupEnd();
+						return charNum;
+					}
+				}, 
+				getPosition: function() {
+					return this.pos;
+				}
+			};

data/web/public/diagram-viewer/js/Polyline.js

@@ -0,0 +1,387 @@
+/**
+ * Class to generate polyline
+ *
+ * @author Dmitry Farafonov
+ */
+ 
+var ANCHOR_TYPE= {
+	main: "main",
+	middle: "middle",
+	first: "first",
+	last: "last"
+};
+
+function Anchor(uuid, type, x, y) {
+	this.uuid = uuid; 
+	this.x = x
+	this.y = y
+	this.type = (type == ANCHOR_TYPE.middle) ? ANCHOR_TYPE.middle : ANCHOR_TYPE.main;
+};
+Anchor.prototype = {
+	uuid: null,
+	x: 0,
+	y: 0,
+	type: ANCHOR_TYPE.main,
+	isFirst: false,
+	isLast: false,
+	ndex: 0,
+	typeIndex: 0
+};
+
+function Polyline(uuid, points, strokeWidth) {
+	/* Array on coordinates:
+	 * points: [{x: 410, y: 110}, 1
+	 *			{x: 570, y: 110}, 1 2
+	 *			{x: 620, y: 240},   2 3
+	 *			{x: 750, y: 270},     3 4
+	 *			{x: 650, y: 370}];      4
+	 */
+	this.points = points;
+	
+	/*
+	 * path for graph
+	 * [["M", x1, y1], ["L", x2, y2], ["C", ax, ay, bx, by, x3, y3], ["L", x3, y3]]
+	 */
+	this.path = [];
+	
+	this.anchors = [];
+	
+	if (strokeWidth) this.strokeWidth = strokeWidth;
+	
+	this.closePath = false;
+	
+	this.init();
+};
+
+Polyline.prototype = {
+	id: null,
+	points: [],
+	path: [],
+	anchors: [],
+	strokeWidth: 1,
+	radius: 15,
+	showDetails: false,
+	element: null,
+	isDefaultConditionAvailable: false,
+	closePath: false,
+	
+	init: function(points){
+		var linesCount = this.getLinesCount();
+		if (linesCount < 1)
+			return;
+			
+		this.normalizeCoordinates();
+		
+		// create anchors
+		
+		this.pushAnchor(ANCHOR_TYPE.first, this.getLine(0).x1, this.getLine(0).y1);
+		
+		for(var i = 1; i < linesCount; i++){
+			var line1 = this.getLine(i-1),
+				line2 = this.getLine(i);
+			
+			//this.pushAnchor(ANCHOR_TYPE.middle, line1.x1 + line1.x2-line1.x1, line1.y1 + line1.y2-line1.y1);
+			this.pushAnchor(ANCHOR_TYPE.main,  line1.x2, line1.y2);
+			//this.pushAnchor(ANCHOR_TYPE.middle,  line2.x1 + line2.x2-line2.x1, line2.y1 + line2.y2-line2.y1);
+		}
+		
+		this.pushAnchor(ANCHOR_TYPE.last, this.getLine(linesCount-1).x2, this.getLine(linesCount-1).y2);
+		
+		this.rebuildPath();
+	},
+	
+	normalizeCoordinates: function(){
+		for(var i=0; i < this.points.length; i++){
+			this.points[i].x = parseFloat(this.points[i].x);
+			this.points[i].y = parseFloat(this.points[i].y);
+		}
+	},
+	
+	getLinesCount: function(){
+		return this.points.length-1;
+	},
+	_getLine: function(i){
+		return {x1: this.points[i].x, y1: this.points[i].y, x2: this.points[i+1].x, y2: this.points[i+1].y};
+	},
+	getLine: function(i){
+		var line = this._getLine(i);
+		line.angle = this.getLineAngle(i) ;
+		return line;
+	},
+	getLineAngle: function(i){
+		var line = this._getLine(i);
+		return Math.atan2(line.y2 - line.y1, line.x2 - line.x1);
+	},
+	getLineLengthX: function(i){
+		var line = this.getLine(i);
+		return (line.x2 - line.x1);
+	},
+	getLineLengthY: function(i){
+		var line = this.getLine(i);
+		return (line.y2 - line.y1);
+	},
+	getLineLength: function(i){
+		var line = this.getLine(i);
+		return Math.sqrt(Math.pow(this.getLineLengthX(i), 2) + Math.pow(this.getLineLengthY(i), 2));
+	},
+	
+	getAnchors: function(){
+		// ������� ��������������� ������
+		// ????
+		return this.anchors;
+	},
+	getAnchorsCount: function(type){
+		if (!type)
+			return this.anchors.length;
+		else {
+			var count = 0;
+			for(var i=0; i < this.getAnchorsCount(); i++){
+				var anchor = this.anchors[i];
+				if (anchor.getType() == type) {
+					count++;
+				}
+			}
+			return count;
+		}
+	},
+	
+	pushAnchor: function(type, x, y, index){
+		if (type == ANCHOR_TYPE.first) {
+			index = 0;
+			typeIndex = 0;
+		} else if (type == ANCHOR_TYPE.last) {
+			index = this.getAnchorsCount();
+			typeIndex = 0;
+		} else if (!index) {
+			index = this.anchors.length;
+		} else {
+			// ��������� anchors, �������� ������� ��� �������, ������� � index
+			//var anchor = this.getAnchor()
+			for(var i=0; i < this.getAnchorsCount(); i++){
+				var anchor = this.anchors[i];
+				if (anchor.index > index) {
+					anchor.index++;
+					anchor.typeIndex++;
+				}
+			}
+		}
+		
+		var anchor = new Anchor(this.id, ANCHOR_TYPE.main, x, y, index, typeIndex);
+		
+		this.anchors.push(anchor);
+	},
+	
+	getAnchor: function(position){
+		return this.anchors[position];
+	},
+	
+	getAnchorByType: function(type, position){
+		if (type == ANCHOR_TYPE.first)
+			return this.anchors[0];
+		if (type == ANCHOR_TYPE.last)
+			return this.anchors[this.getAnchorsCount()-1];
+		
+		for(var i=0; i < this.getAnchorsCount(); i++){
+			var anchor = this.anchors[i];
+			if (anchor.type == type) {
+				if( position == anchor.position)
+					return anchor;
+			}
+		}
+		return null;
+	},
+	
+	addNewPoint: function(position, x, y){
+		// 
+		for(var i = 0; i < this.getLinesCount(); i++){
+			var line = this.getLine(i);
+			if (x > line.x1 && x < line.x2 && y > line.y1 && y < line.y2) {
+				this.points.splice(i+1,0,{x: x, y: y});
+				break;
+			}
+		}
+		
+		this.rebuildPath();
+	},
+	
+	rebuildPath: function(){
+		var path = [];
+		
+		for(var i = 0; i < this.getAnchorsCount(); i++){
+			var anchor = this.getAnchor(i);
+			
+			var pathType = ""
+			if (i==0)
+				pathType = "M";
+			else 
+				pathType = "L";
+			
+// TODO: save previous points and calculate new path just if points are updated, and then save currents values as previous
+			
+			var targetX = anchor.x, targetY = anchor.y;
+			if (i>0 && i < this.getAnchorsCount()-1) {
+				// get new x,y
+				var cx = anchor.x, cy = anchor.y;
+				
+				// pivot point of prev line
+				var AO = this.getLineLength(i-1);
+				if (AO < this.radius) {
+					AO = this.radius;
+				}
+				
+				this.isDefaultConditionAvailable = (this.isDefaultConditionAvailable || (i == 1 && AO > 10));
+				//console.log("isDefaultConditionAvailable", this.isDefaultConditionAvailable);
+				
+				var ED = this.getLineLengthY(i-1) * this.radius / AO;
+				var OD = this.getLineLengthX(i-1) * this.radius / AO;
+					targetX = anchor.x - OD;
+					targetY = anchor.y - ED;
+				
+				if (AO < 2*this.radius && i>1) {
+					targetX = anchor.x - this.getLineLengthX(i-1)/2;
+					targetY = anchor.y - this.getLineLengthY(i-1)/2;;
+				}
+					
+				// pivot point of next line
+				var AO = this.getLineLength(i);
+				if (AO < this.radius) {
+					AO = this.radius;
+				}
+				var ED = this.getLineLengthY(i) * this.radius / AO;
+				var OD = this.getLineLengthX(i) * this.radius / AO;
+					var nextSrcX = anchor.x + OD;
+					var nextSrcY = anchor.y + ED;
+					
+				if (AO < 2*this.radius && i<this.getAnchorsCount()-2) {
+					nextSrcX = anchor.x + this.getLineLengthX(i)/2;
+					nextSrcY = anchor.y + this.getLineLengthY(i)/2;;
+				}
+					
+				
+				var dx0 = (cx - targetX) / 3,
+					dy0 = (cy - targetY) / 3,
+					ax = cx - dx0,
+					ay = cy - dy0,
+					
+					dx1 = (cx - nextSrcX) / 3,
+					dy1 = (cy - nextSrcY) / 3,
+					bx = cx - dx1,
+					by = cy - dy1,
+					
+					zx=nextSrcX, zy=nextSrcY;
+					
+				if (this.showDetails) {
+					var c = ProcessDiagramCanvas.g.path("M"+targetX+","+targetY+"L"+ax+","+ay).attr({stroke: Color.get(255, 153, 51), "stroke-dasharray": "- "});
+					var c = ProcessDiagramCanvas.g.path("M"+nextSrcX+","+nextSrcY+"L"+bx+","+by).attr({stroke: Color.get(255, 153, 51), "stroke-dasharray": "- "});
+					var c = ProcessDiagramCanvas.g.ellipse(ax, ay, 2, 2).attr({stroke: Color.SlateGrey});
+					var c = ProcessDiagramCanvas.g.ellipse(bx, by, 2, 2).attr({stroke: Color.SlateGrey});
+					var c = ProcessDiagramCanvas.g.ellipse(cx, cy, this.radius, this.radius).attr({stroke: Color.Gainsboro});
+					var c = ProcessDiagramCanvas.g.ellipse(targetX, targetY, 2, 2).attr({fill: Color.red});
+					var c = ProcessDiagramCanvas.g.ellipse(nextSrcX, nextSrcY, 2, 2).attr({fill: Color.red});
+				}
+			} else if (i==1 && this.getAnchorsCount() == 2){
+				var AO = this.getLineLength(i-1);
+				if (AO < this.radius) {
+					AO = this.radius;
+				}
+				this.isDefaultConditionAvailable = (this.isDefaultConditionAvailable || (i == 1 && AO > 10));
+				//console.log("-- isDefaultConditionAvailable", this.isDefaultConditionAvailable);
+			}
+
+			// anti smoothing
+			if (this.strokeWidth%2 == 1) {
+				targetX += 0.5;
+				targetY += 0.5;
+			}
+			
+			path.push([pathType, targetX, targetY]);
+			
+			if (i>0 && i < this.getAnchorsCount()-1) {
+				path.push(["C", ax, ay, bx, by, zx, zy]);
+			}
+		}
+		
+		if (this.closePath) {
+			console.log("closePath:", this.closePath);
+			path.push(["Z"]);
+		}
+		
+		this.path = path;
+	},
+	
+	transform: function(transformation){
+		this.element.transform(transformation);
+	},
+	attr: function(attrs){
+		//console.log("attrs: " +attrs, "", this.element);
+		// TODO: foreach and set each
+		this.element.attr(attrs);
+	}
+};
+
+function Polygone(points, strokeWidth) {
+	/* Array on coordinates:
+	 * points: [{x: 410, y: 110}, 1
+	 *			{x: 570, y: 110}, 1 2
+	 *			{x: 620, y: 240},   2 3
+	 *			{x: 750, y: 270},     3 4
+	 *			{x: 650, y: 370}];      4
+	 */
+	this.points = points;
+	
+	/*
+	 * path for graph
+	 * [["M", x1, y1], ["L", x2, y2], ["C", ax, ay, bx, by, x3, y3], ["L", x3, y3]]
+	 */
+	this.path = [];
+	
+	this.anchors = [];
+	
+	if (strokeWidth) this.strokeWidth = strokeWidth;
+	
+	this.closePath = true;
+	this.init();
+};
+
+
+/*
+ * Poligone is inherited from Poliline: draws closedPath of polyline
+ */
+
+var Foo = function () { };
+Foo.prototype = Polyline.prototype;
+
+Polygone.prototype = new Foo();
+
+Polygone.prototype.rebuildPath = function(){
+	var path = [];
+	//console.log("Polygone rebuildPath");
+	for(var i = 0; i < this.getAnchorsCount(); i++){
+		var anchor = this.getAnchor(i);
+		
+		var pathType = ""
+		if (i==0)
+			pathType = "M";
+		else 
+			pathType = "L";
+		
+		var targetX = anchor.x, targetY = anchor.y;
+		
+		// anti smoothing
+		if (this.strokeWidth%2 == 1) {
+			targetX += 0.5;
+			targetY += 0.5;
+		}
+		
+		path.push([pathType, targetX, targetY]);	
+	}
+	if (this.closePath)
+		path.push(["Z"]);
+	
+	this.path = path;
+};
+/*
+Polygone.prototype.transform = function(transformation){
+	this.element.transform(transformation);
+};
+*/