diff options
Diffstat (limited to 'js/dojo/dojox/drawing/tools/custom/Axes.js')
| -rw-r--r-- | js/dojo/dojox/drawing/tools/custom/Axes.js | 577 |
1 files changed, 577 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"); +}); |