diff options
Diffstat (limited to 'includes/js/dojox/gfx/vml_attach.js')
| -rw-r--r-- | includes/js/dojox/gfx/vml_attach.js | 362 |
1 files changed, 362 insertions, 0 deletions
diff --git a/includes/js/dojox/gfx/vml_attach.js b/includes/js/dojox/gfx/vml_attach.js new file mode 100644 index 0000000..b54d31b --- /dev/null +++ b/includes/js/dojox/gfx/vml_attach.js @@ -0,0 +1,362 @@ +dojo.require("dojox.gfx.vml"); + +dojo.experimental("dojox.gfx.vml_attach"); + +(function(){ + dojox.gfx.attachNode = function(node){ + // summary: creates a shape from a Node + // node: Node: an VML node + if(!node) return null; + var s = null; + switch(node.tagName.toLowerCase()){ + case dojox.gfx.Rect.nodeType: + s = new dojox.gfx.Rect(node); + attachRect(s); + break; + case dojox.gfx.Ellipse.nodeType: + if(node.style.width == node.style.height){ + s = new dojox.gfx.Circle(node); + attachCircle(s); + }else{ + s = new dojox.gfx.Ellipse(node); + attachEllipse(s); + } + break; + case dojox.gfx.Path.nodeType: + switch(node.getAttribute("dojoGfxType")){ + case "line": + s = new dojox.gfx.Line(node); + attachLine(s); + break; + case "polyline": + s = new dojox.gfx.Polyline(node); + attachPolyline(s); + break; + case "path": + s = new dojox.gfx.Path(node); + attachPath(s); + break; + case "text": + s = new dojox.gfx.Text(node); + attachText(s); + attachFont(s); + attachTextTransform(s); + break; + case "textpath": + s = new dojox.gfx.TextPath(node); + attachPath(s); + attachText(s); + attachFont(s); + break; + } + break; + case dojox.gfx.Image.nodeType: + switch(node.getAttribute("dojoGfxType")){ + case "image": + s = new dojox.gfx.Image(node); + attachImage(s); + attachImageTransform(s); + break; + } + break; + default: + //console.debug("FATAL ERROR! tagName = " + node.tagName); + return null; + } + if(!(s instanceof dojox.gfx.Image)){ + attachFill(s); + attachStroke(s); + if(!(s instanceof dojox.gfx.Text)){ + attachTransform(s); + } + } + return s; // dojox.gfx.Shape + }; + + dojox.gfx.attachSurface = function(node){ + // summary: creates a surface from a Node + // node: Node: an VML node + var s = new dojox.gfx.Surface(); + s.clipNode = node; + var r = s.rawNode = node.firstChild; + var b = r.firstChild; + if(!b || b.tagName != "rect"){ + return null; // dojox.gfx.Surface + } + s.bgNode = r; + return s; // dojox.gfx.Surface + }; + + var attachFill = function(object){ + // summary: deduces a fill style from a node. + // object: dojox.gfx.Shape: an VML shape + var fillStyle = null, r = object.rawNode, fo = r.fill; + if(fo.on && fo.type == "gradient"){ + var fillStyle = dojo.clone(dojox.gfx.defaultLinearGradient), + rad = dojox.gfx.matrix._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: dojox.gfx.vml._parseFloat(t[0]), color: new dojo.Color(t[1])}); + } + }else if(fo.on && fo.type == "gradientradial"){ + var fillStyle = dojo.clone(dojox.gfx.defaultRadialGradient), + w = parseFloat(r.style.width), h = parseFloat(r.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: dojox.gfx.vml._parseFloat(t[0]), color: new dojo.Color(t[1])}); + } + }else if(fo.on && fo.type == "tile"){ + var fillStyle = dojo.clone(dojox.gfx.defaultPattern); + fillStyle.width = dojox.gfx.pt2px(fo.size.x); // from pt + fillStyle.height = dojox.gfx.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 && r.fillcolor){ + // a color object ! + fillStyle = new dojo.Color(r.fillcolor+""); + fillStyle.a = fo.opacity; + } + object.fillStyle = fillStyle; + }; + + var attachStroke = function(object) { + // summary: deduces a stroke style from a node. + // object: dojox.gfx.Shape: an VML shape + var r = object.rawNode; + if(!r.stroked){ + object.strokeStyle = null; + return; + } + var strokeStyle = object.strokeStyle = dojo.clone(dojox.gfx.defaultStroke), + rs = r.stroke; + strokeStyle.color = new dojo.Color(r.strokecolor.value); + strokeStyle.width = dojox.gfx.normalizedLength(r.strokeweight+""); + strokeStyle.color.a = rs.opacity; + strokeStyle.cap = this._translate(this._capMapReversed, rs.endcap); + strokeStyle.join = rs.joinstyle == "miter" ? rs.miterlimit : rs.joinstyle; + strokeStyle.style = rs.dashstyle; + }; + + var attachTransform = function(object) { + // summary: deduces a transformation matrix from a node. + // object: dojox.gfx.Shape: an VML shape + var s = rawNode.skew, sm = s.matrix, so = s.offset; + object.matrix = dojox.gfx.matrix.normalize({ + xx: sm.xtox, + xy: sm.ytox, + yx: sm.xtoy, + yy: sm.ytoy, + dx: dojox.gfx.pt2px(so.x), + dy: dojox.gfx.pt2px(so.y) + }); + }; + + var attachGroup = function(object){ + // summary: reconstructs all group shape parameters from a node (VML). + // object: dojox.gfx.Shape: an VML shape + // attach the background + object.bgNode = object.rawNode.firstChild; // TODO: check it first + }; + + var attachRect = function(object){ + // summary: builds a rectangle shape from a node. + // object: dojox.gfx.Shape: an VML shape + // a workaround for the VML's arcsize bug: cannot read arcsize of an instantiated node + var r = object.rawNode, arcsize = r.outerHTML.match(/arcsize = \"(\d*\.?\d+[%f]?)\"/)[1], + style = r.style, width = parseFloat(style.width), height = parseFloat(style.height); + arcsize = (arcsize.indexOf("%") >= 0) ? parseFloat(arcsize) / 100 : dojox.gfx.vml._parseFloat(arcsize); + // make an object + object.shape = dojox.gfx.makeParameters(dojox.gfx.defaultRect, { + x: parseInt(style.left), + y: parseInt(style.top), + width: width, + height: height, + r: Math.min(width, height) * arcsize + }); + }; + + var attachEllipse = function(object){ + // summary: builds an ellipse shape from a node. + // object: dojox.gfx.Shape: an VML shape + var style = object.rawNode.style, + rx = parseInt(style.width ) / 2, + ry = parseInt(style.height) / 2; + object.shape = dojox.gfx.makeParameters(dojox.gfx.defaultEllipse, { + cx: parseInt(style.left) + rx, + cy: parseInt(style.top ) + ry, + rx: rx, + ry: ry + }); + }; + + var attachCircle = function(object){ + // summary: builds a circle shape from a node. + // object: dojox.gfx.Shape: an VML shape + var style = object.rawNode.style, r = parseInt(style.width) / 2; + object.shape = dojox.gfx.makeParameters(dojox.gfx.defaultCircle, { + cx: parseInt(style.left) + r, + cy: parseInt(style.top) + r, + r: r + }); + }; + + var attachLine = function(object){ + // summary: builds a line shape from a node. + // object: dojox.gfx.Shape: an VML shape + var shape = object.shape = dojo.clone(dojox.gfx.defaultLine), + p = object.rawNode.path.v.match(dojox.gfx.pathVmlRegExp); + 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); + }; + + var attachPolyline = function(object){ + // summary: builds a polyline/polygon shape from a node. + // object: dojox.gfx.Shape: an VML shape + var shape = object.shape = dojo.clone(dojox.gfx.defaultPolyline), + p = object.rawNode.path.v.match(dojox.gfx.pathVmlRegExp); + do{ + if(p.length < 3 || p[0] != "m"){ break; } + var x = parseInt(p[0]), 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); + }; + + var attachImage = function(object){ + // summary: builds an image shape from a node. + // object: dojox.gfx.Shape: an VML shape + object.shape = dojo.clone(dojox.gfx.defaultImage); + object.shape.src = object.rawNode.firstChild.src; + }; + + var attachImageTransform = function(object) { + // summary: deduces a transformation matrix from a node. + // object: dojox.gfx.Shape: an VML shape + var m = object.rawNode.filters["DXImageTransform.Microsoft.Matrix"]; + object.matrix = dojox.gfx.matrix.normalize({ + xx: m.M11, + xy: m.M12, + yx: m.M21, + yy: m.M22, + dx: m.Dx, + dy: m.Dy + }); + }; + + var attachText = function(object){ + // summary: builds a text shape from a node. + // object: dojox.gfx.Shape: an VML shape + var shape = object.shape = dojo.clone(dojox.gfx.defaultText), + r = object.rawNode, p = r.path.v.match(dojox.gfx.pathVmlRegExp); + do{ + if(!p || p.length != 7){ break; } + var c = r.childNodes, i = 0; + for(; i < c.length && c[i].tagName != "textpath"; ++i); + if(i >= c.length){ break; } + var s = c[i].style; + shape.text = c[i].string; + switch(s["v-text-align"]){ + case "left": + shape.x = parseInt(p[1]); + shape.align = "start"; + break; + case "center": + shape.x = (parseInt(p[1]) + parseInt(p[4])) / 2; + shape.align = "middle"; + break; + case "right": + shape.x = parseInt(p[4]); + shape.align = "end"; + break; + } + shape.y = parseInt(p[2]); + shape.decoration = s["text-decoration"]; + shape.rotated = s["v-rotate-letters"].toLowerCase() in dojox.gfx.vml._bool; + shape.kerning = s["v-text-kern"].toLowerCase() in dojox.gfx.vml._bool; + return; + }while(false); + object.shape = null; + }; + + var attachFont = function(object){ + // summary: deduces a font style from a node. + // object: dojox.gfx.Shape: an VML shape + var fontStyle = object.fontStyle = dojo.clone(dojox.gfx.defaultFont), + c = object.rawNode.childNodes, i = 0; + for(; i < c.length && c[i].tagName == "textpath"; ++i); + if(i >= c.length){ + object.fontStyle = null; + return; + } + var s = c[i].style; + fontStyle.style = s.fontstyle; + fontStyle.variant = s.fontvariant; + fontStyle.weight = s.fontweight; + fontStyle.size = s.fontsize; + fontStyle.family = s.fontfamily; + }; + + var attachTextTransform = function(object) { + // summary: deduces a transformation matrix from a node. + // object: dojox.gfx.Shape: an VML shape + attachTransform(object); + var matrix = object.matrix, fs = object.fontStyle; + // see comments in _getRealMatrix() + if(matrix && fs){ + object.matrix = dojox.gfx.matrix.multiply(matrix, {dy: dojox.gfx.normalizedLength(fs.size) * 0.35}); + } + }; + + var attachPath = function(object){ + // summary: builds a path shape from a Node. + // object: dojox.gfx.Shape: an VML shape + var shape = object.shape = dojo.clone(dojox.gfx.defaultPath), + p = rawNode.path.v.match(dojox.gfx.pathVmlRegExp), + t = [], skip = false, map = dojox.gfx.Path._pathVmlToSvgMap; + for(var i = 0; i < p.length; ++p){ + var s = p[i]; + if(s in map) { + skip = false; + t.push(map[s]); + } else if(!skip){ + var n = parseInt(s); + if(isNaN(n)){ + skip = true; + }else{ + t.push(n); + } + } + } + var l = t.length; + if(l >= 4 && t[l - 1] == "" && t[l - 2] == 0 && t[l - 3] == 0 && t[l - 4] == "l"){ + t.splice(l - 4, 4); + } + if(l){ + shape.path = t.join(" "); + } + }; +})(); |