diff options
Diffstat (limited to 'includes/js/dojox/gfx/path.js')
| -rw-r--r-- | includes/js/dojox/gfx/path.js | 361 |
1 files changed, 361 insertions, 0 deletions
diff --git a/includes/js/dojox/gfx/path.js b/includes/js/dojox/gfx/path.js new file mode 100644 index 0000000..657136b --- /dev/null +++ b/includes/js/dojox/gfx/path.js @@ -0,0 +1,361 @@ +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); + } + }, + getText: function(){ + // summary: returns the current text object or null + return this.text; // Object + }, + 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 + }, + getFont: function(){ + // summary: returns the current font object or null + return this.fontStyle; // Object + }, + 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 + } +}); + +} |