| New file |
|---|
| 0,0 → 1,693 |
|---|
| if(!dojo._hasResource["dojox.gfx.silverlight"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojox.gfx.silverlight"] = true; |
| dojo.provide("dojox.gfx.silverlight"); |
| |
| dojo.require("dojox.gfx._base"); |
| dojo.require("dojox.gfx.shape"); |
| dojo.require("dojox.gfx.path"); |
| |
| dojo.experimental("dojox.gfx.silverlight"); |
| |
| dojox.gfx.silverlight.dasharray = { |
| solid: "none", |
| shortdash: [4, 1], |
| shortdot: [1, 1], |
| shortdashdot: [4, 1, 1, 1], |
| shortdashdotdot: [4, 1, 1, 1, 1, 1], |
| dot: [1, 3], |
| dash: [4, 3], |
| longdash: [8, 3], |
| dashdot: [4, 3, 1, 3], |
| longdashdot: [8, 3, 1, 3], |
| longdashdotdot: [8, 3, 1, 3, 1, 3] |
| }; |
| |
| dojox.gfx.silverlight.fontweight = { |
| normal: 400, |
| bold: 700 |
| }; |
| |
| dojox.gfx.silverlight.caps = {butt: "Flat", round: "Round", square: "Square"}; |
| dojox.gfx.silverlight.joins = {bevel: "Bevel", round: "Round"}; |
| |
| dojox.gfx.silverlight.fonts = { |
| serif: "Times New Roman", |
| times: "Times New Roman", |
| "sans-serif": "Arial", |
| helvetica: "Arial", |
| monotone: "Courier New", |
| courier: "Courier New" |
| }; |
| |
| dojox.gfx.silverlight.hexColor = function(/*String|Array|dojo.Color*/ color){ |
| // summary: converts a color object to a Silverlight hex color string (#aarrggbb) |
| var c = dojox.gfx.normalizeColor(color), |
| t = c.toHex(), a = Math.round(c.a * 255); |
| a = (a < 0 ? 0 : a > 255 ? 255 : a).toString(16); |
| return "#" + (a.length < 2 ? "0" + a : a) + t.slice(1); // String |
| }; |
| |
| dojo.extend(dojox.gfx.Shape, { |
| // summary: Silverlight-specific implementation of dojox.gfx.Shape methods |
| |
| setFill: function(fill){ |
| // summary: sets a fill object (Silverlight) |
| // fill: Object: a fill object |
| // (see dojox.gfx.defaultLinearGradient, |
| // dojox.gfx.defaultRadialGradient, |
| // dojox.gfx.defaultPattern, |
| // or dojo.Color) |
| |
| var p = this.rawNode.getHost().content, r = this.rawNode, f; |
| if(!fill){ |
| // don't fill |
| this.fillStyle = null; |
| this._setFillAttr(null); |
| return this; // self |
| } |
| if(typeof(fill) == "object" && "type" in fill){ |
| // gradient |
| switch(fill.type){ |
| case "linear": |
| this.fillStyle = f = dojox.gfx.makeParameters(dojox.gfx.defaultLinearGradient, fill); |
| var lgb = p.createFromXaml("<LinearGradientBrush/>"); |
| lgb.mappingMode = "Absolute"; |
| lgb.startPoint = f.x1 + "," + f.y1; |
| lgb.endPoint = f.x2 + "," + f.y2; |
| dojo.forEach(f.colors, function(c){ |
| var t = p.createFromXaml("<GradientStop/>"); |
| t.offset = c.offset; |
| t.color = dojox.gfx.silverlight.hexColor(c.color); |
| lgb.gradientStops.add(t); |
| }); |
| this._setFillAttr(lgb); |
| break; |
| case "radial": |
| this.fillStyle = f = dojox.gfx.makeParameters(dojox.gfx.defaultRadialGradient, fill); |
| var rgb = p.createFromXaml("<RadialGradientBrush/>"), w = r.width, h = r.height, |
| l = this.rawNode["Canvas.Left"], t = this.rawNode["Canvas.Top"]; |
| rgb.center = (f.cx - l) / w + "," + (f.cy - t) / h; |
| rgb.radiusX = f.r / w; |
| rgb.radiusY = f.r / h; |
| dojo.forEach(f.colors, function(c){ |
| var t = p.createFromXaml("<GradientStop/>"); |
| t.offset = c.offset; |
| t.color = dojox.gfx.silverlight.hexColor(c.color); |
| rgb.gradientStops.add(t); |
| }); |
| this._setFillAttr(rgb); |
| break; |
| case "pattern": |
| // don't fill: Silverlight doesn't define TileBrush for some reason |
| this.fillStyle = null; |
| this._setFillAttr(null); |
| break; |
| } |
| return this; // self |
| } |
| // color object |
| this.fillStyle = f = dojox.gfx.normalizeColor(fill); |
| var scb = p.createFromXaml("<SolidColorBrush/>"); |
| scb.color = f.toHex(); |
| scb.opacity = f.a; |
| this._setFillAttr(scb); |
| return this; // self |
| }, |
| _setFillAttr: function(f){ |
| this.rawNode.fill = f; |
| }, |
| |
| setStroke: function(stroke){ |
| // summary: sets a stroke object (Silverlight) |
| // stroke: Object: a stroke object |
| // (see dojox.gfx.defaultStroke) |
| |
| var p = this.rawNode.getHost().content, r = this.rawNode; |
| if(!stroke){ |
| // don't stroke |
| this.strokeStyle = null; |
| r.stroke = null; |
| return this; |
| } |
| // normalize the stroke |
| if(typeof stroke == "string"){ |
| stroke = {color: stroke}; |
| } |
| var s = this.strokeStyle = dojox.gfx.makeParameters(dojox.gfx.defaultStroke, stroke); |
| s.color = dojox.gfx.normalizeColor(s.color); |
| // generate attributes |
| if(s){ |
| var scb = p.createFromXaml("<SolidColorBrush/>"); |
| scb.color = s.color.toHex(); |
| scb.opacity = s.color.a; |
| r.stroke = scb; |
| r.strokeThickness = s.width; |
| r.strokeStartLineCap = r.strokeEndLineCap = r.strokeDashCap = |
| dojox.gfx.silverlight.caps[s.cap]; |
| if(typeof s.join == "number"){ |
| r.strokeLineJoin = "Miter"; |
| r.strokeMiterLimit = s.join; |
| }else{ |
| r.strokeLineJoin = dojox.gfx.silverlight.joins[s.join]; |
| } |
| var da = s.style.toLowerCase(); |
| if(da in dojox.gfx.silverlight.dasharray){ da = dojox.gfx.silverlight.dasharray[da]; } |
| if(da instanceof Array){ |
| da = dojo.clone(da); |
| /* |
| for(var i = 0; i < da.length; ++i){ |
| da[i] *= s.width; |
| } |
| */ |
| if(s.cap != "butt"){ |
| for(var i = 0; i < da.length; i += 2){ |
| //da[i] -= s.width; |
| --da[i] |
| if(da[i] < 1){ da[i] = 1; } |
| } |
| for(var i = 1; i < da.length; i += 2){ |
| //da[i] += s.width; |
| ++da[i]; |
| } |
| } |
| r.strokeDashArray = da.join(","); |
| }else{ |
| r.strokeDashArray = null; |
| } |
| } |
| return this; // self |
| }, |
| |
| _getParentSurface: function(){ |
| var surface = this.parent; |
| for(; surface && !(surface instanceof dojox.gfx.Surface); surface = surface.parent); |
| return surface; |
| }, |
| |
| _applyTransform: function() { |
| var tm = this.matrix, r = this.rawNode; |
| if(tm){ |
| var p = this.rawNode.getHost().content, |
| m = p.createFromXaml("<MatrixTransform/>"), |
| mm = p.createFromXaml("<Matrix/>"); |
| mm.m11 = tm.xx; |
| mm.m21 = tm.xy; |
| mm.m12 = tm.yx; |
| mm.m22 = tm.yy; |
| mm.offsetX = tm.dx; |
| mm.offsetY = tm.dy; |
| m.matrix = mm; |
| r.renderTransform = m; |
| }else{ |
| r.renderTransform = null; |
| } |
| 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) |
| rawNode.fill = null; |
| rawNode.stroke = null; |
| this.rawNode = rawNode; |
| }, |
| |
| // move family |
| |
| _moveToFront: function(){ |
| // summary: moves a shape to front of its parent's list of shapes (Silverlight) |
| var c = this.parent.rawNode.children, r = this.rawNode; |
| c.remove(r); |
| c.add(r); |
| return this; // self |
| }, |
| _moveToBack: function(){ |
| // summary: moves a shape to back of its parent's list of shapes (Silverlight) |
| var c = this.parent.rawNode.children, r = this.rawNode; |
| c.remove(r); |
| c.insert(0, r); |
| return this; // self |
| } |
| }); |
| |
| dojo.declare("dojox.gfx.Group", dojox.gfx.Shape, { |
| // summary: a group shape (Silverlight), which can be used |
| // to logically group shapes (e.g, to propagate matricies) |
| constructor: function(){ |
| dojox.gfx.silverlight.Container._init.call(this); |
| }, |
| setRawNode: function(rawNode){ |
| // summary: sets a raw Silverlight node to be used by this shape |
| // rawNode: Node: an Silverlight node |
| this.rawNode = rawNode; |
| } |
| }); |
| dojox.gfx.Group.nodeType = "Canvas"; |
| |
| dojo.declare("dojox.gfx.Rect", dojox.gfx.shape.Rect, { |
| // summary: a rectangle shape (Silverlight) |
| setShape: function(newShape){ |
| // summary: sets a rectangle shape object (Silverlight) |
| // newShape: Object: a rectangle shape object |
| this.shape = dojox.gfx.makeParameters(this.shape, newShape); |
| this.bbox = null; |
| var r = this.rawNode, n = this.shape; |
| r["Canvas.Left"] = n.x; |
| r["Canvas.Top"] = n.y; |
| r.width = n.width; |
| r.height = n.height; |
| r.radiusX = r.radiusY = n.r; |
| return this; // self |
| } |
| }); |
| dojox.gfx.Rect.nodeType = "Rectangle"; |
| |
| dojo.declare("dojox.gfx.Ellipse", dojox.gfx.shape.Ellipse, { |
| // summary: an ellipse shape (Silverlight) |
| setShape: function(newShape){ |
| // summary: sets an ellipse shape object (Silverlight) |
| // newShape: Object: an ellipse shape object |
| this.shape = dojox.gfx.makeParameters(this.shape, newShape); |
| this.bbox = null; |
| var r = this.rawNode, n = this.shape; |
| r["Canvas.Left"] = n.cx - n.rx; |
| r["Canvas.Top"] = n.cy - n.ry; |
| r.width = 2 * n.rx; |
| r.height = 2 * n.ry; |
| return this; // self |
| } |
| }); |
| dojox.gfx.Ellipse.nodeType = "Ellipse"; |
| |
| dojo.declare("dojox.gfx.Circle", dojox.gfx.shape.Circle, { |
| // summary: a circle shape (Silverlight) |
| setShape: function(newShape){ |
| // summary: sets a circle shape object (Silverlight) |
| // newShape: Object: a circle shape object |
| this.shape = dojox.gfx.makeParameters(this.shape, newShape); |
| this.bbox = null; |
| var r = this.rawNode, n = this.shape; |
| r["Canvas.Left"] = n.cx - n.r; |
| r["Canvas.Top"] = n.cy - n.r; |
| r.width = r.height = 2 * n.r; |
| return this; // self |
| } |
| }); |
| dojox.gfx.Circle.nodeType = "Ellipse"; |
| |
| dojo.declare("dojox.gfx.Line", dojox.gfx.shape.Line, { |
| // summary: a line shape (Silverlight) |
| setShape: function(newShape){ |
| // summary: sets a line shape object (Silverlight) |
| // newShape: Object: a line shape object |
| this.shape = dojox.gfx.makeParameters(this.shape, newShape); |
| this.bbox = null; |
| var r = this.rawNode, n = this.shape; |
| r.x1 = n.x1; r.y1 = n.y1; r.x2 = n.x2; r.y2 = n.y2; |
| return this; // self |
| } |
| }); |
| dojox.gfx.Line.nodeType = "Line"; |
| |
| dojo.declare("dojox.gfx.Polyline", dojox.gfx.shape.Polyline, { |
| // summary: a polyline/polygon shape (Silverlight) |
| setShape: function(points, closed){ |
| // summary: sets a polyline/polygon shape object (Silverlight) |
| // points: Object: a polyline/polygon shape object |
| if(points && points instanceof Array){ |
| // branch |
| // points: Array: an array of points |
| this.shape = dojox.gfx.makeParameters(this.shape, {points: points}); |
| if(closed && this.shape.points.length){ |
| this.shape.points.push(this.shape.points[0]); |
| } |
| }else{ |
| this.shape = dojox.gfx.makeParameters(this.shape, points); |
| } |
| this.box = null; |
| var p = this.shape.points, rp = []; |
| for(var i = 0; i < p.length; ++i){ |
| if(typeof p[i] == "number"){ |
| rp.push(p[i], p[++i]); |
| }else{ |
| rp.push(p[i].x, p[i].y); |
| } |
| } |
| this.rawNode.points = rp.join(","); |
| return this; // self |
| } |
| }); |
| dojox.gfx.Polyline.nodeType = "Polyline"; |
| |
| dojo.declare("dojox.gfx.Image", dojox.gfx.shape.Image, { |
| // summary: an image (Silverlight) |
| setShape: function(newShape){ |
| // summary: sets an image shape object (Silverlight) |
| // newShape: Object: an image shape object |
| this.shape = dojox.gfx.makeParameters(this.shape, newShape); |
| this.bbox = null; |
| var r = this.rawNode, n = this.shape; |
| r["Canvas.Left"] = n.x; |
| r["Canvas.Top"] = n.y; |
| r.width = n.width; |
| r.height = n.height; |
| r.source = n.src; |
| return this; // self |
| }, |
| 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) |
| this.rawNode = rawNode; |
| } |
| }); |
| dojox.gfx.Image.nodeType = "Image"; |
| |
| dojo.declare("dojox.gfx.Text", dojox.gfx.shape.Text, { |
| // summary: an anchored text (Silverlight) |
| setShape: function(newShape){ |
| // summary: sets a text shape object (Silverlight) |
| // newShape: Object: a text shape object |
| this.shape = dojox.gfx.makeParameters(this.shape, newShape); |
| this.bbox = null; |
| var r = this.rawNode, s = this.shape; |
| r.text = s.text; |
| r.textDecorations = s.decoration == "underline" ? "Underline" : "None"; |
| r["Canvas.Left"] = -10000; |
| r["Canvas.Top"] = -10000; |
| window.setTimeout(dojo.hitch(this, "_delayAlignment"), 0); |
| return this; // self |
| }, |
| _delayAlignment: function(){ |
| // handle alignment |
| var r = this.rawNode, s = this.shape, |
| w = r.actualWidth, h = r.actualHeight, x = s.x, y = s.y - h * 0.75; |
| switch(s.align){ |
| case "middle": |
| x -= w / 2; |
| break; |
| case "end": |
| x -= w; |
| break; |
| } |
| var a = this.matrix ? dojox.gfx.matrix.multiplyPoint(this.matrix, x, y) : {x: x, y: y}; |
| r["Canvas.Left"] = a.x; |
| r["Canvas.Top"] = a.y; |
| }, |
| setStroke: function(){ |
| // summary: ignore setting a stroke style |
| return this; // self |
| }, |
| _setFillAttr: function(f){ |
| this.rawNode.foreground = f; |
| }, |
| 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) |
| this.rawNode = rawNode; |
| }, |
| _applyTransform: function() { |
| var tm = this.matrix, r = this.rawNode; |
| if(tm){ |
| // the next line is pure magic :-( |
| tm = dojox.gfx.matrix.normalize([1/100, tm, 100]); |
| var p = this.rawNode.getHost().content, |
| m = p.createFromXaml("<MatrixTransform/>"), |
| mm = p.createFromXaml("<Matrix/>"); |
| mm.m11 = tm.xx; |
| mm.m21 = tm.xy; |
| mm.m12 = tm.yx; |
| mm.m22 = tm.yy; |
| mm.offsetX = tm.dx; |
| mm.offsetY = tm.dy; |
| m.matrix = mm; |
| r.renderTransform = m; |
| }else{ |
| r.renderTransform = null; |
| } |
| return this; |
| }, |
| getTextWidth: function(){ |
| // summary: get the text width in pixels |
| return this.rawNode.actualWidth; |
| } |
| }); |
| dojox.gfx.Text.nodeType = "TextBlock"; |
| |
| dojo.declare("dojox.gfx.Path", dojox.gfx.path.Path, { |
| // summary: a path shape (Silverlight) |
| _updateWithSegment: function(segment){ |
| // summary: updates the bounding box of path with new segment |
| // segment: Object: a segment |
| dojox.gfx.Path.superclass._updateWithSegment.apply(this, arguments); |
| var p = this.shape.path; |
| if(typeof(p) == "string"){ |
| this.rawNode.data = p ? p : null; |
| } |
| }, |
| setShape: function(newShape){ |
| // summary: forms a path using a shape (Silverlight) |
| // newShape: Object: an SVG path string or a path object (see dojox.gfx.defaultPath) |
| dojox.gfx.Path.superclass.setShape.apply(this, arguments); |
| var p = this.shape.path; |
| this.rawNode.data = p ? p : null; |
| return this; // self |
| } |
| }); |
| dojox.gfx.Path.nodeType = "Path"; |
| |
| dojo.declare("dojox.gfx.TextPath", dojox.gfx.path.TextPath, { |
| // summary: a textpath shape (Silverlight) |
| _updateWithSegment: function(segment){ |
| // summary: updates the bounding box of path with new segment |
| // segment: Object: a segment |
| }, |
| setShape: function(newShape){ |
| // summary: forms a path using a shape (Silverlight) |
| // newShape: Object: an SVG path string or a path object (see dojox.gfx.defaultPath) |
| }, |
| _setText: function(){ |
| } |
| }); |
| dojox.gfx.TextPath.nodeType = "text"; |
| |
| dojo.declare("dojox.gfx.Surface", dojox.gfx.shape.Surface, { |
| // summary: a surface object to be used for drawings (Silverlight) |
| constructor: function(){ |
| dojox.gfx.silverlight.Container._init.call(this); |
| }, |
| setDimensions: function(width, height){ |
| // summary: sets the width and height of the rawNode |
| // width: String: width of surface, e.g., "100px" |
| // height: String: height of surface, e.g., "100px" |
| this.width = dojox.gfx.normalizedLength(width); // in pixels |
| this.height = dojox.gfx.normalizedLength(height); // in pixels |
| var p = this.rawNode && this.rawNode.getHost(); |
| if(p){ |
| p.width = width; |
| p.height = height; |
| } |
| return this; // self |
| }, |
| getDimensions: function(){ |
| // summary: returns an object with properties "width" and "height" |
| var p = this.rawNode && this.rawNode.getHost(); |
| var t = p ? {width: p.content.actualWidth, height: p.content.actualHeight} : null; |
| if(t.width <= 0){ t.width = this.width; } |
| if(t.height <= 0){ t.height = this.height; } |
| return t; // Object |
| } |
| }); |
| |
| dojox.gfx.silverlight.surfaces = {}; |
| |
| dojox.gfx.createSurface = function(parentNode, width, height){ |
| // summary: creates a surface (Silverlight) |
| // parentNode: Node: a parent node |
| // width: String: width of surface, e.g., "100px" |
| // height: String: height of surface, e.g., "100px" |
| |
| var s = new dojox.gfx.Surface(); |
| parentNode = dojo.byId(parentNode); |
| // create an empty canvas |
| var t = parentNode.ownerDocument.createElement("script"); |
| t.type = "text/xaml"; |
| t.id = dojox.gfx._base._getUniqueId(); |
| t.text = "<Canvas xmlns='http://schemas.microsoft.com/client/2007' Name='" + dojox.gfx._base._getUniqueId() + "'/>"; |
| document.body.appendChild(t); |
| // create a plugin |
| var pluginName = dojox.gfx._base._getUniqueId(); |
| Silverlight.createObject( |
| "#" + t.id, // none |
| parentNode, |
| pluginName, |
| { // Plugin properties. |
| width: String(width), // Width of rectangular region of plugin in pixels. |
| height: String(height), // Height of rectangular region of plugin in pixels. |
| inplaceInstallPrompt: "false", // Determines whether to display in-place install prompt if invalid version detected. |
| //background: "white", // Background color of plugin. |
| //isWindowless: "false", // Determines whether to display plugin in Windowless mode. |
| background: "transparent", // Background color of plugin. |
| isWindowless: "true", // Determines whether to display plugin in Windowless mode. |
| framerate: "24", // MaxFrameRate property value. |
| version: "1.0" // Silverlight version. |
| }, |
| {}, |
| null, |
| null |
| ); |
| s.rawNode = dojo.byId(pluginName).content.root; |
| // register the plugin with its parent node |
| dojox.gfx.silverlight.surfaces[s.rawNode.name] = parentNode; |
| s.width = dojox.gfx.normalizedLength(width); // in pixels |
| s.height = dojox.gfx.normalizedLength(height); // in pixels |
| return s; // dojox.gfx.Surface |
| }; |
| |
| // Extenders |
| |
| dojox.gfx.silverlight.Font = { |
| _setFont: function(){ |
| // summary: sets a font object (Silverlight) |
| var f = this.fontStyle, r = this.rawNode, |
| fw = dojox.gfx.silverlight.fontweight, |
| fo = dojox.gfx.silverlight.fonts, t = f.family.toLowerCase(); |
| r.fontStyle = f.style == "italic" ? "Italic" : "Normal"; |
| r.fontWeight = f.weight in fw ? fw[f.weight] : f.weight; |
| r.fontSize = dojox.gfx.normalizedLength(f.size); |
| r.fontFamily = t in fo ? fo[t] : f.family; |
| } |
| }; |
| |
| dojox.gfx.silverlight.Container = { |
| _init: function(){ |
| dojox.gfx.shape.Container._init.call(this); |
| }, |
| add: function(shape){ |
| // summary: adds a shape to a group/surface |
| // shape: dojox.gfx.Shape: an VML shape object |
| if(this != shape.getParent()){ |
| //dojox.gfx.Group.superclass.add.apply(this, arguments); |
| //this.inherited(arguments); |
| dojox.gfx.shape.Container.add.apply(this, arguments); |
| this.rawNode.children.add(shape.rawNode); |
| } |
| return this; // self |
| }, |
| remove: function(shape, silently){ |
| // summary: remove a shape from a group/surface |
| // shape: dojox.gfx.Shape: an VML shape object |
| // silently: Boolean?: if true, regenerate a picture |
| if(this == shape.getParent()){ |
| var parent = shape.rawNode.getParent(); |
| if(parent){ |
| parent.children.remove(shape.rawNode); |
| } |
| //dojox.gfx.Group.superclass.remove.apply(this, arguments); |
| //this.inherited(arguments); |
| dojox.gfx.shape.Container.remove.apply(this, arguments); |
| } |
| return this; // self |
| }, |
| clear: function(){ |
| // summary: removes all shapes from a group/surface |
| this.rawNode.children.clear(); |
| //return this.inherited(arguments); // self |
| return dojox.gfx.shape.Container.clear.apply(this, arguments); |
| }, |
| _moveChildToFront: dojox.gfx.shape.Container._moveChildToFront, |
| _moveChildToBack: dojox.gfx.shape.Container._moveChildToBack |
| }; |
| |
| dojo.mixin(dojox.gfx.shape.Creator, { |
| createObject: function(shapeType, rawShape){ |
| // summary: creates an instance of the passed shapeType class |
| // shapeType: Function: a class constructor to create an instance of |
| // rawShape: Object: properties to be passed in to the classes "setShape" method |
| if(!this.rawNode){ return null; } |
| var shape = new shapeType(); |
| var node = this.rawNode.getHost().content.createFromXaml("<" + shapeType.nodeType + "/>"); |
| shape.setRawNode(node); |
| shape.setShape(rawShape); |
| this.add(shape); |
| return shape; // dojox.gfx.Shape |
| } |
| }); |
| |
| dojo.extend(dojox.gfx.Text, dojox.gfx.silverlight.Font); |
| //dojo.extend(dojox.gfx.TextPath, dojox.gfx.silverlight.Font); |
| |
| dojo.extend(dojox.gfx.Group, dojox.gfx.silverlight.Container); |
| dojo.extend(dojox.gfx.Group, dojox.gfx.shape.Creator); |
| |
| dojo.extend(dojox.gfx.Surface, dojox.gfx.silverlight.Container); |
| dojo.extend(dojox.gfx.Surface, dojox.gfx.shape.Creator); |
| |
| (function(){ |
| var surfaces = dojox.gfx.silverlight.surfaces; |
| var mouseFix = function(s, a){ |
| var ev = {target: s, currentTarget: s, |
| preventDefault: function(){}, stopPropagation: function(){}}; |
| if(a){ |
| ev.ctrlKey = a.ctrl; |
| ev.shiftKey = a.shift; |
| var p = a.getPosition(null); |
| ev.x = ev.offsetX = ev.layerX = p.x; |
| ev.y = ev.offsetY = ev.layerY = p.y; |
| // calculate clientX and clientY |
| var parent = surfaces[s.getHost().content.root.name]; |
| var t = dojo._abs(parent); |
| ev.clientX = t.x + p.x; |
| ev.clientY = t.y + p.y; |
| } |
| return ev; |
| }; |
| var keyFix = function(s, a){ |
| var ev = { |
| keyCode: a.platformKeyCode, |
| ctrlKey: a.ctrl, |
| shiftKey: a.shift |
| }; |
| return ev; |
| }; |
| var eventNames = { |
| onclick: {name: "MouseLeftButtonUp", fix: mouseFix}, |
| onmouseenter: {name: "MouseEnter", fix: mouseFix}, |
| onmouseleave: {name: "MouseLeave", fix: mouseFix}, |
| onmousedown: {name: "MouseLeftButtonDown", fix: mouseFix}, |
| onmouseup: {name: "MouseLeftButtonUp", fix: mouseFix}, |
| onmousemove: {name: "MouseMove", fix: mouseFix}, |
| onkeydown: {name: "KeyDown", fix: keyFix}, |
| onkeyup: {name: "KeyUp", fix: keyFix} |
| }; |
| var eventsProcessing = { |
| connect: function(name, object, method){ |
| var token, n = name in eventNames ? eventNames[name] : |
| {name: name, fix: function(){ return {}; }}; |
| if(arguments.length > 2){ |
| token = this.getEventSource().addEventListener(n.name, |
| function(s, a){ dojo.hitch(object, method)(n.fix(s, a)); }); |
| }else{ |
| token = this.getEventSource().addEventListener(n.name, |
| function(s, a){ object(n.fix(s, a)); }); |
| } |
| return {name: n.name, token: token}; |
| }, |
| disconnect: function(token){ |
| this.getEventSource().removeEventListener(token.name, token.token); |
| } |
| }; |
| dojo.extend(dojox.gfx.Shape, eventsProcessing); |
| dojo.extend(dojox.gfx.Surface, eventsProcessing); |
| dojox.gfx.equalSources = function(a, b){ |
| return a && b && a.equals(b); |
| } |
| |
| })(); |
| |
| } |