define("dojox/drawing/manager/Anchors", ["dojo", "../util/oo", "../defaults"], 
function(dojo, oo, defaults){

var Anchor = oo.declare(
	function(/* Object */ options){
		// summary:
		//		constructor.
		// options:
		//		dojox.__stencilArgs plus some additional
		//		data, like which point this is (pointIdx)

		this.defaults = defaults.copy();
		this.mouse = options.mouse;
		this.point = options.point;
		this.pointIdx = options.pointIdx;
		this.util = options.util;
		this.id = options.id || this.util.uid("anchor");
		this.org = dojo.mixin({}, this.point);
		this.stencil = options.stencil;
		if(this.stencil.anchorPositionCheck){
			this.anchorPositionCheck = dojo.hitch(this.stencil, this.stencil.anchorPositionCheck);
		}
		if(this.stencil.anchorConstrain){
			this.anchorConstrain = dojo.hitch(this.stencil, this.stencil.anchorConstrain);
		}
		this._zCon = dojo.connect(this.mouse, "setZoom", this, "render");
		this.render();
		this.connectMouse();
	},
	{
		// summary:
		//		An anchor point that is attached to (usually) one of the
		//		corners of a Stencil.
		//		Used internally.

		y_anchor:null,
		x_anchor:null,
		render: function(){
			// summary:
			//		Creates the anchor point. Unlike most render methods
			//		in Drawing, this is only called once.

			this.shape && this.shape.removeShape();
			var d = this.defaults.anchors,
				z = this.mouse.zoom,
				b = d.width * z,
				s = d.size * z,
				p = s/2,
				line = {
					width:b,
					style:d.style,
					color:d.color,
					cap:d.cap
				};
			
	
			var _r = {
				x: this.point.x-p,
				y: this.point.y-p,
				width: s,
				height: s
			};
			this.shape = this.stencil.container.createRect(_r)
				.setStroke(line)
				.setFill(d.fill);
			
			this.shape.setTransform({dx:0, dy:0});
			this.util.attr(this, "drawingType", "anchor");
			this.util.attr(this, "id", this.id);
		},
		onRenderStencil: function(/*Anchor*/anchor){
			// summary:
			//		Event fires when an anchor calls a Stencil's render method
		},
		onTransformPoint: function(/*Anchor*/anchor){
			// summary:
			//		Event fires when an anchor changes the points of a Stencil
		},
		onAnchorDown: function(/*Mouse.EventObject*/obj){
			// summary:
			//		Event fires for mousedown on anchor
			this.selected = obj.id == this.id;
		},
		onAnchorUp: function(/*Mouse.EventObject*/obj){
			// summary:
			//		Event fires for mouseup on anchor
			this.selected = false;
			this.stencil.onTransformEnd(this);
		},
		
		onAnchorDrag: function(/*Mouse.EventObject*/obj){
			// summary:
			//		Event fires for on dragging of an anchor
			if(this.selected){
				// mx is the original transform from when the anchor
				// was created. It does not change
				var mx = this.shape.getTransform();
				
				var pmx = this.shape.getParent().getParent().getTransform();
				
				var marginZero = this.defaults.anchors.marginZero;
				
				var orgx = pmx.dx + this.org.x,
					orgy = pmx.dy + this.org.y,
					x = obj.x - orgx,
					y = obj.y - orgy,
					s = this.defaults.anchors.minSize;
				
				var conL, conR, conT, conB;
				
				var chk = this.anchorPositionCheck(x, y, this);
				if(chk.x<0){
					0 && console.warn("X<0 Shift");
					while(this.anchorPositionCheck(x, y, this).x<0){
						this.shape.getParent().getParent().applyTransform({dx:2, dy:0});
					}
				}
				if(chk.y<0){
					0 && console.warn("Y<0 Shift");
					while(this.anchorPositionCheck(x, y, this).y<0){
						this.shape.getParent().getParent().applyTransform({dx:0, dy:2});
					}
				}
				
				if(this.y_anchor){
					// prevent y overlap of opposite anchor
					if(this.org.y > this.y_anchor.org.y){
						// bottom anchor
						
						conT = this.y_anchor.point.y + s - this.org.y;
						conB = Infinity;
						
						if(y < conT){
							// overlapping other anchor
							y = conT;
						}
						
						
					}else{
						// top anchor
						
						conT = -orgy + marginZero;
						conB = this.y_anchor.point.y - s - this.org.y;
						
						if(y < conT){
							// less than zero
							y = conT;
						}else if(y > conB){
							// overlapping other anchor
							y = conB;
						}
					}
				}else{
					// Lines - check for zero
					conT = -orgy + marginZero;
					if(y < conT){
						// less than zero
						y = conT;
					}
				}

				if(this.x_anchor){
					// prevent x overlap of opposite anchor
					
					if(this.org.x>this.x_anchor.org.x){
						// right anchor
						
						conL = this.x_anchor.point.x + s - this.org.x;
						conR = Infinity;
						
						if(x < conL){
							// overlapping other anchor
							x = conL;
						}
						
					}else{
						// left anchor
						
						conL = -orgx + marginZero;
						conR = this.x_anchor.point.x - s - this.org.x;
						
						if(x < conL){
							x = conL;
						}else if(x > conR){
							// overlapping other anchor
							x = conR;
						}
					}
				}else{
					// Lines check for zero
					conL = -orgx + marginZero;
					if(x < conL){
						x = conL;
					}
				}
				//Constrains anchor point, returns null if not overwritten by stencil
				var constrained = this.anchorConstrain(x, y);
				if(constrained != null){
					x=constrained.x;
					y=constrained.y;
				}
				
				this.shape.setTransform({
					dx:x,
					dy:y
				});
				if(this.linkedAnchor){
					// first and last points of a closed-curve-path
					this.linkedAnchor.shape.setTransform({
						dx:x,
						dy:y
					});
				}
				this.onTransformPoint(this);
			}
		},
		
		anchorConstrain: function(/* Number */x,/* Number */ y){
			// summary:
			//		To be over written by tool!
			//		Add an anchorConstrain method to the tool
			//		and it will automatically overwrite this stub.
			//		Should return a constrained x & y value.
			return null;
		},
		
		anchorPositionCheck: function(/* Number */x,/* Number */ y, /* Anchor */anchor){
			// summary:
			//		To be over written by tool!
			//		Add a anchorPositionCheck method to the tool
			//		and it will automatically overwrite this stub.
			//		Should return x and y coords. Success is both
			//		being greater than zero, fail is if one or both
			//		are less than zero.
			return {x:1, y:1};
		},
		
		setPoint: function(mx){
			// summary:
			//		Internal. Sets the Stencil's point
			this.shape.applyTransform(mx);
		},
		
		connectMouse: function(){
			// summary:
			//		Internal. Connects anchor to manager.mouse
			this._mouseHandle = this.mouse.register(this);
		},
		
		disconnectMouse: function(){
			// summary:
			//		Internal. Disconnects anchor to manager.mouse
			this.mouse.unregister(this._mouseHandle);
		},
		
		reset: function(stencil){
			// summary:
			//		Called (usually) from a Stencil when that Stencil
			//		needed to make modifications to the position of the
			//		point. Basically used when teh anchor causes a
			//		less than zero condition.
		},
		
		destroy: function(){
			// summary:
			//		Destroys anchor.
			dojo.disconnect(this._zCon);
			this.disconnectMouse();
			this.shape.removeShape();
		}
	}
);

//dojox.drawing.manager.Anchors = 
return oo.declare(
	// summary:
	//		Creates and manages the anchor points that are attached to
	//		(usually) the corners of a Stencil.
	// description:
	//		Used internally, but there are some things that should be known:
	//		Anchors attach to a Stencil's 'points' (See stencil.points)
	//		To not display an anchor on a certain point, add noAnchor:true
	//		to the point.
	
	function(/* dojox.__stencilArgs */options){
		this.mouse = options.mouse;
		this.undo = options.undo;
		this.util = options.util;
		this.drawing = options.drawing;
		this.items = {};
	},
	{
		onAddAnchor: function(/*Anchor*/anchor){
			// summary:
			//		Event fires when anchor is created
		},
		
		
		onReset: function(/*Stencil*/stencil){
			// summary:
			//		Event fires when an anchor's reset method is called

			// a desperate hack in order to get the anchor point to reset.
			// FIXME: Is this still used? I think its item.deselect();item.select();
			var st = this.util.byId("drawing").stencils;
			st.onDeselect(stencil);
			st.onSelect(stencil);
		},
		
		onRenderStencil: function(){
			// summary:
			//		Event fires when an anchor calls a Stencil's render method

			for(var nm in this.items){
				dojo.forEach(this.items[nm].anchors, function(a){
					a.shape.moveToFront();
				});
			}
		},
		
		onTransformPoint: function(/*Anchor*/anchor){
			// summary:
			//		Event fired on anchor drag

			// If anchors are a "group", it's corresponding anchor
			// is set. All anchors then moved to front.
			var anchors = this.items[anchor.stencil.id].anchors;
			var item = this.items[anchor.stencil.id].item;
			var pts = [];
			dojo.forEach(anchors, function(a, i){
				if(anchor.id == a.id || anchor.stencil.anchorType!="group"){
					// nothing
				}else{
					if(anchor.org.y == a.org.y){
						a.setPoint({
							dx: 0,
							dy: anchor.shape.getTransform().dy - a.shape.getTransform().dy
						});
					}else if(anchor.org.x == a.org.x){
						a.setPoint({
							dx: anchor.shape.getTransform().dx - a.shape.getTransform().dx,
							dy: 0
						});
					}
					a.shape.moveToFront();
				}
				
				var mx = a.shape.getTransform();
				pts.push({x:mx.dx + a.org.x, y:mx.dy+ a.org.y});
				
				if(a.point.t){
					pts[pts.length-1].t = a.point.t;
				}
				
			}, this);
			item.setPoints(pts);
			item.onTransform(anchor);
			this.onRenderStencil();
		},
		
		onAnchorUp: function(/*Anchor*/anchor){
			// summary:
			//		Event fired on anchor mouseup
		},
		
		onAnchorDown: function(/*Anchor*/anchor){
			// summary:
			//		Event fired on anchor mousedown
		},
		
		onAnchorDrag: function(/*Anchor*/anchor){
			// summary:
			//		Event fired when anchor is moved
		},
		
		onChangeStyle: function(/*Object*/stencil){
			// summary:
			//		if the Stencil changes color while were's selected
			//		this moves the anchors to the back. Fix it.
			
			for(var nm in this.items){
				dojo.forEach(this.items[nm].anchors, function(a){
					a.shape.moveToFront();
				});
			}
		},
		
		add: function(/*Stencil*/item){
			// summary:
			//		Creates anchor points on a Stencil, based on the
			//		Stencil's points.

			this.items[item.id] = {
				item:item,
				anchors:[]
			};
			if(item.anchorType=="none"){ return; }
			var pts = item.points;
			dojo.forEach(pts, function(p, i){
				if(p.noAnchor){ return; }
				if(i==0 || i == item.points.length-1){
					0 && console.log("ITEM TYPE:", item.type, item.shortType);
				}
				var a = new Anchor({stencil:item, point:p, pointIdx:i, mouse:this.mouse, util:this.util});
				this.items[item.id]._cons = [
					dojo.connect(a, "onRenderStencil", this, "onRenderStencil"),
					dojo.connect(a, "reset", this, "onReset"),
					dojo.connect(a, "onAnchorUp", this, "onAnchorUp"),
					dojo.connect(a, "onAnchorDown", this, "onAnchorDown"),
					dojo.connect(a, "onAnchorDrag", this, "onAnchorDrag"),
					dojo.connect(a, "onTransformPoint", this, "onTransformPoint"),
					// FIXME: this will fire for each anchor. yech.
					dojo.connect(item, "onChangeStyle", this, "onChangeStyle")
				];
				
				this.items[item.id].anchors.push(a);
				this.onAddAnchor(a);
			}, this);
			
			if(item.shortType=="path"){
				// check if we have a double-point of a closed-curve-path
				var f = pts[0], l = pts[pts.length-1], a = this.items[item.id].anchors;
				if(f.x ==l.x && f.y==l.y){
					0 && console.warn("LINK ANVHROS", a[0], a[a.length-1]);
					a[0].linkedAnchor = a[a.length-1];
					a[a.length-1].linkedAnchor = a[0];
				}
			}
			
			if(item.anchorType=="group"){
				dojo.forEach(this.items[item.id].anchors, function(anchor){
					dojo.forEach(this.items[item.id].anchors, function(a){
						if(anchor.id != a.id){
							if(anchor.org.y == a.org.y){
								anchor.x_anchor = a;
							}else if(anchor.org.x == a.org.x){
								anchor.y_anchor = a;
							}
						}
					},this);
				},this);
				
			}
		},
		
		remove: function(/*Stencil*/item){
			// summary:
			//		Destroys the anchor points for a Stencil.

			if(!this.items[item.id]){
				return;
			}
			dojo.forEach(this.items[item.id].anchors, function(a){
				a.destroy();
			});
			dojo.forEach(this.items[item.id]._cons, dojo.disconnect, dojo);
			this.items[item.id].anchors = null;
			delete this.items[item.id];
		}
	}
);

});
