diff options
Diffstat (limited to 'js/dojo/dojox/drawing/tools/custom')
| -rw-r--r-- | js/dojo/dojox/drawing/tools/custom/Axes.js | 577 | ||||
| -rw-r--r-- | js/dojo/dojox/drawing/tools/custom/Equation.js | 30 | ||||
| -rw-r--r-- | js/dojo/dojox/drawing/tools/custom/Vector.js | 392 |
3 files changed, 999 insertions, 0 deletions
diff --git a/js/dojo/dojox/drawing/tools/custom/Axes.js b/js/dojo/dojox/drawing/tools/custom/Axes.js new file mode 100644 index 0000000..a30bc11 --- /dev/null +++ b/js/dojo/dojox/drawing/tools/custom/Axes.js @@ -0,0 +1,577 @@ +//>>built +// wrapped by build app +define("dojox/drawing/tools/custom/Axes", ["dijit","dojo","dojox","dojo/require!dojox/drawing/stencil/Path"], function(dijit,dojo,dojox){ +dojo.provide("dojox.drawing.tools.custom.Axes"); +dojo.require("dojox.drawing.stencil.Path"); + + +dojox.drawing.tools.custom.Axes = dojox.drawing.util.oo.declare( + // summary: + // Draws a right-angle Axes (shaped like an L, not a +) + // description: + // This Stencil is created with a Path so that the L shape + // is one continuous piece. Arrow heads are placed at the end + // of each axis. The Axes can be rotated. There are custom + // label methods. + // + dojox.drawing.stencil.Path, + function(options){ + this.closePath = false; + + this.xArrow = new dojox.drawing.annotations.Arrow({stencil:this, idx1:0, idx2:1}); + this.yArrow = new dojox.drawing.annotations.Arrow({stencil:this, idx1:2, idx2:1}); + if(options.data){ + //Allows import of z-axis in non-enabled canvas and xy-axis in + //enabled canvas + this.style.zAxisEnabled = options.data.cosphi == 1 ? true : false; + this.setData(options.data); + } + if(this.style.zAxisEnabled){ + // If the z-axis is enabled, all axes will be created with a z-axis on the canvas. + // there is no switching back and forth for the axis, only for vectors. + this.data.cosphi = 1; + var ops = {}; + dojo.mixin(ops,options); + dojo.mixin(ops,{ + container:this.container.createGroup(), + style: this.style, + showAngle: false, + label: null + }); + if(options.data && (!ops.data.radius || !ops.data.angle)){ + ops.data.x2 = ops.data.x4; + ops.data.y2 = ops.data.y4; + } + ops.style.zAxis = true; + this.zAxis = new dojox.drawing.tools.custom.Vector(ops); + this.zAxis.minimumSize = 5; + //console.log("-----constructing axes: ",this.zAxis); + this.connectMult([ + [this, "onChangeStyle", this.zAxis, "onChangeStyle"], + [this, "select", this.zAxis, "select"], + [this, "deselect", this.zAxis, "deselect"], + [this, "onDelete", this.zAxis, "destroy"], + [this, "onDrag", this, "zSet"], + [this, "onTransform", this, "zSet"], + [this.zAxis, "onBeforeRender", this, "zSet"], + [this, "_onPostRender", this.zAxis, "render"] + ]); + + } + + if(this.points && this.points.length){ + this.setPoints = this._postSetPoints; + // render isn't called yet because baseRender is false + // instead it is called here + this.render(); + options.label && this.setLabel(options.label); + options.shadow && this.addShadow(options.shadow); + } + }, + { + draws:true, + type:"dojox.drawing.tools.custom.Axes", + minimumSize:30, + showAngle:true, + closePath:false, + baseRender:false, + zScale:.5, + + zPoint: function(obj){ + // summary: + // Finds the point for the z axis. + obj.radius = this.util.length(obj); + var pt = this.util.pointOnCircle(obj.start.x, obj.start.y, obj.radius*this.zScale, this.style.zAngle); + return {x:pt.x, y:pt.y, skip:true, noAnchor:true}; + }, + + zSet: function(){ + if(!this.zAxis){ return; }; + var c = this.points[1]; + var z = this.points[3]; + var p = [ + {x:c.x, y:c.y}, + {x:z.x, y:z.y} + ]; + var len = this.util.length({start:{x:c.x, y:c.y}, x:z.x, y:z.y}); + len > this.zAxis.minimumSize ? this.zAxis.setPoints(p) : false; + this.zAxis.cosphi = 1; + }, + + createLabels: function(){ + // summary: + // Creates the label for each axis. + // + // NOTE: Not passing style into text because it's changing it + var props = {align:"middle", valign:"middle", util:this.util, annotation:true, container:this.container, mouse:this.mouse, stencil:this}; + this.labelX = new dojox.drawing.annotations.Label(dojo.mixin(props,{ + labelPosition:this.setLabelX + })); + this.labelY = new dojox.drawing.annotations.Label(dojo.mixin(props,{ + labelPosition:this.setLabelY + })); + if(this.style.zAxisEnabled){ + this.labelZ = new dojox.drawing.annotations.Label(dojo.mixin(props,{ + labelPosition:this.setLabelZ + })); + } + + }, + + setLabelX: function(){ + // summary: + // Custom placement for x-axis label + // + var ax = this.points[0]; + var c = this.points[1]; + + var dist = 40; + var offdist = 20; + var pt, px, py, pt2; + + pt = this.util.lineSub(c.x, c.y, ax.x, ax.y, dist); + px = pt.x + (pt.y -ax.y); + py = pt.y + (ax.x - pt.x); + pt2 = this.util.lineSub(pt.x, pt.y, px, py, (dist-offdist)); + + return { + x: pt2.x, + y: pt2.y, + width:20 + }; + }, + setLabelY: function(){ + // summary: + // Custom placement for y-axis label + // + var c = this.points[1]; + var ay = this.points[2]; + + var dist = 40; + var offdist = 20; + var pt, px, py, pt2; + pt = this.util.lineSub(c.x, c.y, ay.x, ay.y, dist); + px = pt.x + (ay.y - pt.y); + py = pt.y + (pt.x - ay.x); + pt2 = this.util.lineSub(pt.x, pt.y, px, py, (dist-offdist)); + return { + x: pt2.x, + y: pt2.y, + width:20 + }; + }, + setLabelZ: function(){ + // summary: + // Custom placement for z-axis label + // + var c = this.points[1]; + var z = this.points[3]; + + var dist = 40; + var offdist = 20; + var pt, px, py, pt2; + pt = this.util.lineSub(c.x, c.y, z.x, z.y, dist); + px = pt.x + (pt.y - z.y); + py = pt.y + (z.x - pt.x); + pt2 = this.util.lineSub(pt.x, pt.y, px, py, (dist-offdist)); + + return { + x:pt2.x, + y:pt2.y, + width:20 + } + }, + setLabel: function(/* ? String*/value){ + // summary: + // Set the text of the labels. The text would be + // broken up into the two labels. + // arguments: + // value: [optional] String + // If no argument is passed, defaults to two labels + // 'x' and 'y'. If an argument is passed, that + // text will be split on the word 'and' to determine + // the two labels. + // + if(this._labelsCreated){ return; } + !this.labelX && this.createLabels(); + var x = "x"; + var y = "y"; + var z = "z"; + if(value){ + // match first "and" or "&" and trim whitespace. + // Non-greedy matches are not supported in older + // browsers such as Netscape Navigator 4 or + // Microsoft Internet Explorer 5.0. + if(this.labelZ){ + var lbls = value.match(/(.*?)(and|&)(.*?)(and|&)(.*)/i); + if(lbls.length>4){ + x = lbls[1].replace(/^\s+/,"").replace(/\s+$/,""); + y = lbls[3].replace(/^\s+/,"").replace(/\s+$/,""); + z = lbls[5].replace(/^\s+/,"").replace(/\s+$/,""); + } + }else{ + var lbls = value.match(/(.*?)(and|&)(.*)/i); + if(lbls.length>2){ + x = lbls[1].replace(/^\s+/,"").replace(/\s+$/,""); + y = lbls[3].replace(/^\s+/,"").replace(/\s+$/,""); + } + } + } + this.labelX.setLabel(x); + this.labelY.setLabel(y); + if(this.labelZ){ + this.labelZ.setLabel(z); + } + this._labelsCreated = true; + }, + getLabel: function(){ + // summary: + // Getter for the labels. returns an object. + // + if(!this.labelX){ return null; } + return { + x:this.labelX.getText(), + y:this.labelY.getText(), + z:this.labelZ?this.labelZ.getText():null + }; // Object + }, + + anchorPositionCheck: function(/*Number*/x, /*Number*/y, /*manager.Anchor*/anchor){ + // summary: + // Gets called from anchor to check if its current + // position is ok. If not, its x or y transform will + // be changed until this passes. + // + var pm = this.container.getParent().getTransform(); + var am = anchor.shape.getTransform(); + + // the xaxis point has changed and is not yet set as a point + // - but the center should be good (except for the transform). + // Now check the yaxis point. + + var p = this.points; + var o = {x:am.dx+anchor.org.x+pm.dx, y:am.dy+anchor.org.y+pm.dy}; + var c = {x:p[1].x+pm.dx, y:p[1].y+pm.dy}; + var ox = c.x - (c.y - o.y); + var oy = c.y - (o.x - c.x); + + return {x:ox, y:oy}; + + }, + + onTransformBegin: function(/*manager.Anchor*/anchor){ + // summary: + // Overwrites _Base.onTransformBegin + // + // called from anchor point up mouse down + this._isBeingModified = true; + }, + + onTransformEnd: function(/*manager.Anchor*/anchor){ + // summary: + // Overwrites _Base.onTransformEnd + // + // Gets called on anchor mouseup + // also gets called by checkBounds - we don't want that. + if(!anchor){ return; } + + // tell anchor to go to prev point if wrong + // called from anchor point up mouse up + + this._isBeingModified = false; + //this.deselect(); + this._toggleSelected(); + console.log("before:", Math.ceil(this.points[1].x), " x ", Math.ceil(this.points[1].y)) + + var o = this.points[0]; + var c = this.points[1]; + var obj = {start:{x:c.x,y:c.y},x:o.x, y:o.y}; + var pt = this.util.constrainAngle(obj, 0, 89); + var zpt = this.style.zAxisEnabled ? this.zPoint(obj) : null; + + if(pt.x==o.x && pt.y == o.y){ + // we're within the constraint, so now we snap + pt = this.util.snapAngle(obj, this.angleSnap/180); + + obj.x = pt.x; + obj.y = pt.y; + var ox = obj.start.x - (obj.start.y - obj.y); + var oy = obj.start.y - (obj.x - obj.start.x); + + if(ox<0 || oy<0){ + console.warn("AXES ERROR LESS THAN ZERO - ABORT"); + return; + } + this.points = [{x:obj.x, y:obj.y}, {x:obj.start.x, y:obj.start.y, noAnchor:true}]; + this.points.push({x:ox, y:oy, noAnchor:true}); + if(zpt){ this.points.push(zpt);} + this.setPoints(this.points); + + //this.select(); + this.onModify(this); + return; + } + + // we're outside of the constraint. Set to the low or high. + this.points[0].x = pt.x + this.points[0].y = pt.y; + o = this.points[0]; + + var ox = c.x - (c.y - o.y); + var oy = c.y - (o.x - c.x); + + this.points[2] = {x:ox, y:oy, noAnchor:true}; + if(zpt){ this.points.push(zpt); } + this.setPoints(this.points); + + // reset handles render + //anchor.reset(this); + + this.labelX.setLabel(); + this.labelY.setLabel(); + if(this.labelZ){ + this.labelZ.setLabel(); + } + + //this.select(); + this.onModify(this); + + }, + + getBounds: function(/*Boolean*/absolute){ + // summary: + // Custom getBounds overwrites _Base.getBounds + // + var px = this.points[0], + pc = this.points[1], + py = this.points[2]; + if(this.style.zAxisEnabled){ var pz = this.points[3]; } + + if(absolute){ + var bounds = { + x:pc.x, + y:pc.y, + x1:pc.x, + y1:pc.y, + x2:px.x, + y2:px.y, + x3:py.x, + y3:py.y + }; + if(this.style.zAxisEnabled){ + bounds.x4 = pz.x; + bounds.y4 = pz.y; + } + return bounds; + } + + var x1 = this.style.zAxisEnabled ? (py.x < pz.x ? py.x : pz.x) : py.x; + y1 = py.y < px.y ? py.y : px.y, + x2 = px.x, + y2 = this.style.zAxisEnabled ? pz.y : pc.y; + + return { + x1:x1, + y1:y1, + x2:x2, + y2:y2, + x:x1, + y:y1, + w:x2-x1, + h:y2-y1 + }; + }, + + _postSetPoints: function(/*Array*/pts){ + // summary: + // Because Axes only has one anchor, + // we substitute a special setPoints method + // + this.points[0] = pts[0]; + if(this.pointsToData){ + this.data = this.pointsToData(); + } + }, + + onTransform: function(/*Number*/anchor){ + // summary: + // Overwrites _Base.onTransform + // + // the xaxis point has changed - the center will not. + // need to find the yaxis point. + var o = this.points[0]; + var c = this.points[1]; + var ox = c.x - (c.y - o.y); + var oy = c.y - (o.x - c.x); + + // 'noAnchor' on a point indicates an anchor should + // not be rendered. This is the Y point being set. + this.points[2] = {x:ox, y:oy, noAnchor:true}; + if(this.style.zAxisEnabled){ + this.points[3] = this.zPoint({start:{x:c.x, y:c.y}, x:o.x, y:o.y}); + } + this.setPoints(this.points); + if(!this._isBeingModified){ + this.onTransformBegin(); + } + this.render(); + }, + + pointsToData: function(){ + //summary: + // Converts points to data. + var p = this.points; + var d = { + x1:p[1].x, + y1:p[1].y, + x2:p[0].x, + y2:p[0].y, + x3:p[2].x, + y3:p[2].y + } + if(this.style.zAxisEnabled){ + d.x4 = p[3].x; + d.y4 = p[3].y; + d.cosphi = 1; + } + return d; + + }, + + getRadius: function(){ + //summary: + // Possibility of z-axis makes bounds unreliable. + // Use these points instead. + var p = this.points; + var line = {start:{x:p[1].x, y:p[1].y}, x:p[0].x, y:p[0].y}; + return this.util.length(line); + }, + + dataToPoints: function(/* ? Object*/o){ + //summary: + // Converts data to points. + o = o || this.data; + if(o.radius || o.angle){ + // instead of using x1,x2,y1,y1, + // it's been set as x,y,angle,radius + var pt = this.util.pointOnCircle(o.x,o.y,o.radius,o.angle), zpt; + var ox = o.x - (o.y - pt.y); + var oy = o.y - (pt.x - o.x); + if((o.cosphi && o.cosphi==1) || this.style.zAxisEnabled){ + this.style.zAxisEnabled = true; + zpt = this.util.pointOnCircle(o.x, o.y, o.radius*this.zScale, this.style.zAngle); + } + this.data = o = { + x1:o.x, + y1:o.y, + x2:pt.x, + y2:pt.y, + x3:ox, + y3:oy + } + if(this.style.zAxisEnabled){ + this.data.x4 = o.x4 = zpt.x; + this.data.y4 = o.y4 = zpt.y; + this.data.cosphi = 1; + } + + } + this.points = [ + {x:o.x2, y:o.y2}, + {x:o.x1, y:o.y1, noAnchor:true}, + {x:o.x3, y:o.y3, noAnchor:true} + ]; + if(this.style.zAxisEnabled){ this.points.push({x:o.x4, y:o.y4, skip:true, noAnchor:true}); } + return this.points; + }, + + onDrag: function(/*EventObject*/obj){ + // summary: See stencil._Base.onDrag + // + var pt = this.util.constrainAngle(obj, 0, 89); + obj.x = pt.x; + obj.y = pt.y; + var ox = obj.start.x - (obj.start.y - obj.y); + var oy = obj.start.y - (obj.x - obj.start.x); + + if(ox<0 || oy<0){ + return; + } + this.points = [{x:obj.x, y:obj.y}, {x:obj.start.x, y:obj.start.y, noAnchor:true}]; + + this.points.push({x:ox, y:oy, noAnchor:true}); + if(this.style.zAxisEnabled){ + var zpt = this.zPoint(obj); + this.points.push(zpt); + } + this.render(); + }, + + onUp: function(/*EventObject*/obj){ + // summary: See stencil._Base.onUp + // + if(!this._downOnCanvas){ return; } + this._downOnCanvas = false; + var p = this.points; + if(!p.length){ + var s = obj.start, d = 100; + this.points = [ + {x:s.x+d, y:s.y+d}, + {x:s.x, y:s.y+d, noAnchor:true}, + {x:s.x, y:s.y, noAnchor:true} + ]; + if(this.style.zAxisEnabled){ + var zpt = this.zPoint({start:{x:s.x, y:s.y+d}, x:s.x+d, y:s.y+d}); + this.points.push(zpt); + } + this.setPoints = this._postSetPoints; + this.pointsToData(); + this.render(); + this.onRender(this); + return; + } + + var len = this.util.distance(p[1].x ,p[1].y ,p[0].x ,p[0].y ); + if(!p || !p.length){ + return; + }else if(len < this.minimumSize){ + this.remove(this.shape, this.hit); + this.xArrow.remove(this.xArrow.shape, this.xArrow.hit); + this.yArrow.remove(this.yArrow.shape, this.yArrow.hit); + if(this.zArrow){ + this.zArrow.remove(this.zArrow.shape, this.zArrow.hit); + } + return; + } + + var o = p[0]; + var c = p[1]; + obj = {start:{x:c.x,y:c.y},x:o.x,y:o.y}; + var pt = this.util.snapAngle(obj, this.angleSnap/180); + obj.x = pt.x; + obj.y = pt.y; + var ox = obj.start.x - (obj.start.y - obj.y); + var oy = obj.start.y - (obj.x - obj.start.x); + + if(ox<0 || oy<0){ + return; + } + this.points = [{x:obj.x, y:obj.y}, {x:obj.start.x, y:obj.start.y, noAnchor:true}]; + + this.points.push({x:ox, y:oy, noAnchor:true}); + if(this.style.zAxisEnabled){ this.points.push(this.zPoint(obj)); } + this.onRender(this); + this.setPoints = this._postSetPoints; + } + } +); + +dojox.drawing.tools.custom.Axes.setup = { + // summary: See stencil._Base ToolsSetup + // + name:"dojox.drawing.tools.custom.Axes", + tooltip:"Axes Tool", + iconClass:"iconAxes" +}; +dojox.drawing.register(dojox.drawing.tools.custom.Axes.setup, "tool"); +}); diff --git a/js/dojo/dojox/drawing/tools/custom/Equation.js b/js/dojo/dojox/drawing/tools/custom/Equation.js new file mode 100644 index 0000000..b9b5f40 --- /dev/null +++ b/js/dojo/dojox/drawing/tools/custom/Equation.js @@ -0,0 +1,30 @@ +//>>built +// wrapped by build app +define("dojox/drawing/tools/custom/Equation", ["dijit","dojo","dojox","dojo/require!dojox/drawing/tools/TextBlock"], function(dijit,dojo,dojox){ +dojo.provide("dojox.drawing.tools.custom.Equation"); +dojo.require("dojox.drawing.tools.TextBlock"); + +dojox.drawing.tools.custom.Equation = dojox.drawing.util.oo.declare( + // summary: + // Essentially the same as the TextBlock tool, but + // allows for a different icon and tooltip title. + // + dojox.drawing.tools.TextBlock, + function(options){ + + }, + { + customType:"equation" + } + +); + +dojox.drawing.tools.custom.Equation.setup = { + // summary: See stencil._Base ToolsSetup + // + name:"dojox.drawing.tools.custom.Equation", + tooltip:"Equation Tool", + iconClass:"iconEq" +}; +dojox.drawing.register(dojox.drawing.tools.custom.Equation.setup, "tool"); +}); diff --git a/js/dojo/dojox/drawing/tools/custom/Vector.js b/js/dojo/dojox/drawing/tools/custom/Vector.js new file mode 100644 index 0000000..748af50 --- /dev/null +++ b/js/dojo/dojox/drawing/tools/custom/Vector.js @@ -0,0 +1,392 @@ +//>>built +// wrapped by build app +define("dojox/drawing/tools/custom/Vector", ["dijit","dojo","dojox","dojo/require!dojox/drawing/tools/Arrow,dojox/drawing/util/positioning"], function(dijit,dojo,dojox){ +dojo.provide("dojox.drawing.tools.custom.Vector"); +dojo.require("dojox.drawing.tools.Arrow"); +dojo.require("dojox.drawing.util.positioning"); + +dojox.drawing.tools.custom.Vector = dojox.drawing.util.oo.declare( + // summary: + // Creates a Vector Stencil. + // description: + // Generally the same as an arrow, except that the arrow + // head is only at the end. There is additionaly functionality + // to allow for a 'zero vector' - one with no length. + // + // + dojox.drawing.tools.Arrow, + function(options){ + this.minimumSize = this.style.arrows.length; + this.addShadow({size:3, mult:2}); + }, + { + draws:true, + type:"dojox.drawing.tools.custom.Vector", + minimumSize:30, + showAngle:true, + + + + changeAxis: function(cosphi){ + // summary: + // Converts a vector to and from the z axis. + // If passed a cosphi value that is used to set + // the axis, otherwise it is the opp of what it is. + cosphi = cosphi!==undefined?cosphi:this.style.zAxis? 0 : 1; + if(cosphi == 0){ + this.style.zAxis = false; + this.data.cosphi = 0; + }else{ + this.style.zAxis = true; + var p = this.points; + var pt = this.zPoint(); + this.setPoints([ + {x:p[0].x, y:p[0].y}, + {x:pt.x, y:pt.y} + ]); + } + this.render(); + }, + + _createZeroVector: function(shp, d, sty){ + // summary: + // Special creation function for the zero-vector shape + // + var s = shp=="hit" ? this.minimumSize : this.minimumSize/6; + var f = shp=="hit" ? sty.fill : null; + d = { + cx:this.data.x1, + cy:this.data.y1, + rx:s, + ry:s + }; + + this.remove(this[shp]); + this[shp] = this.container.createEllipse(d) + .setStroke(sty) + .setFill(f); + this.util.attr(this[shp], "drawingType", "stencil"); + }, + + _create: function(/*String*/shp, /*StencilData*/d, /*Object*/sty){ + // summary: + // Creates a dojox.gfx.shape based on passed arguments. + // Can be called many times by implementation to create + // multiple shapes in one stencil. + // + this.remove(this[shp]); + this[shp] = this.container.createLine(d) + .setStroke(sty); + this._setNodeAtts(this[shp]); + }, + + onDrag: function(/*EventObject*/obj){ + // summary: See stencil._Base.onDrag + // + if(this.created){ return; } + + var x1 = obj.start.x, + y1 = obj.start.y, + x2 = obj.x, + y2 = obj.y; + + if(this.keys.shift && !this.style.zAxis){ + var pt = this.util.snapAngle(obj, 45/180); + x2 = pt.x; + y2 = pt.y; + } + + if(this.keys.alt){ + // FIXME: + // should double the length of the line + // FIXME: + // if alt dragging past ZERO it seems to work + // but select/deselect shows bugs + var dx = x2>x1 ? ((x2-x1)/2) : ((x1-x2)/-2); + var dy = y2>y1 ? ((y2-y1)/2) : ((y1-y2)/-2); + x1 -= dx; + x2 -= dx; + y1 -= dy; + y2 -= dy; + } + + if(this.style.zAxis){ + var pts = this.zPoint(obj); + x2 = pts.x; + y2 = pts.y; + } + + this.setPoints([ + {x:x1, y:y1}, + {x:x2, y:y2} + ]); + this.render(); + }, + + onTransform: function(/* ? manager.Anchor */anchor){ + // summary: + // Called from anchor point mouse drag + // also called from plugins.Pan.checkBounds + if(!this._isBeingModified){ + this.onTransformBegin(); + } + // this is not needed for anchor moves, but it + // is for stencil move: + + this.setPoints(this.points); + this.render(); + }, + + anchorConstrain: function(x, y){ + // summary: + // Called from anchor point mouse drag + if(!this.style.zAxis){ return null; } + var radians = this.style.zAngle*Math.PI/180; + //Constrain to angle + var test = x<0 ? x>-y : x<-y; + var dx = test ? x : -y/Math.tan(radians); + var dy = !test ? y : -Math.tan(radians)*x; + return {x:dx, y:dy} + }, + + zPoint: function(obj){ + // summary: + // Takes any point and converts it to + // be on the z-axis. + if(obj===undefined){ + if(!this.points[0]){ return null; }; + var d = this.pointsToData(); + obj = { + start:{ + x:d.x1, + y:d.y1 + }, + x:d.x2, + y:d.y2 + }; + } + var radius = this.util.length(obj); + var angle = this.util.angle(obj); + angle<0 ? angle = 360 + angle : angle; + + angle = angle > 135 && angle < 315 ? this.style.zAngle : this.util.oppAngle(this.style.zAngle); + + return this.util.pointOnCircle(obj.start.x, obj.start.y, radius, angle); + }, + + pointsToData: function(p){ + // summary: + // Converts points to data + p = p || this.points; + var cosphi = 0; + var obj = {start:{x:p[0].x, y:p[0].y}, x:p[1].x, y:p[1].y}; + if(this.style.zAxis && (this.util.length(obj)>this.minimumSize)){ + + var angle = this.util.angle(obj); + angle<0 ? angle = 360 + angle : angle; + cosphi = angle > 135 && angle < 315 ? 1 : -1; + } + this.data = { + x1: p[0].x, + y1: p[0].y, + x2: p[1].x, + y2: p[1].y, + cosphi: cosphi + }; + return this.data; + }, + + dataToPoints: function(o){ + //summary: + // Converts data to points. + o = o || this.data; + if(o.radius || o.angle){ + // instead of using x1,x2,y1,y1, + // it's been set as x,y,angle,radius + var cosphi = 0; + var pt = this.util.pointOnCircle(o.x,o.y,o.radius,o.angle); + if(this.style.zAxis || (o.cosphi && o.cosphi!=0)){ + this.style.zAxis = true; + cosphi = o.angle > 135 && o.angle < 315 ? 1 : -1; + } + //console.log(" ---- pts:", pt.x, pt.y); + this.data = o = { + x1:o.x, + y1:o.y, + x2:pt.x, + y2:pt.y, + cosphi:cosphi + } + + } + this.points = [ + {x:o.x1, y:o.y1}, + {x:o.x2, y:o.y2} + ]; + return this.points; + }, + + render: function(){ + // summary: + // Renders the 'hit' object (the shape used for an expanded + // hit area and for highlighting) and the'shape' (the actual + // display object). Additionally checks if Vector should be + // drawn as an arrow or a circle (zero-length) + // + this.onBeforeRender(this); + if(this.getRadius() >= this.minimumSize){ + this._create("hit", this.data, this.style.currentHit); + this._create("shape", this.data, this.style.current); + + }else{ + this.data.cosphi = 0; + this._createZeroVector("hit", this.data, this.style.currentHit); + this._createZeroVector("shape", this.data, this.style.current); + } + }, + onUp: function(/*EventObject*/obj){ + // summary: See stencil._Base.onUp + // + if(this.created || !this._downOnCanvas){ return; } + this._downOnCanvas = false; + //Default vector for single click + if(!this.shape){ + var d = 100; + obj.start.x = this.style.zAxis ? obj.start.x + d : obj.start.x; + obj.y = obj.y+d; + this.setPoints([ + {x:obj.start.x, y:obj.start.y}, + {x:obj.x, y:obj.y} + ]); + this.render(); + } + + // When within minimum size this sets zero vector length to zero + if(this.getRadius()<this.minimumSize){ + var p = this.points; + this.setPoints([ + {x:p[0].x, y:p[0].y}, + {x:p[0].x, y:p[0].y} + ]); + }else{ + //SnapAngle fails for the zero length vector + var p = this.points; + var pt = this.style.zAxis ? this.zPoint(obj) : this.util.snapAngle(obj, this.angleSnap/180); + this.setPoints([ + {x:p[0].x, y:p[0].y}, + {x:pt.x, y:pt.y} + ]); + } + this.renderedOnce = true; + this.onRender(this); + } + } + +); + +dojox.drawing.tools.custom.Vector.setup = { + // summary: See stencil._Base ToolsSetup + // + name:"dojox.drawing.tools.custom.Vector", + tooltip:"Vector Tool", + iconClass:"iconVector" +}; + +if(dojox.drawing.defaults.zAxisEnabled){ + dojox.drawing.tools.custom.Vector.setup.secondary = { + // summary: + // Creates a secondary tool for the Vector Stencil. + // description: + // See Toolbar.js makeButtons function. The toolbar + // checks Vector.setup for a secondary tool and requires + // name, label, and funct. Currently it doesn't accept icon + // and only uses text from label for the button. Funct is the + // function that fires when the button is clicked. + // + // Setup and postSetup are optional + // and allow tool specific functions to be added to the + // Toolbar object as if they were written there. + name: "vectorSecondary", + label: "z-axis", + funct: function(button){ + button.selected ? this.zDeselect(button) : this.zSelect(button); + + var stencils = this.drawing.stencils.selectedStencils; + for(var nm in stencils){ + if(stencils[nm].shortType == "vector" && (stencils[nm].style.zAxis != dojox.drawing.defaults.zAxis)){ + var s = stencils[nm]; + s.changeAxis(); + //Reset anchors + if(s.style.zAxis){ s.deselect(); s.select(); } + } + } + + }, + setup: function(){ + // summary: + // All functions, variables and connections defined here + // are treated as if they were added directly to toolbar. + // They are included with the tool because secondary buttons + // are tool specific. + var zAxis = dojox.drawing.defaults.zAxis; + this.zSelect = function(button){ + if(!button.enabled){ return; } + zAxis = true; + dojox.drawing.defaults.zAxis = true; + button.select(); + this.vectorTest(); + this.zSelected = button; + }; + this.zDeselect = function(button){ + if(!button.enabled){ return; } + zAxis = false; + dojox.drawing.defaults.zAxis = false; + button.deselect(); + this.vectorTest(); + this.zSelected = null; + }; + this.vectorTest = function(){ + dojo.forEach(this.buttons, function(b){ + if(b.toolType=="vector" && b.selected){ + this.drawing.currentStencil.style.zAxis = zAxis; + } + },this); + }; + dojo.connect(this, "onRenderStencil", this, function(){ if(this.zSelected){ this.zDeselect(this.zSelected)}}); + var c = dojo.connect(this.drawing, "onSurfaceReady", this, function(){ + dojo.disconnect(c); + dojo.connect(this.drawing.stencils, "onSelect", this, function(stencil){ + if(stencil.shortType == "vector"){ + if(stencil.style.zAxis){ + //If stencil is on the z-axis, update button to reflect that + dojo.forEach(this.buttons, function(b){ + if(b.toolType=="vectorSecondary"){ + this.zSelect(b); + } + },this); + + }else{ + //Update button to not be z-axis + dojo.forEach(this.buttons, function(b){ + if(b.toolType=="vectorSecondary"){ + this.zDeselect(b); + } + },this); + } + }; + }); + }); + }, + postSetup: function(btn){ + // summary: + // Depending on the secondary tool, it may need + // extra functionality for some of the basic functions. + // Post is passed the button so those connections can + // be made. + dojo.connect(btn, "enable", function(){ dojox.drawing.defaults.zAxisEnabled = true; }); + dojo.connect(btn, "disable", function(){ dojox.drawing.defaults.zAxisEnabled = false; }); + } + }; +} +dojox.drawing.register(dojox.drawing.tools.custom.Vector.setup, "tool"); +}); |