Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/svg.js URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/svg.js?view=auto&rev=473755 ============================================================================== --- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/svg.js (added) +++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/svg.js Sat Nov 11 08:44:22 2006 @@ -0,0 +1,543 @@ +dojo.provide("dojo.gfx.svg"); + +dojo.require("dojo.lang.declare"); +dojo.require("dojo.svg"); + +dojo.require("dojo.gfx.color"); +dojo.require("dojo.gfx.common"); +dojo.require("dojo.gfx.shape"); +dojo.require("dojo.gfx.path"); + +dojo.require("dojo.experimental"); +dojo.experimental("dojo.gfx.svg"); + +dojo.gfx.svg.getRef = function(fill){ + if(!fill || fill == "none") return null; + if(fill.match(/^url\(#.+\)$/)){ + return dojo.byId(fill.slice(5, -1)); + } + // Opera's bug: incorrect representation of a reference + if(dojo.render.html.opera && fill.match(/^#dj_unique_.+$/)){ + // we assume here that a reference was generated by dojo.gfx + return dojo.byId(fill.slice(1)); + } + return null; +}; + +dojo.lang.extend(dojo.gfx.Shape, { + setStroke: function(stroke){ + if(!stroke){ + // don't stroke + this.strokeStyle = null; + this.rawNode.setAttribute("stroke", "none"); + this.rawNode.setAttribute("stroke-opacity", 0); + return this; + } + // normalize the stroke + this.strokeStyle = dojo.gfx.makeParameters(dojo.gfx.defaultStroke, stroke); + this.strokeStyle.color = dojo.gfx.normalizeColor(this.strokeStyle.color); + // generate attributes + var s = this.strokeStyle; + var rn = this.rawNode; + if(s){ + rn.setAttribute("stroke", s.color.toCss()); + rn.setAttribute("stroke-opacity", s.color.a); + rn.setAttribute("stroke-width", s.width); + rn.setAttribute("stroke-linecap", s.cap); + if(typeof(s.join) == "number"){ + rn.setAttribute("stroke-linejoin", "miter"); + rn.setAttribute("stroke-miterlimit", s.join); + }else{ + rn.setAttribute("stroke-linejoin", s.join); + } + } + return this; + }, + + setFill: function(fill){ + if(!fill){ + // don't fill + this.fillStyle = null; + this.rawNode.setAttribute("fill", "none"); + this.rawNode.setAttribute("fill-opacity", 0); + return this; + } + if(typeof(fill) == "object" && "type" in fill){ + // gradient + switch(fill.type){ + case "linear": + var f = dojo.gfx.makeParameters(dojo.gfx.defaultLinearGradient, fill); + var gradient = this._setFillObject(f, "linearGradient"); + dojo.lang.forEach(["x1", "y1", "x2", "y2"], function(x){ + gradient.setAttribute(x, f[x].toFixed(8)); + }); + break; + case "radial": + var f = dojo.gfx.makeParameters(dojo.gfx.defaultRadialGradient, fill); + var gradient = this._setFillObject(f, "radialGradient"); + dojo.lang.forEach(["cx", "cy", "r"], function(x){ + gradient.setAttribute(x, f[x].toFixed(8)); + }); + break; + case "pattern": + var f = dojo.gfx.makeParameters(dojo.gfx.defaultPattern, fill); + var pattern = this._setFillObject(f, "pattern"); + dojo.lang.forEach(["x", "y", "width", "height"], function(x){ + pattern.setAttribute(x, f[x].toFixed(8)); + }); + break; + } + return this; + } + // color object + var f = dojo.gfx.normalizeColor(fill); + this.fillStyle = f; + this.rawNode.setAttribute("fill", f.toCss()); + this.rawNode.setAttribute("fill-opacity", f.a); + return this; + }, + + _setFillObject: function(/*Object*/f, /*String*/nodeType){ + var def_elems = this.rawNode.parentNode.getElementsByTagName("defs"); + if(def_elems.length == 0){ return this; } + this.fillStyle = f; + var defs = def_elems[0]; + var fill = this.rawNode.getAttribute("fill"); + var ref = dojo.gfx.svg.getRef(fill); + if(ref){ + fill = ref; + if(fill.tagName.toLowerCase() != nodeType.toLowerCase()){ + var id = fill.id; + fill.parentNode.removeChild(fill); + fill = document.createElementNS(dojo.svg.xmlns.svg, nodeType); + fill.setAttribute("id", id); + defs.appendChild(fill); + }else{ + while(fill.childNodes.length){ + fill.removeChild(fill.lastChild); + } + } + }else{ + fill = document.createElementNS(dojo.svg.xmlns.svg, nodeType); + fill.setAttribute("id", dojo.dom.getUniqueId()); + defs.appendChild(fill); + } + if(nodeType == "pattern"){ + fill.setAttribute("patternUnits", "userSpaceOnUse"); + var img = document.createElementNS(dojo.svg.xmlns.svg, "image"); + img.setAttribute("x", 0); + img.setAttribute("y", 0); + img.setAttribute("width", f.width .toFixed(8)); + img.setAttribute("height", f.height.toFixed(8)); + img.setAttributeNS(dojo.svg.xmlns.xlink, "href", f.src); + fill.appendChild(img); + }else{ + fill.setAttribute("gradientUnits", "userSpaceOnUse"); + for(var i = 0; i < f.colors.length; ++i){ + f.colors[i].color = dojo.gfx.normalizeColor(f.colors[i].color); + var t = document.createElementNS(dojo.svg.xmlns.svg, "stop"); + t.setAttribute("offset", f.colors[i].offset.toFixed(8)); + t.setAttribute("stop-color", f.colors[i].color.toCss()); + fill.appendChild(t); + } + } + this.rawNode.setAttribute("fill", "url(#" + fill.getAttribute("id") +")"); + this.rawNode.removeAttribute("fill-opacity"); + return fill; + }, + + _applyTransform: function() { + var matrix = this._getRealMatrix(); + if(matrix){ + var tm = this.matrix; + this.rawNode.setAttribute("transform", "matrix(" + + tm.xx.toFixed(8) + "," + tm.yx.toFixed(8) + "," + + tm.xy.toFixed(8) + "," + tm.yy.toFixed(8) + "," + + tm.dx.toFixed(8) + "," + tm.dy.toFixed(8) + ")"); + }else{ + this.rawNode.removeAttribute("transform"); + } + return this; + }, + + setRawNode: function(rawNode){ + // summary: + // assigns and clears the underlying node that will represent this + // shape. Once set, transforms, gradients, etc, can be applied. + // no fill & stroke by default + with(rawNode){ + setAttribute("fill", "none"); + setAttribute("fill-opacity", 0); + setAttribute("stroke", "none"); + setAttribute("stroke-opacity", 0); + setAttribute("stroke-width", 1); + setAttribute("stroke-linecap", "butt"); + setAttribute("stroke-linejoin", "miter"); + setAttribute("stroke-miterlimit", 4); + } + this.rawNode = rawNode; + }, + + moveToFront: function(){ + this.rawNode.parentNode.appendChild(this.rawNode); + return this; + }, + moveToBack: function(){ + this.rawNode.parentNode.insertBefore(this.rawNode, this.rawNode.parentNode.firstChild); + return this; + }, + + setShape: function(newShape){ + this.shape = dojo.gfx.makeParameters(this.shape, newShape); + for(var i in this.shape){ + if(i != "type"){ this.rawNode.setAttribute(i, this.shape[i]); } + } + return this; + }, + + attachFill: function(rawNode){ + var fillStyle = null; + if(rawNode){ + var fill = rawNode.getAttribute("fill"); + if(fill == "none"){ return; } + var ref = dojo.gfx.svg.getRef(fill); + if(ref){ + var gradient = ref; + switch(gradient.tagName.toLowerCase()){ + case "lineargradient": + fillStyle = this._getGradient(dojo.gfx.defaultLinearGradient, gradient); + dojo.lang.forEach(["x1", "y1", "x2", "y2"], function(x){ + fillStyle[x] = gradient.getAttribute(x); + }); + break; + case "radialgradient": + fillStyle = this._getGradient(dojo.gfx.defaultRadialGradient, gradient); + dojo.lang.forEach(["cx", "cy", "r"], function(x){ + fillStyle[x] = gradient.getAttribute(x); + }); + fillStyle.cx = gradient.getAttribute("cx"); + fillStyle.cy = gradient.getAttribute("cy"); + fillStyle.r = gradient.getAttribute("r"); + break; + case "pattern": + fillStyle = dojo.lang.shallowCopy(dojo.gfx.defaultPattern, true); + dojo.lang.forEach(["x", "y", "width", "height"], function(x){ + fillStyle[x] = gradient.getAttribute(x); + }); + fillStyle.src = gradient.firstChild.getAttributeNS(dojo.svg.xmlns.xlink, "href"); + break; + } + }else{ + fillStyle = new dojo.gfx.color.Color(fill); + var opacity = rawNode.getAttribute("fill-opacity"); + if(opacity != null) fillStyle.a = opacity; + } + } + return fillStyle; + }, + + _getGradient: function(defaultGradient, gradient){ + var fillStyle = dojo.lang.shallowCopy(defaultGradient, true); + fillStyle.colors = []; + for(var i = 0; i < gradient.childNodes.length; ++i){ + fillStyle.colors.push({ + offset: gradient.childNodes[i].getAttribute("offset"), + color: new dojo.gfx.color.Color(gradient.childNodes[i].getAttribute("stop-color")) + }); + } + return fillStyle; + }, + + attachStroke: function(rawNode){ + if(!rawNode){ return; } + var stroke = rawNode.getAttribute("stroke"); + if(stroke == null || stroke == "none") return null; + var strokeStyle = dojo.lang.shallowCopy(dojo.gfx.defaultStroke, true); + var color = new dojo.gfx.color.Color(stroke); + if(color){ + strokeStyle.color = color; + strokeStyle.color.a = rawNode.getAttribute("stroke-opacity"); + strokeStyle.width = rawNode.getAttribute("stroke-width"); + strokeStyle.cap = rawNode.getAttribute("stroke-linecap"); + strokeStyle.join = rawNode.getAttribute("stroke-linejoin"); + if(strokeStyle.join == "miter"){ + strokeStyle.join = rawNode.getAttribute("stroke-miterlimit"); + } + } + return strokeStyle; + }, + + attachTransform: function(rawNode){ + var matrix = null; + if(rawNode){ + matrix = rawNode.getAttribute("transform"); + if(matrix.match(/^matrix\(.+\)$/)){ + var t = matrix.slice(7, -1).split(","); + matrix = dojo.gfx.matrix.normalize({ + xx: parseFloat(t[0]), xy: parseFloat(t[2]), + yx: parseFloat(t[1]), yy: parseFloat(t[3]), + dx: parseFloat(t[4]), dy: parseFloat(t[5]) + }); + } + } + return matrix; + }, + + attachShape: function(rawNode){ + var shape = null; + if(rawNode){ + shape = dojo.lang.shallowCopy(this.shape, true); + for(var i in shape) { + shape[i] = rawNode.getAttribute(i); + } + } + return shape; + }, + + attach: function(rawNode){ + if(rawNode) { + this.rawNode = rawNode; + this.fillStyle = this.attachFill(rawNode); + this.strokeStyle = this.attachStroke(rawNode); + this.matrix = this.attachTransform(rawNode); + this.shape = this.attachShape(rawNode); + } + } +}); + +dojo.declare("dojo.gfx.Group", dojo.gfx.Shape, { + setRawNode: function(rawNode){ + this.rawNode = rawNode; + } +}); +dojo.gfx.Group.nodeType = "g"; + +dojo.declare("dojo.gfx.Rect", dojo.gfx.shape.Rect, { + attachShape: function(rawNode){ + var shape = null; + if(rawNode){ + shape = dojo.gfx.Rect.superclass.attachShape.apply(this, arguments); + shape.r = Math.min(rawNode.getAttribute("rx"), rawNode.getAttribute("ry")); + } + return shape; + }, + setShape: function(newShape){ + this.shape = dojo.gfx.makeParameters(this.shape, newShape); + this.bbox = null; + for(var i in this.shape){ + if(i != "type" && i != "r"){ this.rawNode.setAttribute(i, this.shape[i]); } + } + this.rawNode.setAttribute("rx", this.shape.r); + this.rawNode.setAttribute("ry", this.shape.r); + return this; + } +}); +dojo.gfx.Rect.nodeType = "rect"; + +dojo.gfx.Ellipse = dojo.gfx.shape.Ellipse; +dojo.gfx.Ellipse.nodeType = "ellipse"; + +dojo.gfx.Circle = dojo.gfx.shape.Circle; +dojo.gfx.Circle.nodeType = "circle"; + +dojo.gfx.Line = dojo.gfx.shape.Line; +dojo.gfx.Line.nodeType = "line"; + +dojo.declare("dojo.gfx.Polyline", dojo.gfx.shape.Polyline, { + setShape: function(points){ + if(points && points instanceof Array){ + this.shape = dojo.gfx.makeParameters(this.shape, { points: points }); + if(closed && this.shape.points.length){ + this.shape.points.push(this.shape.points[0]); + } + }else{ + this.shape = dojo.gfx.makeParameters(this.shape, points); + } + this.box = null; + var attr = []; + var p = this.shape.points; + for(var i = 0; i < p.length; ++i){ + attr.push(p[i].x.toFixed(8)); + attr.push(p[i].y.toFixed(8)); + } + this.rawNode.setAttribute("points", attr.join(" ")); + return this; + } +}); +dojo.gfx.Polyline.nodeType = "polyline"; + +dojo.declare("dojo.gfx.Image", dojo.gfx.shape.Image, { + setShape: function(newShape){ + this.shape = dojo.gfx.makeParameters(this.shape, newShape); + this.bbox = null; + var rawNode = this.rawNode; + for(var i in this.shape){ + if(i != "type" && i != "src"){ rawNode.setAttribute(i, this.shape[i]); } + } + rawNode.setAttributeNS(dojo.svg.xmlns.xlink, "href", this.shape.src); + return this; + }, + setStroke: function() { return this; }, + setFill: function() { return this; }, + attachStroke: function(rawNode){ return null; }, + attachFill: function(rawNode){ return null; } +}); +dojo.gfx.Image.nodeType = "image"; + +dojo.declare("dojo.gfx.Path", dojo.gfx.path.Path, +{ + _updateWithSegment: function(segment){ + dojo.gfx.Path.superclass._updateWithSegment.apply(this, arguments); + if(typeof(this.shape.path) == "string"){ + this.rawNode.setAttribute("d", this.shape.path); + } + }, + setShape: function(newShape){ + dojo.gfx.Path.superclass.setShape.apply(this, arguments); + this.rawNode.setAttribute("d", this.shape.path); + return this; + } +}); +dojo.gfx.Path.nodeType = "path"; + +dojo.gfx._creators = { + // creators + createPath: function(path){ + return this.createObject(dojo.gfx.Path, path); + }, + createRect: function(rect){ + return this.createObject(dojo.gfx.Rect, rect); + }, + createCircle: function(circle){ + return this.createObject(dojo.gfx.Circle, circle); + }, + createEllipse: function(ellipse){ + return this.createObject(dojo.gfx.Ellipse, ellipse); + }, + createLine: function(line){ + return this.createObject(dojo.gfx.Line, line); + }, + createPolyline: function(points){ + return this.createObject(dojo.gfx.Polyline, points); + }, + createImage: function(image){ + return this.createObject(dojo.gfx.Image, image); + }, + createGroup: function(){ + return this.createObject(dojo.gfx.Group); + }, + createObject: function(/*Function*/shapeType, /*Object*/rawShape){ + // summary: creates an instance of the passed shapeType class + // shapeType: a class constructor to create an instance of + // rawShape: properties to be passed in to the classes "setShape" method + + if(!this.rawNode){ return null; } + var shape = new shapeType(); + var node = document.createElementNS(dojo.svg.xmlns.svg, shapeType.nodeType); + shape.setRawNode(node); + this.rawNode.appendChild(node); + shape.setShape(rawShape); + this.add(shape); + return shape; + }, + // group control + add: function(shape){ + var oldParent = shape.getParent(); + if(oldParent){ + oldParent.remove(shape, true); + } + shape._setParent(this, null); + this.rawNode.appendChild(shape.rawNode); + return this; + }, + remove: function(shape, silently){ + if(this.rawNode == shape.rawNode.parentNode){ + this.rawNode.removeChild(shape.rawNode); + } + shape._setParent(null, null); + return this; + } +}; + +dojo.gfx.attachNode = function(node){ + if(!node) return null; + var s = null; + switch(node.tagName.toLowerCase()){ + case dojo.gfx.Rect.nodeType: + s = new dojo.gfx.Rect(); + break; + case dojo.gfx.Ellipse.nodeType: + s = new dojo.gfx.Ellipse(); + break; + case dojo.gfx.Polyline.nodeType: + s = new dojo.gfx.Polyline(); + break; + case dojo.gfx.Path.nodeType: + s = new dojo.gfx.Path(); + break; + case dojo.gfx.Circle.nodeType: + s = new dojo.gfx.Circle(); + break; + case dojo.gfx.Line.nodeType: + s = new dojo.gfx.Line(); + break; + case dojo.gfx.Image.nodeType: + s = new dojo.gfx.Image(); + break; + default: + dojo.debug("FATAL ERROR! tagName = " + node.tagName); + } + s.attach(node); + return s; +}; + +dojo.lang.extend(dojo.gfx.Surface, { + setDimensions: function(/*String*/width, /*String*/height){ + // summary: sets the width and height of the rawNode + if(!this.rawNode){ return this; } + this.rawNode.setAttribute("width", width); + this.rawNode.setAttribute("height", height); + return this; // dojo.gfx.Surface + }, + getDimensions: function(){ + // summary: returns an object with properties "width" and "height" + return this.rawNode ? {width: this.rawNode.getAttribute("width"), height: this.rawNode.getAttribute("height")} : null; // Object + } +}); + +dojo.gfx.createSurface = function(parentNode, width, height){ + var s = new dojo.gfx.Surface(); + s.rawNode = document.createElementNS(dojo.svg.xmlns.svg, "svg"); + s.rawNode.setAttribute("width", width); + s.rawNode.setAttribute("height", height); + + var defs = new dojo.gfx.svg.Defines(); + var node = document.createElementNS(dojo.svg.xmlns.svg, dojo.gfx.svg.Defines.nodeType); + defs.setRawNode(node); + s.rawNode.appendChild(node); + + dojo.byId(parentNode).appendChild(s.rawNode); + return s; +}; + +dojo.gfx.attachSurface = function(node){ + var s = new dojo.gfx.Surface(); + s.rawNode = node; + return s; +}; + +dojo.lang.extend(dojo.gfx.Group, dojo.gfx._creators); +dojo.lang.extend(dojo.gfx.Surface, dojo.gfx._creators); + +delete dojo.gfx._creators; + +// Gradient and pattern +dojo.gfx.svg.Defines = function(){ + this.rawNode = null; +}; +dojo.lang.extend(dojo.gfx.svg.Defines, { + setRawNode: function(rawNode){ + this.rawNode = rawNode; + } +}); +dojo.gfx.svg.Defines.nodeType = "defs"; Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/svg.js ------------------------------------------------------------------------------ svn:eol-style = native Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/vml.js URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/vml.js?view=auto&rev=473755 ============================================================================== --- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/vml.js (added) +++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/vml.js Sat Nov 11 08:44:22 2006 @@ -0,0 +1,1147 @@ +dojo.provide("dojo.gfx.vml"); + +dojo.require("dojo.dom"); +dojo.require("dojo.math"); +dojo.require("dojo.lang.declare"); +dojo.require("dojo.lang.extras"); +dojo.require("dojo.string.*"); +dojo.require("dojo.html.metrics"); + +dojo.require("dojo.gfx.color"); +dojo.require("dojo.gfx.common"); +dojo.require("dojo.gfx.shape"); +dojo.require("dojo.gfx.path"); + +dojo.require("dojo.experimental"); +dojo.experimental("dojo.gfx.vml"); + +dojo.gfx.vml.xmlns = "urn:schemas-microsoft-com:vml"; + +dojo.gfx.vml._parseFloat = function(str) { + return str.match(/^\d+f$/i) ? parseInt(str) / 65536 : parseFloat(str); +}; + +dojo.gfx.vml.cm_in_pt = 72 / 2.54; +dojo.gfx.vml.mm_in_pt = 7.2 / 2.54; + +dojo.gfx.vml.px_in_pt = function(){ return dojo.html.getCachedFontMeasurements()["12pt"] / 12; }; + +dojo.gfx.vml.pt2px = function(len){ return len * this.px_in_pt(); }; +dojo.gfx.vml.px2pt = function(len){ return len / this.px_in_pt(); }; + +dojo.gfx.vml.normalizedLength = function(len) { + if(len.length == 0) return 0; + if(len.length > 2){ + var px_in_pt = this.px_in_pt(); + var val = parseFloat(len); + switch(len.slice(-2)){ + case "px": return val; + case "pt": return val * px_in_pt; + case "in": return val * 72 * px_in_pt; + case "pc": return val * 12 * px_in_pt; + case "mm": return val / this.mm_in_pt * px_in_pt; + case "cm": return val / this.cm_in_pt * px_in_pt; + } + } + return parseFloat(len); +}; + +dojo.lang.extend(dojo.gfx.Shape, { + setStroke: function(stroke){ + if(!stroke){ + // don't stroke + this.strokeStyle = null; + this.rawNode.stroked = false; + return this; + } + // normalize the stroke + this.strokeStyle = dojo.gfx.makeParameters(dojo.gfx.defaultStroke, stroke); + this.strokeStyle.color = dojo.gfx.normalizeColor(this.strokeStyle.color); + // generate attributes + var s = this.strokeStyle; + this.rawNode.stroked = true; + this.rawNode.strokecolor = s.color.toCss(); + this.rawNode.strokeweight = s.width + "px"; // TODO: should we assume that the width is always in pixels? + if(this.rawNode.stroke) { + this.rawNode.stroke.opacity = s.color.a; + this.rawNode.stroke.endcap = this._translate(this._capMap, s.cap); + if(typeof(s.join) == "number") { + this.rawNode.stroke.joinstyle = "miter"; + this.rawNode.stroke.miterlimit = s.join; + }else{ + this.rawNode.stroke.joinstyle = s.join; + // this.rawNode.stroke.miterlimit = s.width; + } + } + return this; + }, + + _capMap: { butt: 'flat' }, + _capMapReversed: { flat: 'butt' }, + + _translate: function(dict, value) { + return (value in dict) ? dict[value] : value; + }, + + setFill: function(fill){ + if(!fill){ + // don't fill + this.fillStyle = null; + this.rawNode.filled = false; + return this; + } + if(typeof(fill) == "object" && "type" in fill){ + // gradient + switch(fill.type){ + case "linear": + var f = dojo.gfx.makeParameters(dojo.gfx.defaultLinearGradient, fill); + this.fillStyle = f; + var s = ""; + for(var i = 0; i < f.colors.length; ++i){ + f.colors[i].color = dojo.gfx.normalizeColor(f.colors[i].color); + s += f.colors[i].offset.toFixed(8) + " " + f.colors[i].color.toHex() + ";"; + } + var fo = this.rawNode.fill; + fo.colors.value = s; + fo.method = "sigma"; + fo.type = "gradient"; + fo.angle = (dojo.math.radToDeg(Math.atan2(f.x2 - f.x1, f.y2 - f.y1)) + 180) % 360; + fo.on = true; + break; + case "radial": + var f = dojo.gfx.makeParameters(dojo.gfx.defaultRadialGradient, fill); + this.fillStyle = f; + var w = parseFloat(this.rawNode.style.width); + var h = parseFloat(this.rawNode.style.height); + var c = isNaN(w) ? 1 : 2 * f.r / w; + var i = f.colors.length - 1; + f.colors[i].color = dojo.gfx.normalizeColor(f.colors[i].color); + var s = "0 " + f.colors[i].color.toHex(); + for(; i >= 0; --i){ + f.colors[i].color = dojo.gfx.normalizeColor(f.colors[i].color); + s += (1 - c * f.colors[i].offset).toFixed(8) + " " + f.colors[i].color.toHex() + ";"; + } + var fo = this.rawNode.fill; + fo.colors.value = s; + fo.method = "sigma"; + fo.type = "gradientradial"; + if(isNaN(w) || isNaN(h)){ + fo.focusposition = "0.5 0.5"; + }else{ + fo.focusposition = (f.cx / w).toFixed(8) + " " + (f.cy / h).toFixed(8); + } + fo.focussize = "0 0"; + fo.on = true; + break; + case "pattern": + var f = dojo.gfx.makeParameters(dojo.gfx.defaultPattern, fill); + this.fillStyle = f; + var fo = this.rawNode.fill; + fo.type = "tile"; + fo.src = f.src; + if(f.width && f.height){ + // in points + fo.size.x = dojo.gfx.vml.px2pt(f.width); + fo.size.y = dojo.gfx.vml.px2pt(f.height); + } + fo.alignShape = false; + fo.position.x = 0; + fo.position.y = 0; + fo.origin.x = f.width ? f.x / f.width : 0; + fo.origin.y = f.height ? f.y / f.height : 0; + fo.on = true; + break; + } + this.rawNode.fill.opacity = 1; + return this; + } + // color object + this.fillStyle = dojo.gfx.normalizeColor(fill); + this.rawNode.fillcolor = this.fillStyle.toHex(); + this.rawNode.fill.opacity = this.fillStyle.a; + this.rawNode.filled = true; + return this; + }, + + _applyTransform: function() { + var matrix = this._getRealMatrix(); + if(!matrix) return this; + var skew = this.rawNode.skew; + if(typeof(skew) == "undefined"){ + for(var i = 0; i < this.rawNode.childNodes.length; ++i){ + if(this.rawNode.childNodes[i].tagName == "skew"){ + skew = this.rawNode.childNodes[i]; + break; + } + } + } + if(skew){ + skew.on = false; + var mt = matrix.xx.toFixed(8) + " " + matrix.xy.toFixed(8) + " " + + matrix.yx.toFixed(8) + " " + matrix.yy.toFixed(8) + " 0 0"; + var offset = Math.floor(matrix.dx).toFixed() + "px " + Math.floor(matrix.dy).toFixed() + "px"; + var l = parseFloat(this.rawNode.style.left); + var t = parseFloat(this.rawNode.style.top); + var w = parseFloat(this.rawNode.style.width); + var h = parseFloat(this.rawNode.style.height); + if(isNaN(l)) l = 0; + if(isNaN(t)) t = 0; + if(isNaN(w)) w = 1; + if(isNaN(h)) h = 1; + var origin = (-l / w - 0.5).toFixed(8) + " " + (-t / h - 0.5).toFixed(8); + skew.matrix = mt; + skew.origin = origin; + skew.offset = offset; + skew.on = true; + } + return this; + }, + + setRawNode: function(rawNode){ + rawNode.stroked = false; + rawNode.filled = false; + this.rawNode = rawNode; + }, + + // Attach family + attachStroke: function(rawNode) { + var strokeStyle = dojo.lang.shallowCopy(dojo.gfx.defaultStroke, true); + if(rawNode && rawNode.stroked){ + strokeStyle.color = new dojo.gfx.color.Color(rawNode.strokecolor.value); + dojo.debug("We are expecting an .75pt here, instead of strokeweight = " + rawNode.strokeweight ); + strokeStyle.width = dojo.gfx.vml.normalizedLength(rawNode.strokeweight+""); + strokeStyle.color.a = rawNode.stroke.opacity; + strokeStyle.cap = this._translate(this._capMapReversed, rawNode.stroke.endcap); + strokeStyle.join = rawNode.stroke.joinstyle == "miter" ? rawNode.stroke.miterlimit : rawNode.stroke.joinstyle; + }else{ + return null; + } + return strokeStyle; + }, + + attachFill: function(rawNode){ + var fillStyle = null; + var fo = rawNode.fill; + if(rawNode) { + if(fo.on && fo.type == "gradient"){ + var fillStyle = dojo.lang.shallowCopy(dojo.gfx.defaultLinearGradient, true); + var rad = dojo.math.degToRad(fo.angle); + fillStyle.x2 = Math.cos(rad); + fillStyle.y2 = Math.sin(rad); + fillStyle.colors = []; + var stops = fo.colors.value.split(";"); + for(var i = 0; i < stops.length; ++i){ + var t = stops[i].match(/\S+/g); + if(!t || t.length != 2) continue; + fillStyle.colors.push({offset: dojo.gfx.vml._parseFloat(t[0]), color: new dojo.gfx.color.Color(t[1])}); + } + }else if(fo.on && fo.type == "gradientradial"){ + var fillStyle = dojo.lang.shallowCopy(dojo.gfx.defaultRadialGradient, true); + var w = parseFloat(rawNode.style.width); + var h = parseFloat(rawNode.style.height); + fillStyle.cx = isNaN(w) ? 0 : fo.focusposition.x * w; + fillStyle.cy = isNaN(h) ? 0 : fo.focusposition.y * h; + fillStyle.r = isNaN(w) ? 1 : w / 2; + fillStyle.colors = []; + var stops = fo.colors.value.split(";"); + for(var i = stops.length - 1; i >= 0; --i){ + var t = stops[i].match(/\S+/g); + if(!t || t.length != 2) continue; + fillStyle.colors.push({offset: dojo.gfx.vml._parseFloat(t[0]), color: new dojo.gfx.color.Color(t[1])}); + } + }else if(fo.on && fo.type == "tile"){ + var fillStyle = dojo.lang.shallowCopy(dojo.gfx.defaultPattern, true); + fillStyle.width = dojo.gfx.vml.pt2px(fo.size.x); // from pt + fillStyle.height = dojo.gfx.vml.pt2px(fo.size.y); // from pt + fillStyle.x = fo.origin.x * fillStyle.width; + fillStyle.y = fo.origin.y * fillStyle.height; + fillStyle.src = fo.src; + }else if(fo.on && rawNode.fillcolor){ + // a color object ! + fillStyle = new dojo.gfx.color.Color(rawNode.fillcolor+""); + fillStyle.a = fo.opacity; + } + } + return fillStyle; + }, + + attachTransform: function(rawNode) { + var matrix = {}; + if(rawNode){ + var s = rawNode.skew; + matrix.xx = s.matrix.xtox; + matrix.xy = s.matrix.ytox; + matrix.yx = s.matrix.xtoy; + matrix.yy = s.matrix.ytoy; + matrix.dx = dojo.gfx.vml.pt2px(s.offset.x); + matrix.dy = dojo.gfx.vml.pt2px(s.offset.y); + } + return dojo.gfx.matrix.normalize(matrix); + }, + + attach: function(rawNode){ + if(rawNode){ + this.rawNode = rawNode; + this.shape = this.attachShape(rawNode); + this.fillStyle = this.attachFill(rawNode); + this.strokeStyle = this.attachStroke(rawNode); + this.matrix = this.attachTransform(rawNode); + } + } +}); + +dojo.declare("dojo.gfx.Group", dojo.gfx.shape.VirtualGroup, { + add: function(shape){ + if(this != shape.getParent()){ + this.rawNode.appendChild(shape.rawNode); + dojo.gfx.Group.superclass.add.apply(this, arguments); + } + return this; + }, + remove: function(shape, silently){ + if(this == shape.getParent()){ + if(this.rawNode == shape.rawNode.parentNode){ + this.rawNode.removeChild(shape.rawNode); + } + dojo.gfx.Group.superclass.remove.apply(this, arguments); + } + return this; + }, + attach: function(rawNode){ + if(rawNode){ + this.rawNode = rawNode; + this.shape = null; + this.fillStyle = null; + this.strokeStyle = null; + this.matrix = null; + } + } +}); +dojo.gfx.Group.nodeType = "group"; + +var zIndex = { + moveToFront: function(){ + this.rawNode.parentNode.appendChild(this.rawNode); + return this; + }, + moveToBack: function(){ + this.rawNode.parentNode.insertBefore(this.rawNode, this.rawNode.parentNode.firstChild); + return this; + } +}; +dojo.lang.extend(dojo.gfx.Shape, zIndex); +dojo.lang.extend(dojo.gfx.Group, zIndex); +delete zIndex; + +dojo.declare("dojo.gfx.Rect", dojo.gfx.shape.Rect, { + setShape: function(newShape){ + var shape = this.shape = dojo.gfx.makeParameters(this.shape, newShape); + this.bbox = null; + var style = this.rawNode.style; + style.left = shape.x.toFixed(); + style.top = shape.y.toFixed(); + style.width = (typeof(shape.width) == "string" && shape.width.indexOf("%") >= 0) ? shape.width : shape.width.toFixed(); + style.height = (typeof(shape.width) == "string" && shape.height.indexOf("%") >= 0) ? shape.height : shape.height.toFixed(); + var r = Math.min(1, (shape.r / Math.min(parseFloat(shape.width), parseFloat(shape.height)))).toFixed(8); + // a workaround for the VML's arcsize bug: cannot read arcsize of an instantiated node + var parent = this.rawNode.parentNode; + var before = null; + if(parent){ + if(parent.lastChild != this.rawNode){ + for(var i = 0; i < parent.childNodes.length; ++i){ + if(parent.childNodes[i] == this.rawNode){ + before = parent.childNodes[i+1]; + break; + } + } + } + parent.removeChild(this.rawNode); + } + this.rawNode.arcsize = r; + if(parent){ + if(before){ + parent.insertBefore(this.rawNode, before); + }else{ + parent.appendChild(this.rawNode); + } + } + return this.setTransform(this.matrix); + }, + attachShape: function(rawNode){ + // a workaround for the VML's arcsize bug: cannot read arcsize of an instantiated node + var arcsize = rawNode.outerHTML.match(/arcsize = \"(\d*\.?\d+[%f]?)\"/)[1]; + arcsize = (arcsize.indexOf("%") >= 0) ? parseFloat(arcsize) / 100 : dojo.gfx.vml._parseFloat(arcsize); + var style = rawNode.style; + var width = parseFloat(style.width); + var height = parseFloat(style.height); + // make an object + return dojo.gfx.makeParameters(dojo.gfx.defaultRect, { + x: parseInt(style.left), + y: parseInt(style.top), + width: width, + height: height, + r: Math.min(width, height) * arcsize + }); + } +}); +dojo.gfx.Rect.nodeType = "roundrect"; // use a roundrect so the stroke join type is respected + +dojo.declare("dojo.gfx.Ellipse", dojo.gfx.shape.Ellipse, { + setShape: function(newShape){ + var shape = this.shape = dojo.gfx.makeParameters(this.shape, newShape); + this.bbox = null; + var style = this.rawNode.style; + style.left = (shape.cx - shape.rx).toFixed(); + style.top = (shape.cy - shape.ry).toFixed(); + style.width = (shape.rx * 2).toFixed(); + style.height = (shape.ry * 2).toFixed(); + return this.setTransform(this.matrix); + }, + attachShape: function(rawNode){ + var style = this.rawNode.style; + var rx = parseInt(style.width ) / 2; + var ry = parseInt(style.height) / 2; + return dojo.gfx.makeParameters(dojo.gfx.defaultEllipse, { + cx: parseInt(style.left) + rx, + cy: parseInt(style.top ) + ry, + rx: rx, + ry: ry + }); + } +}); +dojo.gfx.Ellipse.nodeType = "oval"; + +dojo.declare("dojo.gfx.Circle", dojo.gfx.shape.Circle, { + setShape: function(newShape){ + var shape = this.shape = dojo.gfx.makeParameters(this.shape, newShape); + this.bbox = null; + var style = this.rawNode.style; + style.left = (shape.cx - shape.r).toFixed(); + style.top = (shape.cy - shape.r).toFixed(); + style.width = (shape.r * 2).toFixed(); + style.height = (shape.r * 2).toFixed(); + return this; + }, + attachShape: function(rawNode){ + var style = this.rawNode.style; + var r = parseInt(style.width) / 2; + return dojo.gfx.makeParameters(dojo.gfx.defaultCircle, { + cx: parseInt(style.left) + r, + cy: parseInt(style.top) + r, + r: r + }); + } +}); +dojo.gfx.Circle.nodeType = "oval"; + +dojo.declare("dojo.gfx.Line", dojo.gfx.shape.Line, + function(rawNode){ + if(rawNode) rawNode.setAttribute("dojoGfxType", "line"); + }, { + setShape: function(newShape){ + var shape = this.shape = dojo.gfx.makeParameters(this.shape, newShape); + this.bbox = null; + this.rawNode.path.v = "m" + shape.x1.toFixed() + " " + shape.y1.toFixed() + + "l" + shape.x2.toFixed() + " " + shape.y2.toFixed() + "e"; + return this.setTransform(this.matrix); + }, + attachShape: function(rawNode){ + var p = rawNode.path.v.match(dojo.gfx.pathRegExp); + var shape = {}; + do{ + if(p.length < 7 || p[0] != "m" || p[3] != "l" || p[6] != "e") break; + shape.x1 = parseInt(p[1]); + shape.y1 = parseInt(p[2]); + shape.x2 = parseInt(p[4]); + shape.y2 = parseInt(p[5]); + }while(false); + return dojo.gfx.makeParameters(dojo.gfx.defaultLine, shape); + } +}); +dojo.gfx.Line.nodeType = "shape"; + +dojo.declare("dojo.gfx.Polyline", dojo.gfx.shape.Polyline, + function(rawNode){ + if(rawNode) rawNode.setAttribute("dojoGfxType", "polyline"); + }, { + setShape: function(points, closed){ + if(points && points instanceof Array){ + this.shape = dojo.gfx.makeParameters(this.shape, { points: points }); + if(closed && this.shape.points.length) this.shape.points.push(this.shape.points[0]); + }else{ + this.shape = dojo.gfx.makeParameters(this.shape, points); + } + this.bbox = null; + var attr = []; + var p = this.shape.points; + if(p.length > 0){ + attr.push("m"); + attr.push(p[0].x.toFixed()); + attr.push(p[0].y.toFixed()); + if(p.length > 1){ + attr.push("l"); + for(var i = 1; i < p.length; ++i){ + attr.push(p[i].x.toFixed()); + attr.push(p[i].y.toFixed()); + } + } + } + attr.push("e"); + this.rawNode.path.v = attr.join(" "); + return this.setTransform(this.matrix); + }, + attachShape: function(rawNode){ + var shape = dojo.lang.shallowCopy(dojo.gfx.defaultPolyline, true); + var p = rawNode.path.v.match(dojo.gfx.pathRegExp); + do{ + if(p.length < 3 || p[0] != "m") break; + var x = parseInt(p[0]); + var y = parseInt(p[1]); + if(isNaN(x) || isNaN(y)) break; + shape.points.push({x: x, y: y}); + if(p.length < 6 || p[3] != "l") break; + for(var i = 4; i < p.length; i += 2){ + x = parseInt(p[i]); + y = parseInt(p[i + 1]); + if(isNaN(x) || isNaN(y)) break; + shape.points.push({x: x, y: y}); + } + }while(false); + return shape; + } +}); +dojo.gfx.Polyline.nodeType = "shape"; + +dojo.declare("dojo.gfx.Image", dojo.gfx.shape.Image, { + getEventSource: function() { + return this.rawNode ? this.rawNode.firstChild : null; + }, + setShape: function(newShape){ + var shape = this.shape = dojo.gfx.makeParameters(this.shape, newShape); + this.bbox = null; + var firstChild = this.rawNode.firstChild; + firstChild.src = shape.src; + if(shape.width || shape.height){ + firstChild.style.width = shape.width; + firstChild.style.height = shape.height; + } + return this.setTransform(this.matrix); + }, + setStroke: function() { return this; }, + setFill: function() { return this; }, + attachShape: function(rawNode){ + var shape = dojo.lang.shallowCopy(dojo.gfx.defaultImage, true); + shape.src = rawNode.firstChild.src; + return shape; + }, + attachStroke: function(rawNode){ return null; }, + attachFill: function(rawNode){ return null; }, + attachTransform: function(rawNode) { + var matrix = {}; + if(rawNode){ + var m = rawNode.filters["DXImageTransform.Microsoft.Matrix"]; + matrix.xx = m.M11; + matrix.xy = m.M12; + matrix.yx = m.M21; + matrix.yy = m.M22; + matrix.dx = m.Dx; + matrix.dy = m.Dy; + } + return dojo.gfx.matrix.normalize(matrix); + }, + _applyTransform: function() { + var matrix = this._getRealMatrix(); + if(!matrix) return this; + with(this.rawNode.filters["DXImageTransform.Microsoft.Matrix"]){ + M11 = matrix.xx; + M12 = matrix.xy; + M21 = matrix.yx; + M22 = matrix.yy; + Dx = matrix.dx; + Dy = matrix.dy; + } + return this; + } +}); +dojo.gfx.Image.nodeType = "image"; + +dojo.gfx.path._calcArc = function(alpha){ + var cosa = Math.cos(alpha); + var sina = Math.sin(alpha); + // return a start point, 1st and 2nd control points, and an end point + var p2 = {x: cosa + (4 / 3) * (1 - cosa), y: sina - (4 / 3) * cosa * (1 - cosa) / sina}; + return { + s: {x: cosa, y: sina}, + c1: p2, + c2: {x: p2.x, y: -p2.y}, + e: {x: cosa, y: -sina} + }; +}; + +dojo.declare("dojo.gfx.Path", dojo.gfx.path.Path, + function(rawNode){ + if(rawNode) rawNode.setAttribute("dojoGfxType", "path"); + this.vmlPath = ""; + this.lastControl = {}; + }, { + _updateWithSegment: function(segment){ + var last = dojo.lang.shallowCopy(this.last); + dojo.gfx.Path.superclass._updateWithSegment.apply(this, arguments); + // add a VML path segment + var path = this[this.renderers[segment.action]](segment, last); + if(typeof(this.vmlPath) == "string"){ + this.vmlPath += path.join(""); + }else{ + this.vmlPath = this.vmlPath.concat(path); + } + if(typeof(this.vmlPath) == "string"){ + this.rawNode.path.v = this.vmlPath + " e"; + } + }, + setShape: function(newShape){ + this.vmlPath = []; + this.lastControl = {}; + dojo.gfx.Path.superclass.setShape.apply(this, arguments); + this.vmlPath = this.vmlPath.join(""); + this.rawNode.path.v = this.vmlPath + " e"; + return this; + }, + _pathVmlToSvgMap: {m: "M", l: "L", t: "m", r: "l", c: "C", v: "c", qb: "Q", x: "z", e: ""}, + attachShape: function(rawNode){ + var shape = dojo.lang.shallowCopy(dojo.gfx.defaultPath, true); + var p = rawNode.path.v.match(dojo.gfx.pathRegExp); + var t = [], skip = false; + for(var i = 0; i < p.length; ++p){ + var s = p[i]; + if(s in this._pathVmlToSvgMap) { + skip = false; + t.push(this._pathVmlToSvgMap[s]); + } else if(!skip){ + var n = parseInt(s); + if(isNaN(n)){ + skip = true; + }else{ + t.push(n); + } + } + } + if(t.length) shape.path = t.join(" "); + return shape; + }, + // VML-specific segment renderers + renderers: { + M: "_moveToA", m: "_moveToR", + L: "_lineToA", l: "_lineToR", + H: "_hLineToA", h: "_hLineToR", + V: "_vLineToA", v: "_vLineToR", + C: "_curveToA", c: "_curveToR", + S: "_smoothCurveToA", s: "_smoothCurveToR", + Q: "_qCurveToA", q: "_qCurveToR", + T: "_qSmoothCurveToA", t: "_qSmoothCurveToR", + A: "_arcTo", a: "_arcTo", + Z: "_closePath", z: "_closePath" + }, + _addArgs: function(path, args, from, upto){ + if(typeof(upto) == "undefined"){ + upto = args.length; + } + if(typeof(from) == "undefined"){ + from = 0; + } + for(var i = from; i < upto; ++i){ + path.push(" "); + path.push(args[i].toFixed()); + } + }, + _addArgsAdjusted: function(path, last, args, from, upto){ + if(typeof(upto) == "undefined"){ + upto = args.length; + } + if(typeof(from) == "undefined"){ + from = 0; + } + for(var i = from; i < upto; i += 2){ + path.push(" "); + path.push((last.x + args[i]).toFixed()); + path.push(" "); + path.push((last.y + args[i + 1]).toFixed()); + } + }, + _moveToA: function(segment){ + var p = [" m"]; + var n = segment.args; + var l = n.length; + if(l == 2){ + this._addArgs(p, n); + }else{ + this._addArgs(p, n, 0, 2); + p.push(" l"); + this._addArgs(p, n, 2); + } + this.lastControl = {}; + return p; + }, + _moveToR: function(segment, last){ + var p = ["x" in last ? " t" : " m"]; + var n = segment.args; + var l = n.length; + if(l == 2){ + this._addArgs(p, n); + }else{ + this._addArgs(p, n, 0, 2); + p.push(" r"); + this._addArgs(p, n, 2); + } + this.lastControl = {}; + return p; + }, + _lineToA: function(segment){ + var p = [" l"]; + this._addArgs(p, segment.args); + this.lastControl = {}; + return p; + }, + _lineToR: function(segment){ + var p = [" r"]; + this._addArgs(p, segment.args); + this.lastControl = {}; + return p; + }, + _hLineToA: function(segment, last){ + var p = [" l"]; + var n = segment.args; + var l = n.length; + var y = " " + last.y.toFixed(); + for(var i = 0; i < l; ++i){ + p.push(" "); + p.push(n[i].toFixed()); + p.push(y); + } + this.lastControl = {}; + return p; + }, + _hLineToR: function(segment){ + var p = [" r"]; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; ++i){ + p.push(" "); + p.push(n[i].toFixed()); + p.push(" 0"); + } + this.lastControl = {}; + return p; + }, + _vLineToA: function(segment, last){ + var p = [" l"]; + var n = segment.args; + var l = n.length; + var x = " " + last.x.toFixed(); + for(var i = 0; i < l; ++i){ + p.push(x); + p.push(" "); + p.push(n[i].toFixed()); + } + this.lastControl = {}; + return p; + }, + _vLineToR: function(segment){ + var p = [" r"]; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; ++i){ + p.push(" 0 "); + p.push(n[i].toFixed()); + } + this.lastControl = {}; + return p; + }, + _curveToA: function(segment){ + var p = []; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; i += 6){ + p.push(" c"); + this._addArgs(p, n, i, i + 6); + } + this.lastControl = {x: n[l - 4], y: n[l - 3], type: "C"}; + return p; + }, + _curveToR: function(segment, last){ + var p = []; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; i += 6){ + p.push(" v"); + this._addArgs(p, n, i, i + 6); + this.lastControl = {x: last.x + n[i + 2], y: last.y + n[i + 3]}; + last.x += n[i + 4]; + last.y += n[i + 5]; + } + this.lastControl.type = "C"; + return p; + }, + _smoothCurveToA: function(segment, last){ + var p = []; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; i += 4){ + p.push(" c"); + if(this.lastControl.type == "C"){ + this._addArgs(p, [ + 2 * last.x - this.lastControl.x, + 2 * last.y - this.lastControl.y + ]); + }else{ + this._addArgs(p, [last.x, last.y]); + } + this._addArgs(p, n, i, i + 4); + } + this.lastControl = {x: n[l - 4], y: n[l - 3], type: "C"}; + return p; + }, + _smoothCurveToR: function(segment, last){ + var p = []; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; i += 4){ + p.push(" v"); + if(this.lastControl.type == "C"){ + this._addArgs(p, [ + last.x - this.lastControl.x, + last.y - this.lastControl.y + ]); + }else{ + this._addArgs(p, [0, 0]); + } + this._addArgs(p, n, i, i + 4); + this.lastControl = {x: last.x + n[i], y: last.y + n[i + 1]}; + last.x += n[i + 2]; + last.y += n[i + 3]; + } + this.lastControl.type = "C"; + return p; + }, + _qCurveToA: function(segment){ + var p = []; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; i += 4){ + p.push(" qb"); + this._addArgs(p, n, i, i + 4); + } + this.lastControl = {x: n[l - 4], y: n[l - 3], type: "Q"}; + return p; + }, + _qCurveToR: function(segment, last){ + var p = []; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; i += 4){ + p.push(" qb"); + this._addArgsAdjusted(p, last, n, i, i + 4); + this.lastControl = {x: last.x + n[i], y: last.y + n[i + 1]}; + last.x += n[i + 2]; + last.y += n[i + 3]; + } + this.lastControl.type = "Q"; + return p; + }, + _qSmoothCurveToA: function(segment, last){ + var p = []; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; i += 2){ + p.push(" qb"); + if(this.lastControl.type == "Q"){ + this._addArgs(p, [ + this.lastControl.x = 2 * last.x - this.lastControl.x, + this.lastControl.y = 2 * last.y - this.lastControl.y + ]); + }else{ + this._addArgs(p, [ + this.lastControl.x = last.x, + this.lastControl.y = last.y + ]); + } + this._addArgs(p, n, i, i + 2); + } + this.lastControl.type = "Q"; + return p; + }, + _qSmoothCurveToR: function(segment, last){ + var p = []; + var n = segment.args; + var l = n.length; + for(var i = 0; i < l; i += 2){ + p.push(" qb"); + if(this.lastControl.type == "Q"){ + this._addArgs(p, [ + this.lastControl.x = 2 * last.x - this.lastControl.x, + this.lastControl.y = 2 * last.y - this.lastControl.y + ]); + }else{ + this._addArgs(p, [ + this.lastControl.x = last.x, + this.lastControl.y = last.y + ]); + } + this._addArgsAdjusted(p, last, n, i, i + 2); + } + this.lastControl.type = "Q"; + return p; + }, + _PI4: Math.PI / 4, + _curvePI4: dojo.gfx.path._calcArc(Math.PI / 8), + _calcArcTo: function(path, last, rx, ry, xRotg, large, cw, x, y){ + var m = dojo.gfx.matrix; + // calculate parameters + var xRot = -dojo.math.degToRad(xRotg); + var rx2 = rx * rx; + var ry2 = ry * ry; + var pa = m.multiplyPoint( + m.rotate(-xRot), + {x: (last.x - x) / 2, y: (last.y - y) / 2} + ); + var pax2 = pa.x * pa.x; + var pay2 = pa.y * pa.y; + var c1 = Math.sqrt((rx2 * ry2 - rx2 * pay2 - ry2 * pax2) / (rx2 * pay2 + ry2 * pax2)); + var ca = { + x: c1 * rx * pa.y / ry, + y: -c1 * ry * pa.x / rx + }; + if(large == cw){ + ca = {x: -ca.x, y: -ca.y}; + } + // our center + var c = m.multiplyPoint( + [ + m.translate( + (last.x + x) / 2, + (last.y + y) / 2 + ), + m.rotate(xRot) + ], + ca + ); + // start of our arc + var startAngle = Math.atan2(c.y - last.y, last.x - c.x) - xRot; + var endAngle = Math.atan2(c.y - y, x - c.x) - xRot; + // size of our arc in radians + var theta = cw ? startAngle - endAngle : endAngle - startAngle; + if(theta < 0){ + theta += this._2PI; + }else if(theta > this._2PI){ + theta = this._2PI; + } + // calculate our elliptic transformation + var elliptic_transform = m.normalize([ + m.translate(c.x, c.y), + m.rotate(xRot), + m.scale(rx, ry) + ]); + // draw curve chunks + var alpha = this._PI4 / 2; + var curve = this._curvePI4; + var step = cw ? -alpha : alpha; + for(var angle = theta; angle > 0; angle -= this._PI4){ + if(angle < this._PI4){ + alpha = angle / 2; + curve = dojo.gfx.path._calcArc(alpha); + step = cw ? -alpha : alpha; + } + var c1, c2, e; + var M = m.normalize([elliptic_transform, m.rotate(startAngle + step)]); + if(cw){ + c1 = m.multiplyPoint(M, curve.c2); + c2 = m.multiplyPoint(M, curve.c1); + e = m.multiplyPoint(M, curve.s ); + }else{ + c1 = m.multiplyPoint(M, curve.c1); + c2 = m.multiplyPoint(M, curve.c2); + e = m.multiplyPoint(M, curve.e ); + } + // draw the curve + path.push(" c"); + this._addArgs(path, [c1.x, c1.y, c2.x, c2.y, e.x, e.y]); + startAngle += 2 * step; + } + }, + _arcTo: function(segment, last){ + var p = []; + var n = segment.args; + var l = n.length; + var relative = segment.action == "a"; + for(var i = 0; i < l; i += 7){ + var x1 = n[i + 5]; + var y1 = n[i + 6]; + if(relative){ + x1 += last.x; + y1 += last.y; + } + this._calcArcTo( + p, last, n[i], n[i + 1], n[i + 2], + n[i + 3] ? 1 : 0, n[i + 4] ? 1 : 0, + x1, y1 + ); + last = {x: x1, y: y1}; + } + this.lastControl = {}; + return p; + }, + _closePath: function(){ + this.lastControl = {}; + return ["x"]; + } +}); +dojo.gfx.Path.nodeType = "shape"; + + +dojo.gfx._creators = { + createRect: function(rect){ + return this.createObject(dojo.gfx.Rect, rect); + }, + createEllipse: function(ellipse){ + return this.createObject(dojo.gfx.Ellipse, ellipse); + }, + createCircle: function(circle){ + return this.createObject(dojo.gfx.Circle, circle); + }, + createLine: function(line){ + return this.createObject(dojo.gfx.Line, line, true); + }, + createPolyline: function(points){ + return this.createObject(dojo.gfx.Polyline, points, true); + }, + createPath: function(path){ + return this.createObject(dojo.gfx.Path, path, true); + }, + createGroup: function(path){ + return this.createObject(dojo.gfx.Group, null, true); + }, + createImage: function(image){ + if(!this.rawNode) return null; + var shape = new dojo.gfx.Image(); + var node = document.createElement('div'); + node.style.position = "relative"; + node.style.width = this.rawNode.style.width; + node.style.height = this.rawNode.style.height; + node.style.filter = "progid:DXImageTransform.Microsoft.Matrix(M11=1, M12=0, M21=0, M22=1, Dx=0, Dy=0)"; + var img = document.createElement('img'); + node.appendChild(img); + shape.setRawNode(node); + this.rawNode.appendChild(node); + shape.setShape(image); + this.add(shape); + return shape; + }, + createObject: function(shapeType, rawShape, overrideSize) { + if(!this.rawNode) return null; + var shape = new shapeType(); + var node = document.createElement('v:' + shapeType.nodeType); + shape.setRawNode(node); + this.rawNode.appendChild(node); + if(overrideSize) this._overrideSize(node); + shape.setShape(rawShape); + this.add(shape); + return shape; + }, + _overrideSize: function(node){ + node.style.width = this.rawNode.style.width; + node.style.height = this.rawNode.style.height; + node.coordsize = parseFloat(node.style.width) + " " + parseFloat(node.style.height); + } +}; + +dojo.lang.extend(dojo.gfx.Group, dojo.gfx._creators); +dojo.lang.extend(dojo.gfx.Surface, dojo.gfx._creators); + +delete dojo.gfx._creators; + +dojo.gfx.attachNode = function(node){ + if(!node) return null; + var s = null; + switch(node.tagName.toLowerCase()){ + case dojo.gfx.Rect.nodeType: + s = new dojo.gfx.Rect(); + break; + case dojo.gfx.Ellipse.nodeType: + s = (node.style.width == node.style.height) + ? new dojo.gfx.Circle() + : new dojo.gfx.Ellipse(); + break; + case dojo.gfx.Path.nodeType: + switch(node.getAttribute("dojoGfxType")){ + case "line": + s = new dojo.gfx.Line(); + break; + case "polyline": + s = new dojo.gfx.Polyline(); + break; + case "path": + s = new dojo.gfx.Path(); + break; + } + break; + case dojo.gfx.Image.nodeType: + s = new dojo.gfx.Image(); + break; + default: + dojo.debug("FATAL ERROR! tagName = " + node.tagName); + } + s.attach(node); + return s; +}; + +dojo.lang.extend(dojo.gfx.Surface, { + setDimensions: function(width, height){ + if(!this.rawNode) return this; + this.rawNode.style.width = width; + this.rawNode.style.height = height; + this.rawNode.coordsize = width + " " + height; + return this; + }, + getDimensions: function(){ + return this.rawNode ? { width: this.rawNode.style.width, height: this.rawNode.style.height } : null; + }, + // group control + add: function(shape){ + var oldParent = shape.getParent(); + if(this != oldParent){ + this.rawNode.appendChild(shape.rawNode); + if(oldParent){ + oldParent.remove(shape, true); + } + shape._setParent(this, null); + } + return this; + }, + remove: function(shape, silently){ + if(this == shape.getParent()){ + if(this.rawNode == shape.rawNode.parentNode){ + this.rawNode.removeChild(shape.rawNode); + } + shape._setParent(null, null); + } + return this; + } +}); + +dojo.gfx.createSurface = function(parentNode, width, height){ + var s = new dojo.gfx.Surface(); + s.rawNode = document.createElement("v:group"); + s.rawNode.style.width = width ? width : "100%"; + s.rawNode.style.height = height ? height : "100%"; + s.rawNode.coordsize = (width && height) + ? (parseFloat(width) + " " + parseFloat(height)) + : "100% 100%"; + s.rawNode.coordorigin = "0 0"; + dojo.byId(parentNode).appendChild(s.rawNode); + return s; +}; + +dojo.gfx.attachSurface = function(node){ + var s = new dojo.gfx.Surface(); + s.rawNode = node; + return s; +}; Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/gfx/vml.js ------------------------------------------------------------------------------ svn:eol-style = native Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/Colorspace.js URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/Colorspace.js?view=auto&rev=473755 ============================================================================== --- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/Colorspace.js (added) +++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/Colorspace.js Sat Nov 11 08:44:22 2006 @@ -0,0 +1,5 @@ +dojo.provide("dojo.graphics.Colorspace"); +dojo.require("dojo.gfx.Colorspace"); + +dojo.deprecated("dojo.graphics.Colorspace: use dojo.gfx.Colorspace instead.", "0.5"); +dojo.graphics.Colorspace = dojo.gfx.Colorspace; Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/Colorspace.js ------------------------------------------------------------------------------ svn:eol-style = native Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/__package__.js URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/__package__.js?view=auto&rev=473755 ============================================================================== --- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/__package__.js (added) +++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/__package__.js Sat Nov 11 08:44:22 2006 @@ -0,0 +1,2 @@ +// By default... don't pull in anything? (todo: figure out what should be in list) +dojo.provide("dojo.graphics.*"); Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/__package__.js ------------------------------------------------------------------------------ svn:eol-style = native Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color.js URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color.js?view=auto&rev=473755 ============================================================================== --- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color.js (added) +++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color.js Sat Nov 11 08:44:22 2006 @@ -0,0 +1,27 @@ +dojo.provide("dojo.graphics.color"); +dojo.require("dojo.gfx.color"); + +dojo.deprecated("dojo.graphics.color.Color is now dojo.gfx.color.Color.", "0.5"); +dojo.graphics.color.Color = dojo.gfx.color.Color; + +dojo.graphics.color.named = dojo.gfx.color.named; +dojo.graphics.color.blend = function(a, b, weight) { + dojo.deprecated("dojo.graphics.color.blend is now dojo.gfx.color.blend", "0.5"); + return dojo.gfx.color.blend(a, b, weight); +} +dojo.graphics.color.blendHex = function(a, b, weight) { + dojo.deprecated("dojo.graphics.color.blendHex is now dojo.gfx.color.blendHex", "0.5"); + return dojo.gfx.color.rgb2hex(dojo.gfx.color.blend(dojo.gfx.color.hex2rgb(a), dojo.gfx.color.hex2rgb(b), weight)); +} +dojo.graphics.color.extractRGB = function(color) { + dojo.deprecated("dojo.graphics.color.extractRGB is now dojo.gfx.color.extractRGB", "0.5"); + return dojo.gfx.color.extractRGB(color); +} +dojo.graphics.color.hex2rgb = function(hex) { + dojo.deprecated("dojo.graphics.color.hex2rgb is now dojo.gfx.color.hex2rgb", "0.5"); + return dojo.gfx.color.hex2rgb(hex); +} +dojo.graphics.color.rgb2hex = function(r, g, b) { + dojo.deprecated("dojo.graphics.color.rgb2hex is now dojo.gfx.color.rgb2hex", "0.5"); + return dojo.gfx.color.rgb2hex; +} Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color.js ------------------------------------------------------------------------------ svn:eol-style = native Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsl.js URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsl.js?view=auto&rev=473755 ============================================================================== --- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsl.js (added) +++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsl.js Sat Nov 11 08:44:22 2006 @@ -0,0 +1,23 @@ +dojo.provide("dojo.graphics.color.hsl"); +dojo.require("dojo.gfx.color.hsl"); + +dojo.deprecated("dojo.graphics.color.hsl has been replaced with dojo.gfx.color.hsl", "0.5"); + +dojo.graphics.color.rgb2hsl = function(r, g, b){ + dojo.deprecated("dojo.graphics.color.rgb2hsl has been replaced with dojo.gfx.color.rgb2hsl", "0.5"); + return dojo.gfx.color.rgb2hsl(r, g, b); +} +dojo.graphics.color.hsl2rgb = function(h, s, l){ + dojo.deprecated("dojo.graphics.color.hsl2rgb has been replaced with dojo.gfx.color.hsl2rgb", "0.5"); + return dojo.gfx.color.hsl2rgb(h, s, l); +} + +dojo.graphics.color.hsl2hex = function(h, s, l){ + dojo.deprecated("dojo.graphics.color.hsl2hex has been replaced with dojo.gfx.color.hsl2hex", "0.5"); + return dojo.gfx.color.hsl2hex(h, s, l); +} + +dojo.graphics.color.hex2hsl = function(hex){ + dojo.deprecated("dojo.graphics.color.hex2hsl has been replaced with dojo.gfx.color.hex2hsl", "0.5"); + return dojo.gfx.color.hex2hsl(hex); +} Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsl.js ------------------------------------------------------------------------------ svn:eol-style = native Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsv.js URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsv.js?view=auto&rev=473755 ============================================================================== --- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsv.js (added) +++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsv.js Sat Nov 11 08:44:22 2006 @@ -0,0 +1,13 @@ +dojo.provide("dojo.graphics.color.hsv"); +dojo.require("dojo.gfx.color.hsv"); + +dojo.deprecated("dojo.graphics.color.hsv has been replaced by dojo.gfx.color.hsv", "0.5"); + +dojo.graphics.color.rgb2hsv = function(r, g, b){ + dojo.deprecated("dojo.graphics.color.rgb2hsv has been replaced by dojo.gfx.color.rgb2hsv", "0.5"); + return dojo.gfx.color.rgb2hsv(r, g, b); +} +dojo.graphics.color.hsv2rgb = function(h, s, v){ + dojo.deprecated("dojo.graphics.color.hsv2rgb has been replaced by dojo.gfx.color.hsv2rgb", "0.5"); + return dojo.gfx.color.hsv2rgb(h, s, v); +} Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/graphics/color/hsv.js ------------------------------------------------------------------------------ svn:eol-style = native Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/hostenv_adobesvg.js URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/hostenv_adobesvg.js?view=auto&rev=473755 ============================================================================== --- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/hostenv_adobesvg.js (added) +++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/hostenv_adobesvg.js Sat Nov 11 08:44:22 2006 @@ -0,0 +1,561 @@ +/* + * Adobe SVG Viewer host environment + */ +if(typeof window == 'undefined'){ + dojo.raise("attempt to use adobe svg hostenv when no window object"); +} + +with(dojo.render){ + name = navigator.appName; + ver = parseFloat(navigator.appVersion, 10); + switch(navigator.platform){ + case "MacOS": + os.osx = true; + break; + case "Linux": + os.linux = true; + break; + case "Windows": + os.win = true; + break; + default: + os.linux = true; + break; + }; + svg.capable = true; + svg.support.builtin = true; + svg.adobe = true; +}; + +// browserEval("alert(window.location);"); + +dojo.hostenv.println = function(s){ + try{ + // FIXME: this may not work with adobe's viewer, as we may first need a + // reference to the svgDocument + // FIXME: need a way to determine where to position the text for this + var ti = document.createElement("text"); + ti.setAttribute("x","50"); + var yPos = 25 + 15*document.getElementsByTagName("text").length; + ti.setAttribute("y",yPos); + var tn = document.createTextNode(s); + ti.appendChild(tn); + document.documentElement.appendChild(ti); + }catch(e){ + + } +} + +dojo.debug = function() { + if (!djConfig.isDebug) { return; } + var args = arguments; + if(typeof dojo.hostenv.println != 'function'){ + dojo.raise("attempt to call dojo.debug when there is no dojo.hostenv println implementation (yet?)"); + } + var isJUM = dj_global["jum"]; + var s = isJUM ? "": "DEBUG: "; + for(var i=0;i 0){ + dojo.debug("couldn't initialize, there are files still in flight"); + return; + } + this.modulesLoadedFired = true; + var mll = this.modulesLoadedListeners; + for(var x=0; x"+oa.join("\n")+""); +} + +dojo.hostenv.unwindUriStack = function(){ + var stack = this.loadUriStack; + for(var x in dojo.hostenv.loadedUris){ + for(var y=stack.length-1; y>=0; y--){ + if(stack[y][0]==x){ + stack.splice(y, 1); + } + } + } + var next = stack.pop(); + if((!next)&&(stack.length==0)){ + return; + } + for(var x=0; x"); + dj_eval(next[2]); + next[1](true); + }catch(e){ + dojo.debug("we got an error when loading "+next[0]); + dojo.debug("error: "+e); + // for(var x in e){ alert(x+" "+e[x]); } + } + dojo.hostenv.loadedUris[next[0]] = true; + dojo.hostenv.loadedUris.push(next[0]); + last = next; + next = stack.pop(); + if((!next)&&(stack.length==0)){ break; } + while(dojo.hostenv.loadedUris[next[0]]){ + last = next; + next = stack.pop(); + } + } + if(next){ + stack.push(next); + dojo.debug("### CHOKED ON: "+next[0]); + } +} + +/** + * Reads the contents of the URI, and evaluates the contents. + * Returns true if it succeeded. Returns false if the URI reading failed. Throws if the evaluation throws. + * The result of the eval is not available to the caller. + */ +dojo.hostenv.loadUri = function(uri, cb){ + if(dojo.hostenv.loadedUris[uri]){ + return; + } + var stack = this.loadUriStack; + stack.push([uri, cb, null]); + var tcb = function(contents){ + // gratuitous hack for Adobe SVG 3 + if(contents.content){ + contents = contents.content; + } + + // stack management + var next = stack.pop(); + if((!next)&&(stack.length==0)){ + dojo.hostenv.modulesLoaded(); + return; + } + if(typeof contents == "string"){ + stack.push(next); + for(var x=0; x0){ + eval(deps.join(";")); + }else{ + dojo.hostenv.unwindUriStack(); + } + } + } + } + this.getText(uri, tcb, true); +} + +/** + * Reads the contents of the URI, and evaluates the contents. + * Returns true if it succeeded. Returns false if the URI reading failed. Throws if the evaluation throws. + * The result of the eval is not available to the caller. + */ +dojo.hostenv.loadUri = function(uri, cb){ + if(dojo.hostenv.loadedUris[uri]){ + return; + } + var stack = this.loadUriStack; + stack.push([uri, cb, null]); + var tcb = function(contents){ + // gratuitous hack for Adobe SVG 3 + if(contents.content){ + contents = contents.content; + } + + // stack management + var next = stack.pop(); + if((!next)&&(stack.length==0)){ + dojo.hostenv.modulesLoaded(); + return; + } + if(typeof contents == "string"){ + stack.push(next); + for(var x=0; x0){ + eval(deps.join(";")); + }else{ + dojo.hostenv.unwindUriStack(); + } + } + } + } + this.getText(uri, tcb, true); +} + +/** +* loadModule("A.B") first checks to see if symbol A.B is defined. +* If it is, it is simply returned (nothing to do). +* If it is not defined, it will look for "A/B.js" in the script root directory, followed +* by "A.js". +* It throws if it cannot find a file to load, or if the symbol A.B is not defined after loading. +* It returns the object A.B. +* +* This does nothing about importing symbols into the current package. +* It is presumed that the caller will take care of that. For example, to import +* all symbols: +* +* with (dojo.hostenv.loadModule("A.B")) { +* ... +* } +* +* And to import just the leaf symbol: +* +* var B = dojo.hostenv.loadModule("A.B"); +* ... +* +* dj_load is an alias for dojo.hostenv.loadModule +*/ +dojo.hostenv.loadModule = function(modulename, exact_only, omit_module_check){ + // alert("dojo.hostenv.loadModule('"+modulename+"');"); + var module = this.findModule(modulename, 0); + if(module){ + return module; + } + + // dojo.debug("dojo.hostenv.loadModule('"+modulename+"');"); + + // protect against infinite recursion from mutual dependencies + if (typeof this.loading_modules_[modulename] !== 'undefined'){ + // NOTE: this should never throw an exception!! "recursive" includes + // are normal in the course of app and module building, so blow out of + // it gracefully, but log it in debug mode + + // dojo.raise("recursive attempt to load module '" + modulename + "'"); + dojo.debug("recursive attempt to load module '" + modulename + "'"); + }else{ + this.addedToLoadingCount.push(modulename); + } + this.loading_modules_[modulename] = 1; + + + // convert periods to slashes + var relpath = modulename.replace(/\./g, '/') + '.js'; + + var syms = modulename.split("."); + var nsyms = modulename.split("."); + if(syms[0]=="dojo"){ // FIXME: need a smarter way to do this! + syms[0] = "src"; + } + var last = syms.pop(); + syms.push(last); + // figure out if we're looking for a full package, if so, we want to do + // things slightly diffrently + var _this = this; + var pfn = this.pkgFileName; + if(last=="*"){ + modulename = (nsyms.slice(0, -1)).join('.'); + + var module = this.findModule(modulename, 0); + // dojo.debug("found: "+modulename+"="+module); + if(module){ + _this.removedFromLoadingCount.push(modulename); + return module; + } + + var nextTry = function(lastStatus){ + if(lastStatus){ + module = _this.findModule(modulename, false); // pass in false so we can give better error + if((!module)&&(syms[syms.length-1]!=pfn)){ + dojo.raise("Module symbol '" + modulename + "' is not defined after loading '" + relpath + "'"); + } + if(module){ + _this.removedFromLoadingCount.push(modulename); + dojo.hostenv.modulesLoaded(); + return; + } + } + syms.pop(); + syms.push(pfn); + // dojo.debug("syms: "+syms); + relpath = syms.join("/") + '.js'; + if(relpath.charAt(0)=="/"){ + relpath = relpath.slice(1); + } + // dojo.debug("relpath: "+relpath); + _this.loadPath(relpath, ((!omit_module_check) ? modulename : null), nextTry); + } + + nextTry(); + }else{ + relpath = syms.join("/") + '.js'; + modulename = nsyms.join('.'); + + var nextTry = function(lastStatus){ + // dojo.debug("lastStatus: "+lastStatus); + if(lastStatus){ + // dojo.debug("inital relpath: "+relpath); + module = _this.findModule(modulename, false); // pass in false so we can give better error + // if(!module){ + if((!module)&&(syms[syms.length-1]!=pfn)){ + dojo.raise("Module symbol '" + modulename + "' is not defined after loading '" + relpath + "'"); + } + if(module){ + _this.removedFromLoadingCount.push(modulename); + dojo.hostenv.modulesLoaded(); + return; + } + } + var setPKG = (syms[syms.length-1]==pfn) ? false : true; + syms.pop(); + if(setPKG){ + syms.push(pfn); + } + relpath = syms.join("/") + '.js'; + if(relpath.charAt(0)=="/"){ + relpath = relpath.slice(1); + } + // dojo.debug("relpath: "+relpath); + _this.loadPath(relpath, ((!omit_module_check) ? modulename : null), nextTry); + } + + this.loadPath(relpath, ((!omit_module_check) ? modulename : null), nextTry); + } + return; +} + +/** + * Read the contents of the specified uri and return those contents. + * + * FIXME: Make sure this is consistent with other implementations of getText + * @param uri A relative or absolute uri. If absolute, it still must be in the same "domain" as we are. + * @param async_cb If not specified, returns false as synchronous is not + * supported. If specified, load asynchronously, and use async_cb as the handler which receives the result of the request. + * @param fail_ok Default false. If fail_ok and !async_cb and loading fails, return null instead of throwing. + */ +dojo.hostenv.async_cb = null; + +dojo.hostenv.unWindGetTextStack = function(){ + if(dojo.hostenv.inFlightCount>0){ + setTimeout("dojo.hostenv.unWindGetTextStack()", 100); + return; + } + // we serialize because this environment is too messed up + // to know how to do anything else + dojo.hostenv.inFlightCount++; + var next = dojo.hostenv.getTextStack.pop(); + if((!next)&&(dojo.hostenv.getTextStack.length==0)){ + dojo.hostenv.inFlightCount--; + dojo.hostenv.async_cb = function(){}; + return; + } + dojo.hostenv.async_cb = next[1]; + // http = window.getURL(uri, dojo.hostenv.anon[cbn]); + window.getURL(next[0], function(result){ + dojo.hostenv.inFlightCount--; + dojo.hostenv.async_cb(result.content); + dojo.hostenv.unWindGetTextStack(); + }); +} + +dojo.hostenv.getText = function(uri, async_cb, fail_ok){ + // dojo.debug("Calling getText()"); + try{ + if(async_cb){ + dojo.hostenv.getTextStack.push([uri, async_cb, fail_ok]); + dojo.hostenv.unWindGetTextStack(); + }else{ + return dojo.raise("No synchronous XMLHTTP implementation available, for uri " + uri); + } + }catch(e){ + return dojo.raise("No XMLHTTP implementation available, for uri " + uri); + } +} + + +/** + * Makes an async post to the specified uri. + * + * FIXME: Not sure that we need this, but adding for completeness. + * More details about the implementation of this are available at + * http://wiki.svg.org/index.php/PostUrl + * @param uri A relative or absolute uri. If absolute, it still must be in the same "domain" as we are. + * @param async_cb If not specified, returns false as synchronous is not + * supported. If specified, load asynchronously, and use async_cb as the progress handler which takes the xmlhttp object as its argument. If async_cb, this function returns null. + * @param text Data to post + * @param fail_ok Default false. If fail_ok and !async_cb and loading fails, return null instead of throwing. + * @param mime_type optional MIME type of the posted data (such as "text/plain") + * @param encoding optional encoding for data. null, 'gzip' and 'deflate' are possible values. If browser does not support binary post this parameter is ignored. + */ +dojo.hostenv.postText = function(uri, async_cb, text, fail_ok, mime_type, encoding){ + var http = null; + + var async_callback = function(httpResponse){ + if (!httpResponse.success) { + dojo.raise("Request for uri '" + uri + "' resulted in " + httpResponse.status); + } + + if(!httpResponse.content) { + if (!fail_ok) dojo.raise("Request for uri '" + uri + "' resulted in no content"); + return null; + } + // FIXME: wtf, I'm losing a reference to async_cb + async_cb(httpResponse.content); + } + + try { + if(async_cb) { + http = window.postURL(uri, text, async_callback, mimeType, encoding); + } else { + return dojo.raise("No synchronous XMLHTTP post implementation available, for uri " + uri); + } + } catch(e) { + return dojo.raise("No XMLHTTP post implementation available, for uri " + uri); + } +} + +/* + * It turns out that if we check *right now*, as this script file is being loaded, + * then the last script element in the window DOM is ourselves. + * That is because any subsequent script elements haven't shown up in the document + * object yet. + */ +function dj_last_script_src() { + var scripts = window.document.getElementsByTagName('script'); + if(scripts.length < 1){ + dojo.raise("No script elements in window.document, so can't figure out my script src"); + } + var li = scripts.length-1; + var xlinkNS = "http://www.w3.org/1999/xlink"; + var src = null; + var script = null; + while(!src){ + script = scripts.item(li); + src = script.getAttributeNS(xlinkNS,"href"); + li--; + if(li<0){ break; } + // break; + } + if(!src){ + dojo.raise("Last script element (out of " + scripts.length + ") has no src"); + } + return src; +} + +if(!dojo.hostenv["library_script_uri_"]){ + dojo.hostenv.library_script_uri_ = dj_last_script_src(); +} + +// dojo.hostenv.loadUri = function(uri){ + /* FIXME: adding a script element doesn't seem to be synchronous, and so + * checking for namespace or object existance after loadUri using this + * method will error out. Need to figure out some other way of handling + * this! + */ + /* + var se = document.createElement("script"); + se.src = uri; + var head = document.getElementsByTagName("head")[0]; + head.appendChild(se); + // document.write("