Subversion Repositories Applications.papyrus

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);
        }

})();

}