Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.gfx.path"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojox.gfx.path"] = true;

dojo.provide("dojox.gfx.path");

dojo.require("dojox.gfx.shape");

dojo.declare("dojox.gfx.path.Path", dojox.gfx.Shape, {

	// summary: a generalized path shape

	constructor: function(rawNode){

		// summary: a path constructor

		// rawNode: Node: a DOM node to be used by this path object

		this.shape = dojo.clone(dojox.gfx.defaultPath);

		this.segments = [];

		this.absolute = true;

		this.last = {};

		this.rawNode = rawNode;

	},

	// mode manipulations

	setAbsoluteMode: function(mode){

		// summary: sets an absolute or relative mode for path points

		// mode: Boolean: true/false or "absolute"/"relative" to specify the mode

		this.absolute = typeof mode == "string" ? (mode == "absolute") : mode;

		return this; // self

	},

	getAbsoluteMode: function(){

		// summary: returns a current value of the absolute mode

		return this.absolute; // Boolean

	},

	getBoundingBox: function(){

		// summary: returns the bounding box {x, y, width, height} or null

		return (this.bbox && ("l" in this.bbox)) ? {x: this.bbox.l, y: this.bbox.t, width: this.bbox.r - this.bbox.l, height: this.bbox.b - this.bbox.t} : null; // dojox.gfx.Rectangle

	},

	getLastPosition: function(){

		// summary: returns the last point in the path, or null

		return "x" in this.last ? this.last : null; // Object

	},

	// segment interpretation

	_updateBBox: function(x, y){

		// summary: updates the bounding box of path with new point

		// x: Number: an x coordinate

		// y: Number: a y coordinate

		// we use {l, b, r, t} representation of a bbox

		if(this.bbox && ("l" in this.bbox)){

			if(this.bbox.l > x) this.bbox.l = x;

			if(this.bbox.r < x) this.bbox.r = x;

			if(this.bbox.t > y) this.bbox.t = y;

			if(this.bbox.b < y) this.bbox.b = y;

		}else{

			this.bbox = {l: x, b: y, r: x, t: y};

		}

	},

	_updateWithSegment: function(segment){

		// summary: updates the bounding box of path with new segment

		// segment: Object: a segment

		var n = segment.args, l = n.length;

		// update internal variables: bbox, absolute, last

		switch(segment.action){

			case "M":

			case "L":

			case "C":

			case "S":

			case "Q":

			case "T":

				for(var i = 0; i < l; i += 2){

					this._updateBBox(n[i], n[i + 1]);

				}

				this.last.x = n[l - 2];

				this.last.y = n[l - 1];

				this.absolute = true;

				break;

			case "H":

				for(var i = 0; i < l; ++i){

					this._updateBBox(n[i], this.last.y);

				}

				this.last.x = n[l - 1];

				this.absolute = true;

				break;

			case "V":

				for(var i = 0; i < l; ++i){

					this._updateBBox(this.last.x, n[i]);

				}

				this.last.y = n[l - 1];

				this.absolute = true;

				break;

			case "m":

				var start = 0;

				if(!("x" in this.last)){

					this._updateBBox(this.last.x = n[0], this.last.y = n[1]);

					start = 2;

				}

				for(var i = start; i < l; i += 2){

					this._updateBBox(this.last.x += n[i], this.last.y += n[i + 1]);

				}

				this.absolute = false;

				break;

			case "l":

			case "t":

				for(var i = 0; i < l; i += 2){

					this._updateBBox(this.last.x += n[i], this.last.y += n[i + 1]);

				}

				this.absolute = false;

				break;

			case "h":

				for(var i = 0; i < l; ++i){

					this._updateBBox(this.last.x += n[i], this.last.y);

				}

				this.absolute = false;

				break;

			case "v":

				for(var i = 0; i < l; ++i){

					this._updateBBox(this.last.x, this.last.y += n[i]);

				}

				this.absolute = false;

				break;

			case "c":

				for(var i = 0; i < l; i += 6){

					this._updateBBox(this.last.x + n[i], this.last.y + n[i + 1]);

					this._updateBBox(this.last.x + n[i + 2], this.last.y + n[i + 3]);

					this._updateBBox(this.last.x += n[i + 4], this.last.y += n[i + 5]);

				}

				this.absolute = false;

				break;

			case "s":

			case "q":

				for(var i = 0; i < l; i += 4){

					this._updateBBox(this.last.x + n[i], this.last.y + n[i + 1]);

					this._updateBBox(this.last.x += n[i + 2], this.last.y += n[i + 3]);

				}

				this.absolute = false;

				break;

			case "A":

				for(var i = 0; i < l; i += 7){

					this._updateBBox(n[i + 5], n[i + 6]);

				}

				this.last.x = n[l - 2];

				this.last.y = n[l - 1];

				this.absolute = true;

				break;

			case "a":

				for(var i = 0; i < l; i += 7){

					this._updateBBox(this.last.x += n[i + 5], this.last.y += n[i + 6]);

				}

				this.absolute = false;

				break;

		}

		// add an SVG path segment

		var path = [segment.action];

		for(var i = 0; i < l; ++i){

			path.push(dojox.gfx.formatNumber(n[i], true));

		}

		if(typeof this.shape.path == "string"){

			this.shape.path += path.join("");

		}else{

			var l = path.length, a = this.shape.path;

			for(var i = 0; i < l; ++i){

				a.push(path[i]);

			}

		}

	},

	// a dictionary, which maps segment type codes to a number of their argemnts

	_validSegments: {m: 2, l: 2, h: 1, v: 1, c: 6, s: 4, q: 4, t: 2, a: 7, z: 0},

	_pushSegment: function(action, args){

		// summary: adds a segment

		// action: String: valid SVG code for a segment's type

		// args: Array: a list of parameters for this segment

		var group = this._validSegments[action.toLowerCase()];

		if(typeof group == "number"){

			if(group){

				if(args.length >= group){

					var segment = {action: action, args: args.slice(0, args.length - args.length % group)};

					this.segments.push(segment);

					this._updateWithSegment(segment);

				}

			}else{

				var segment = {action: action, args: []};

				this.segments.push(segment);

				this._updateWithSegment(segment);

			}

		}

	},

	_collectArgs: function(array, args){

		// summary: converts an array of arguments to plain numeric values

		// array: Array: an output argument (array of numbers)

		// args: Array: an input argument (can be values of Boolean, Number, dojox.gfx.Point, or an embedded array of them)

		for(var i = 0; i < args.length; ++i){

			var t = args[i];

			if(typeof t == "boolean"){

				array.push(t ? 1 : 0);

			}else if(typeof t == "number"){

				array.push(t);

			}else if(t instanceof Array){

				this._collectArgs(array, t);

			}else if("x" in t && "y" in t){

				array.push(t.x, t.y);

			}

		}

	},

	// segments

	moveTo: function(){

		// summary: formes a move segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "M" : "m", args);

		return this; // self

	},

	lineTo: function(){

		// summary: formes a line segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "L" : "l", args);

		return this; // self

	},

	hLineTo: function(){

		// summary: formes a horizontal line segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "H" : "h", args);

		return this; // self

	},

	vLineTo: function(){

		// summary: formes a vertical line segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "V" : "v", args);

		return this; // self

	},

	curveTo: function(){

		// summary: formes a curve segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "C" : "c", args);

		return this; // self

	},

	smoothCurveTo: function(){

		// summary: formes a smooth curve segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "S" : "s", args);

		return this; // self

	},

	qCurveTo: function(){

		// summary: formes a quadratic curve segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "Q" : "q", args);

		return this; // self

	},

	qSmoothCurveTo: function(){

		// summary: formes a quadratic smooth curve segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "T" : "t", args);

		return this; // self

	},

	arcTo: function(){

		// summary: formes an elliptic arc segment

		var args = [];

		this._collectArgs(args, arguments);

		this._pushSegment(this.absolute ? "A" : "a", args);

		return this; // self

	},

	closePath: function(){

		// summary: closes a path

		this._pushSegment("Z", []);

		return this; // self

	},

	// setShape

	_setPath: function(path){

		// summary: forms a path using an SVG path string

		// path: String: an SVG path string

		var p = dojo.isArray(path) ? path : path.match(dojox.gfx.pathSvgRegExp);

		this.segments = [];

		this.absolute = true;

		this.bbox = {};

		this.last = {};

		if(!p) return;

		// create segments

		var action = "",	// current action

			args = [],		// current arguments

			l = p.length;

		for(var i = 0; i < l; ++i){

			var t = p[i], x = parseFloat(t);

			if(isNaN(x)){

				if(action){

					this._pushSegment(action, args);

				}

				args = [];

				action = t;

			}else{

				args.push(x);

			}

		}

		this._pushSegment(action, args);

	},

	setShape: function(newShape){

		// summary: forms a path using a shape

		// newShape: Object: an SVG path string or a path object (see dojox.gfx.defaultPath)

		dojox.gfx.Shape.prototype.setShape.call(this, typeof newShape == "string" ? {path: newShape} : newShape);

		var path = this.shape.path;

		// switch to non-updating version of path building

		this.shape.path = [];

		this._setPath(path);

		// switch back to the string path

		this.shape.path = this.shape.path.join("");

		return this; // self

	},

	// useful constant for descendants

	_2PI: Math.PI * 2

});

dojo.declare("dojox.gfx.path.TextPath", dojox.gfx.path.Path, {

	// summary: a generalized TextPath shape

	constructor: function(rawNode){

		// summary: a TextPath shape constructor

		// rawNode: Node: a DOM node to be used by this TextPath object

		if(!("text" in this)){

			this.text = dojo.clone(dojox.gfx.defaultTextPath);

		}

		if(!("fontStyle" in this)){

			this.fontStyle = dojo.clone(dojox.gfx.defaultFont);

		}

	},

	setText: function(newText){

		// summary: sets a text to be drawn along the path

		this.text = dojox.gfx.makeParameters(this.text,

			typeof newText == "string" ? {text: newText} : newText);

		this._setText();

		return this;	// self

	},

	setFont: function(newFont){

		// summary: sets a font for text

		this.fontStyle = typeof newFont == "string" ?

			dojox.gfx.splitFontString(newFont) :

			dojox.gfx.makeParameters(dojox.gfx.defaultFont, newFont);

		this._setFont();

		return this;	// self

	}

});

}