/**
 * jquery.Jcrop.js v0.9.6
 * jQuery Image Cropping Plugin
 * @author Kelly Hallman <khallman@gmail.com>
 * Copyright (c) 2008-2009 Kelly Hallman - released under MIT License {{{
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:

 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.

 * }}}
 */

(function($) {

$.Jcrop = function(obj,opt)
{
	// Initialization {{{

	// Sanitize some options {{{
	var obj = obj, opt = opt;

	if (typeof(obj) !== 'object') obj = $(obj)[0];
	if (typeof(opt) !== 'object') opt = { };

	if (!('trackDocument' in opt))
		opt.trackDocument = $.browser.msie ? false : true;

	if (!('keySupport' in opt))
			opt.keySupport = $.browser.msie ? false : true;
		
		// }}}
		// Extend the default options {{{
		var defaults = {

			// Basic Settings
			trackDocument:		false,
			baseClass:			'jcrop',
			addClass:			null,

			// Styling Options
			bgColor:			'black',
			bgOpacity:			.6,
			borderOpacity:		.4,
			handleOpacity:		.5,

			handlePad:			5,
			handleSize:			9,
			handleOffset:		5,
			edgeMargin:			14,

			aspectRatio:		0,
			keySupport:			true,
			cornerHandles:		true,
			sideHandles:		true,
			drawBorders:		true,
			dragEdges:			true,

			boxWidth:			0,
			boxHeight:			0,

			boundary:			8,
			animationDelay:		20,
			swingSpeed:			3,

			allowSelect:		true,
			allowMove:			true,
			allowResize:		true,

			minSelect:			[ 0, 0 ],
			maxSize:			[ 0, 0 ],
			minSize:			[ 0, 0 ],

			// Callbacks / Event Handlers
			onChange: function() { },
			onSelect: function() { }

		};
		var options = defaults;
		setOptions(opt);

		// }}}
		// Initialize some jQuery objects {{{

		var $origimg = $(obj);
		var $img = $origimg.clone().css({ position: 'absolute' });

		$origimg.after($img).hide();

		presize($img,options.boxWidth,options.boxHeight);

		var boundx = $img.width(),
			boundy = $img.height(),

			$div = $('<div />')
				.width(boundx).height(boundy)
				.addClass(cssClass('holder'))
				.css({
					position: 'relative',
					backgroundColor: options.bgColor
				}).insertAfter($origimg).append($img);
		;
		
		if (options.addClass) $div.addClass(options.addClass);
		//$img.wrap($div);

		var $img2 = $('<img />')/*{{{*/
				.attr('src',$img.attr('src'))
				.css('position','absolute')
				.width(boundx).height(boundy)
		;/*}}}*/
		var $img_holder = $('<div />')/*{{{*/
			.width(pct(100)).height(pct(100))
			.css({
				zIndex: 310,
				position: 'absolute',
				overflow: 'hidden'
			})
			.append($img2)
		;/*}}}*/
		var $hdl_holder = $('<div />')/*{{{*/
			.width(pct(100)).height(pct(100))
			.css('zIndex',320);
		/*}}}*/
		var $sel = $('<div />')/*{{{*/
			.css({
				position: 'absolute',
				zIndex: 300
			})
			.insertBefore($img)
			.append($img_holder,$hdl_holder)
		;/*}}}*/

		var bound = options.boundary;
		var $trk = $('<div />')
				.addClass(cssClass('tracker'))
				.width(boundx+(bound*2))
				.height(boundy+(bound*2))
				.css({
					position: 'absolute',
					top: px(-bound),
					left: px(-bound),
					zIndex: 290,
					opacity: 0
				})
				.mousedown(newSelection)
		;	
		
		/* }}} */
		// Set more variables {{{

		var xlimit, ylimit, xmin, ymin;
		var xscale, yscale, enabled = true;
		var docOffset = getPos($img),
			// Internal states
			btndown, lastcurs, dimmed, animating,
			shift_down;

		// }}}
		

		// }}}
		// Internal Modules {{{

		var Coords = function()/*{{{*/
		{
			var x1 = 0, y1 = 0, x2 = 0, y2 = 0, ox, oy;

			function setPressed(pos)/*{{{*/
			{
				var pos = rebound(pos);
				x2 = x1 = pos[0];
				y2 = y1 = pos[1];
			};
			/*}}}*/
			function setCurrent(pos)/*{{{*/
			{
				var pos = rebound(pos);
				ox = pos[0] - x2;
				oy = pos[1] - y2;
				x2 = pos[0];
				y2 = pos[1];
			};
			/*}}}*/
			function getOffset()/*{{{*/
			{
				return [ ox, oy ];
			};
			/*}}}*/
			function moveOffset(offset)/*{{{*/
			{
				var ox = offset[0], oy = offset[1];

				if (0 > x1 + ox) ox -= ox + x1;
				if (0 > y1 + oy) oy -= oy + y1;

				if (boundy < y2 + oy) oy += boundy - (y2 + oy);
				if (boundx < x2 + ox) ox += boundx - (x2 + ox);

				x1 += ox;
				x2 += ox;
				y1 += oy;
				y2 += oy;
			};
			/*}}}*/
			function getCorner(ord)/*{{{*/
			{
				var c = getFixed();
				switch(ord)
				{
					case 'ne': return [ c.x2, c.y ];
					case 'nw': return [ c.x, c.y ];
					case 'se': return [ c.x2, c.y2 ];
					case 'sw': return [ c.x, c.y2 ];
				}
			};
			/*}}}*/
			function getFixed()/*{{{*/
			{
				if (!options.aspectRatio) return getRect();
				// This function could use some optimization I think...
				var aspect = options.aspectRatio,
					min_x = options.minSize[0]/xscale, 
					min_y = options.minSize[1]/yscale,
					max_x = options.maxSize[0]/xscale, 
					max_y = options.maxSize[1]/yscale,
					rw = x2 - x1,
					rh = y2 - y1,
					rwa = Math.abs(rw),
					rha = Math.abs(rh),
					real_ratio = rwa / rha,
					xx, yy
				;
				if (max_x == 0) { max_x = boundx * 10 }
				if (max_y == 0) { max_y = boundy * 10 }
				if (real_ratio < aspect)
				{
					yy = y2;
					w = rha * aspect;
					xx = rw < 0 ? x1 - w : w + x1;

					if (xx < 0)
					{
						xx = 0;
						h = Math.abs((xx - x1) / aspect);
						yy = rh < 0 ? y1 - h: h + y1;
					}
					else if (xx > boundx)
					{
						xx = boundx;
						h = Math.abs((xx - x1) / aspect);
						yy = rh < 0 ? y1 - h : h + y1;
					}
				}
				else
				{
					xx = x2;
					h = rwa / aspect;
					yy = rh < 0 ? y1 - h : y1 + h;
					if (yy < 0)
					{
						yy = 0;
						w = Math.abs((yy - y1) * aspect);
						xx = rw < 0 ? x1 - w : w + x1;
					}
					else if (yy > boundy)
					{
						yy = boundy;
						w = Math.abs(yy - y1) * aspect;
						xx = rw < 0 ? x1 - w : w + x1;
					}
				}

				// Magic %-)
				if(xx > x1) { // right side
				  if(xx - x1 < min_x) {
					xx = x1 + min_x;
				  } else if (xx - x1 > max_x) {
					xx = x1 + max_x;
				  }
				  if(yy > y1) {
					yy = y1 + (xx - x1)/aspect;
				  } else {
					yy = y1 - (xx - x1)/aspect;
				  }
				} else if (xx < x1) { // left side
				  if(x1 - xx < min_x) {
					xx = x1 - min_x
				  } else if (x1 - xx > max_x) {
					xx = x1 - max_x;
				  }
				  if(yy > y1) {
					yy = y1 + (x1 - xx)/aspect;
				  } else {
					yy = y1 - (x1 - xx)/aspect;
				  }
				}

				if(xx < 0) {
					x1 -= xx;
					xx = 0;
				} else  if (xx > boundx) {
					x1 -= xx - boundx;
					xx = boundx;
				}

				if(yy < 0) {
					y1 -= yy;
					yy = 0;
				} else  if (yy > boundy) {
					y1 -= yy - boundy;
					yy = boundy;
				}

				return last = makeObj(flipCoords(x1,y1,xx,yy));
			};
			/*}}}*/
			function rebound(p)/*{{{*/
			{
				if (p[0] < 0) p[0] = 0;
				if (p[1] < 0) p[1] = 0;

				if (p[0] > boundx) p[0] = boundx;
				if (p[1] > boundy) p[1] = boundy;

				return [ p[0], p[1] ];
			};
			/*}}}*/
			function flipCoords(x1,y1,x2,y2)/*{{{*/
			{
				var xa = x1, xb = x2, ya = y1, yb = y2;
				if (x2 < x1)
				{
					xa = x2;
					xb = x1;
				}
				if (y2 < y1)
				{
					ya = y2;
					yb = y1;
				}
				return [ Math.round(xa), Math.round(ya), Math.round(xb), Math.round(yb) ];
			};
			/*}}}*/
			function getRect()/*{{{*/
			{
				var xsize = x2 - x1;
				var ysize = y2 - y1;

				if (xlimit && (Math.abs(xsize) > xlimit))
					x2 = (xsize > 0) ? (x1 + xlimit) : (x1 - xlimit);
				if (ylimit && (Math.abs(ysize) > ylimit))
					y2 = (ysize > 0) ? (y1 + ylimit) : (y1 - ylimit);

				if (ymin && (Math.abs(ysize) < ymin))
					y2 = (ysize > 0) ? (y1 + ymin) : (y1 - ymin);
				if (xmin && (Math.abs(xsize) < xmin))
					x2 = (xsize > 0) ? (x1 + xmin) : (x1 - xmin);

				if (x1 < 0) { x2 -= x1; x1 -= x1; }
				if (y1 < 0) { y2 -= y1; y1 -= y1; }
				if (x2 < 0) { x1 -= x2; x2 -= x2; }
				if (y2 < 0) { y1 -= y2; y2 -= y2; }
				if (x2 > boundx) { var delta = x2 - boundx; x1 -= delta; x2 -= delta; }
				if (y2 > boundy) { var delta = y2 - boundy; y1 -= delta; y2 -= delta; }
				if (x1 > boundx) { var delta = x1 - boundy; y2 -= delta; y1 -= delta; }
				if (y1 > boundy) { var delta = y1 - boundy; y2 -= delta; y1 -= delta; }

				return makeObj(flipCoords(x1,y1,x2,y2));
			};
			/*}}}*/
			function makeObj(a)/*{{{*/
			{
				return { x: a[0], y: a[1], x2: a[2], y2: a[3],
					w: a[2] - a[0], h: a[3] - a[1] };
			};
			/*}}}*/

			return {
				flipCoords: flipCoords,
				setPressed: setPressed,
				setCurrent: setCurrent,
				getOffset: getOffset,
				moveOffset: moveOffset,
				getCorner: getCorner,
				getFixed: getFixed
			};
		}();

		/*}}}*/
		var Selection = function()/*{{{*/
		{
			var start, end, dragmode, awake, hdep = 370;
			var borders = { };
			var handle = { };
			var seehandles = false;
			var hhs = options.handleOffset;

			/* Insert draggable elements {{{*/

			// Insert border divs for outline
			if (options.drawBorders) {
				borders = {
						top: insertBorder('hline')
							.css('top',$.browser.msie?px(-1):px(0)),
						bottom: insertBorder('hline'),
						left: insertBorder('vline'),
						right: insertBorder('vline')
				};
			}

			// Insert handles on edges
			if (options.dragEdges) {
				handle.t = insertDragbar('n');
				handle.b = insertDragbar('s');
				handle.r = insertDragbar('e');
				handle.l = insertDragbar('w');
			}

			// Insert side handles
			options.sideHandles &&
				createHandles(['n','s','e','w']);

			// Insert corner handles
			options.cornerHandles &&
				createHandles(['sw','nw','ne','se']);

			/*}}}*/
			// Private Methods
			function insertBorder(type)/*{{{*/
			{
				var jq = $('<div />')
					.css({position: 'absolute', opacity: options.borderOpacity })
					.addClass(cssClass(type));
				$img_holder.append(jq);
				return jq;
			};
			/*}}}*/
			function dragDiv(ord,zi)/*{{{*/
			{
				var jq = $('<div />')
					.mousedown(createDragger(ord))
					.css({
						cursor: ord+'-resize',
						position: 'absolute',
						zIndex: zi 
					})
				;
				$hdl_holder.append(jq);
				return jq;
			};
			/*}}}*/
			function insertHandle(ord)/*{{{*/
			{
				return dragDiv(ord,hdep++)
					.css({ top: px(-hhs+1), left: px(-hhs+1), opacity: options.handleOpacity })
					.addClass(cssClass('handle'));
			};
			/*}}}*/
			function insertDragbar(ord)/*{{{*/
			{
				var s = options.handleSize,
					o = hhs,
					h = s, w = s,
					t = o, l = o;

				switch(ord)
				{
					case 'n': case 's': w = pct(100); break;
					case 'e': case 'w': h = pct(100); break;
				}

				return dragDiv(ord,hdep++).width(w).height(h)
					.css({ top: px(-t+1), left: px(-l+1)});
			};
			/*}}}*/
			function createHandles(li)/*{{{*/
			{
				for(i in li) handle[li[i]] = insertHandle(li[i]);
			};
			/*}}}*/
			function moveHandles(c)/*{{{*/
			{
				var midvert  = Math.round((c.h / 2) - hhs),
					midhoriz = Math.round((c.w / 2) - hhs),
					north = west = -hhs+1,
					east = c.w - hhs,
					south = c.h - hhs,
					x, y;

				'e' in handle &&
					handle.e.css({ top: px(midvert), left: px(east) }) &&
					handle.w.css({ top: px(midvert) }) &&
					handle.s.css({ top: px(south), left: px(midhoriz) }) &&
					handle.n.css({ left: px(midhoriz) });

				'ne' in handle &&
					handle.ne.css({ left: px(east) }) &&
					handle.se.css({ top: px(south), left: px(east) }) &&
					handle.sw.css({ top: px(south) });

				'b' in handle &&
					handle.b.css({ top: px(south) }) &&
					handle.r.css({ left: px(east) });
			};
			/*}}}*/
			function moveto(x,y)/*{{{*/
			{
				$img2.css({ top: px(-y), left: px(-x) });
				$sel.css({ top: px(y), left: px(x) });
			};
			/*}}}*/
			function resize(w,h)/*{{{*/
			{
				$sel.width(w).height(h);
			};
			/*}}}*/
			function refresh()/*{{{*/
			{
				var c = Coords.getFixed();

				Coords.setPressed([c.x,c.y]);
				Coords.setCurrent([c.x2,c.y2]);

				updateVisible();
			};
			/*}}}*/

			// Internal Methods
			function updateVisible()/*{{{*/
				{ if (awake) return update(); };
			/*}}}*/
			function update()/*{{{*/
			{
				var c = Coords.getFixed();

				resize(c.w,c.h);
				moveto(c.x,c.y);

				options.drawBorders &&
					borders['right'].css({ left: px(c.w-1) }) &&
						borders['bottom'].css({ top: px(c.h-1) });

				seehandles && moveHandles(c);
				awake || show();

				options.onChange(unscale(c));
			};
			/*}}}*/
			function show()/*{{{*/
			{
				$sel.show();
				$img.css('opacity',options.bgOpacity);
				awake = true;
			};
			/*}}}*/
			function release()/*{{{*/
			{
				disableHandles();
				$sel.hide();
				$img.css('opacity',1);
				awake = false;
			};
			/*}}}*/
			function showHandles()//{{{
			{
				if (seehandles)
				{
					moveHandles(Coords.getFixed());
					$hdl_holder.show();
				}
			};
			//}}}
			function enableHandles()/*{{{*/
			{ 
				seehandles = true;
				if (options.allowResize)
				{
					moveHandles(Coords.getFixed());
					$hdl_holder.show();
					return true;
				}
			};
			/*}}}*/
			function disableHandles()/*{{{*/
			{
				seehandles = false;
				$hdl_holder.hide();
			};
			/*}}}*/
			function animMode(v)/*{{{*/
			{
				(animating = v) ? disableHandles(): enableHandles();
			};
			/*}}}*/
			function done()/*{{{*/
			{
				animMode(false);
				refresh();
			};
			/*}}}*/

			var $track = $('<div />')
					.addClass(cssClass('tracker'))
					.mousedown(createDragger('move'))
					.css({ cursor: 'move', position: 'absolute', zIndex: 360, opacity: 0 })

			$img_holder.append($track);
			disableHandles();

			return {
				updateVisible: updateVisible,
				update: update,
				release: release,
				refresh: refresh,
				setCursor: function (cursor) { $track.css('cursor',cursor); },
				enableHandles: enableHandles,
				enableOnly: function() { seehandles = true; },
				showHandles: showHandles,
				disableHandles: disableHandles,
				animMode: animMode,
				done: done
			};
		}();
		/*}}}*/
		var Tracker = function()/*{{{*/
		{
			var onMove		= function() { },
				onDone		= function() { },
				trackDoc	= options.trackDocument;

			if (!trackDoc)
			{
				$trk
					.mousemove(trackMove)
					.mouseup(trackUp)
					.mouseout(trackUp)
				;
			}

			function toFront()/*{{{*/
			{
				if (trackDoc)
				{
					$(document)
						.mousemove(trackMove)
						.mouseup(trackUp)
					;
				}
				$trk.css({zIndex:450});
			}
			/*}}}*/
			function toBack()/*{{{*/
			{
				if (trackDoc)
				{
					$(document)
						.unbind('mousemove',trackMove)
						.unbind('mouseup',trackUp)
					;
				}
				$trk.css({zIndex:290});
			}
			/*}}}*/
			function trackMove(e)/*{{{*/
			{
				onMove(mouseAbs(e));
			};
			/*}}}*/
			function trackUp(e)/*{{{*/
			{
				e.preventDefault();
				e.stopPropagation();

				if (btndown)
				{
					btndown = false;

					onDone(mouseAbs(e));
					options.onSelect(unscale(Coords.getFixed()));
					toBack();
					onMove = function() { };
					onDone = function() { };
				}

				return false;
			};
			/*}}}*/

			function activateHandlers(move,done)/* {{{ */
			{
				btndown = true;
				onMove = move;
				onDone = done;
				toFront();
				return false;
			};
			/* }}} */

			function setCursor(t) { $trk.css('cursor',t); };

			$img.before($trk);
			return {
				activateHandlers: activateHandlers,
				setCursor: setCursor
			};
		}();
		/*}}}*/
		var KeyManager = function()/*{{{*/
		{
			var $keymgr = $('<input type="radio" />')
					.css({ position: 'absolute', left: '-30px' })
					.keypress(parseKey)
					.blur(onBlur),

				$keywrap = $('<div />')
					.css({
						position: 'absolute',
						overflow: 'hidden'
					})
					.append($keymgr)
			;

			function watchKeys()/*{{{*/
			{
				if (options.keySupport)
				{
					$keymgr.show();
					$keymgr.focus();
				}
			};
			/*}}}*/
			function onBlur(e)/*{{{*/
			{
				$keymgr.hide();
			};
			/*}}}*/
			function doNudge(e,x,y)/*{{{*/
			{
				if (options.allowMove) {
					Coords.moveOffset([x,y]);
					Selection.updateVisible();
				};
				e.preventDefault();
				e.stopPropagation();
			};
			/*}}}*/
			function parseKey(e)/*{{{*/
			{
				if (e.ctrlKey) return true;
				shift_down = e.shiftKey ? true : false;
				var nudge = shift_down ? 10 : 1;
				switch(e.keyCode)
				{
					case 37: doNudge(e,-nudge,0); break;
					case 39: doNudge(e,nudge,0); break;
					case 38: doNudge(e,0,-nudge); break;
					case 40: doNudge(e,0,nudge); break;

					case 27: Selection.release(); break;

					case 9: return true;
				}

				return nothing(e);
			};
			/*}}}*/
			
			if (options.keySupport) $keywrap.insertBefore($img);
			return {
				watchKeys: watchKeys
			};
		}();
		/*}}}*/

		// }}}
		// Internal Methods {{{

		function px(n) { return '' + parseInt(n) + 'px'; };
		function pct(n) { return '' + parseInt(n) + '%'; };
		function cssClass(cl) { return options.baseClass + '-' + cl; };
		function getPos(obj)/*{{{*/
		{
			// Updated in v0.9.4 to use built-in dimensions plugin
			var pos = $(obj).offset();
			return [ pos.left, pos.top ];
		};
		/*}}}*/
		function mouseAbs(e)/*{{{*/
		{
			return [ (e.pageX - docOffset[0]), (e.pageY - docOffset[1]) ];
		};
		/*}}}*/
		function myCursor(type)/*{{{*/
		{
			if (type != lastcurs)
			{
				Tracker.setCursor(type);
				//Handles.xsetCursor(type);
				lastcurs = type;
			}
		};
		/*}}}*/
		function startDragMode(mode,pos)/*{{{*/
		{
			docOffset = getPos($img);
			Tracker.setCursor(mode=='move'?mode:mode+'-resize');

			if (mode == 'move')
				return Tracker.activateHandlers(createMover(pos), doneSelect);

			var fc = Coords.getFixed();
			Coords.setPressed(Coords.getCorner(oppLockCorner(mode)));
			Tracker.activateHandlers(dragmodeHandler(mode,fc),doneSelect);
		};
		/*}}}*/
		function dragmodeHandler(mode,f)/*{{{*/
		{
			return function(pos) {
				if (!options.aspectRatio) switch(mode)
				{
					case 'e': pos[1] = f.y2; break;
					case 'w': pos[1] = f.y2; break;
					case 'n': pos[0] = f.x2; break;
					case 's': pos[0] = f.x2; break;
				}
				else switch(mode)
				{
					case 'e': pos[1] = f.y+1; break;
					case 'w': pos[1] = f.y+1; break;
					case 'n': pos[0] = f.x+1; break;
					case 's': pos[0] = f.x+1; break;
				}
				Coords.setCurrent(pos);
				Selection.update();
			};
		};
		/*}}}*/
		function createMover(pos)/*{{{*/
		{
			var lloc = pos;
			KeyManager.watchKeys();

			return function(pos)
			{
				Coords.moveOffset([pos[0] - lloc[0], pos[1] - lloc[1]]);
				lloc = pos;
				
				Selection.update();
			};
		};
		/*}}}*/
		function oppLockCorner(ord)/*{{{*/
		{
			switch(ord)
			{
				case 'n': return 'sw';
				case 's': return 'nw';
				case 'e': return 'nw';
				case 'w': return 'ne';
				case 'ne': return 'sw';
				case 'nw': return 'se';
				case 'se': return 'nw';
				case 'sw': return 'ne';
			};
		};
		/*}}}*/
		function createDragger(ord)/*{{{*/
		{
			return function(e) {
				if (options.disabled) return false;
				if ((ord == 'move') && !options.allowMove) return false;
				btndown = true;
				startDragMode(ord,mouseAbs(e));
				e.stopPropagation();
				e.preventDefault();
				return false;
			};
		};
		/*}}}*/
		function presize($obj,w,h)/*{{{*/
		{
			var nw = $obj.width(), nh = $obj.height();
			if ((nw > w) && w > 0)
			{
				nw = w;
				nh = (w/$obj.width()) * $obj.height();
			}
			if ((nh > h) && h > 0)
			{
				nh = h;
				nw = (h/$obj.height()) * $obj.width();
			}
			xscale = $obj.width() / nw;
			yscale = $obj.height() / nh;
			$obj.width(nw).height(nh);
		};
		/*}}}*/
		function unscale(c)/*{{{*/
		{
			return {
				x: parseInt(c.x * xscale), y: parseInt(c.y * yscale), 
				x2: parseInt(c.x2 * xscale), y2: parseInt(c.y2 * yscale), 
				w: parseInt(c.w * xscale), h: parseInt(c.h * yscale)
			};
		};
		/*}}}*/
		function doneSelect(pos)/*{{{*/
		{
			var c = Coords.getFixed();
			if (c.w > options.minSelect[0] && c.h > options.minSelect[1])
			{
				Selection.enableHandles();
				Selection.done();
			}
			else
			{
				Selection.release();
			}
			Tracker.setCursor( options.allowSelect?'crosshair':'default' );
		};
		/*}}}*/
		function newSelection(e)/*{{{*/
		{
			if (options.disabled) return false;
			if (!options.allowSelect) return false;
			btndown = true;
			docOffset = getPos($img);
			Selection.disableHandles();
			myCursor('crosshair');
			var pos = mouseAbs(e);
			Coords.setPressed(pos);
			Tracker.activateHandlers(selectDrag,doneSelect);
			KeyManager.watchKeys();
			Selection.update();

			e.stopPropagation();
			e.preventDefault();
			return false;
		};
		/*}}}*/
		function selectDrag(pos)/*{{{*/
		{
			Coords.setCurrent(pos);
			Selection.update();
		};
		/*}}}*/

		// }}}
		// Public API {{{
		
		function animateTo(a)/*{{{*/
		{
			var x1 = a[0] / xscale,
				y1 = a[1] / yscale,
				x2 = a[2] / xscale,
				y2 = a[3] / yscale;

			if (animating) return;

			var animto = Coords.flipCoords(x1,y1,x2,y2);
			var c = Coords.getFixed();
			var animat = initcr = [ c.x, c.y, c.x2, c.y2 ];
			var interv = options.animationDelay;

			var x = animat[0];
			var y = animat[1];
			var x2 = animat[2];
			var y2 = animat[3];
			var ix1 = animto[0] - initcr[0];
			var iy1 = animto[1] - initcr[1];
			var ix2 = animto[2] - initcr[2];
			var iy2 = animto[3] - initcr[3];
			var pcent = 0;
			var velocity = options.swingSpeed;

			Selection.animMode(true);

			var animator = function()
			{
				return function()
				{
					pcent += (100 - pcent) / velocity;

					animat[0] = x + ((pcent / 100) * ix1);
					animat[1] = y + ((pcent / 100) * iy1);
					animat[2] = x2 + ((pcent / 100) * ix2);
					animat[3] = y2 + ((pcent / 100) * iy2);

					if (pcent < 100) animateStart();
						else Selection.done();

					if (pcent >= 99.8) pcent = 100;

					setSelectRaw(animat);
				};
			}();

			function animateStart()
				{ window.setTimeout(animator,interv); };

			animateStart();
		};
		/*}}}*/
		function setSelect(rect)//{{{
		{
			setSelectRaw([rect[0]/xscale,rect[1]/yscale,rect[2]/xscale,rect[3]/yscale]);
		};
		//}}}
		function setSelectRaw(l) /*{{{*/
		{
			Coords.setPressed([l[0],l[1]]);
			Coords.setCurrent([l[2],l[3]]);
			Selection.update();
		};
		/*}}}*/
		function setOptions(opt)/*{{{*/
		{
			if (typeof(opt) != 'object') opt = { };
			options = $.extend(options,opt);

			if (typeof(options.onChange)!=='function')
				options.onChange = function() { };

			if (typeof(options.onSelect)!=='function')
				options.onSelect = function() { };

		};
		/*}}}*/
		function tellSelect()/*{{{*/
		{
			return unscale(Coords.getFixed());
		};
		/*}}}*/
		function tellScaled()/*{{{*/
		{
			return Coords.getFixed();
		};
		/*}}}*/
		function setOptionsNew(opt)/*{{{*/
		{
			setOptions(opt);
			interfaceUpdate();
		};
		/*}}}*/
		function disableCrop()//{{{
		{
			options.disabled = true;
			Selection.disableHandles();
			Selection.setCursor('default');
			Tracker.setCursor('default');
		};
		//}}}
		function enableCrop()//{{{
		{
			options.disabled = false;
			interfaceUpdate();
		};
		//}}}
		function cancelCrop()//{{{
		{
			Selection.done();
			Tracker.activateHandlers(null,null);
		};
		//}}}
		function destroy()//{{{
		{
			$div.remove();
			$origimg.show();
		};
		//}}}

		function interfaceUpdate(alt)//{{{
		// This method tweaks the interface based on options object.
		// Called when options are changed and at end of initialization.
		{
			options.allowResize ?
				alt?Selection.enableOnly():Selection.enableHandles():
				Selection.disableHandles();

			Tracker.setCursor( options.allowSelect? 'crosshair': 'default' );
			Selection.setCursor( options.allowMove? 'move': 'default' );

			if ('setSelect' in options) {
				setSelect(opt.setSelect);
				Selection.done();
				delete(options.setSelect);
			}

			if ('trueSize' in options) {
				xscale = options.trueSize[0] / boundx;
				yscale = options.trueSize[1] / boundy;
			}

			xlimit = options.maxSize[0] || 0;
			ylimit = options.maxSize[1] || 0;
			xmin = options.minSize[0] || 0;
			ymin = options.minSize[1] || 0;

			if ('outerImage' in options)
			{
				$img.attr('src',options.outerImage);
				delete(options.outerImage);
			}

			Selection.refresh();
		};
		//}}}

	// }}}


	$hdl_holder.hide();
	interfaceUpdate(true);
	
	return {
		animateTo: animateTo,
		setSelect: setSelect,
		setOptions: setOptionsNew,
		tellSelect: tellSelect,
		tellScaled: tellScaled,

		disable: disableCrop,
		enable: enableCrop,
		cancel: cancelCrop,

		focus: KeyManager.watchKeys,

		getBounds: function() { return [ boundx * xscale, boundy * yscale ]; },
		getWidgetSize: function() { return [ boundx, boundy ]; },

		release: Selection.release,
		destroy: destroy

	};
};


$.fn.Jcrop = function(options)/*{{{*/
{
	function attachWhenDone(from)/*{{{*/
	{
		var loadsrc = options.useImg || from.src;
		var img = new Image();
		var from = from;
		img.onload = function() {
			$(from).hide().after(img);
			from.Jcrop = $.Jcrop(img,options);
		};
		img.src = loadsrc;
	};
	/*}}}*/
	if (typeof(options) !== 'object') options = { };

	// Iterate over each object, attach Jcrop
	this.each(function()
	{
		// If we've already attached to this object
		if ('Jcrop' in this)
		{
			// The API can be requested this way (undocumented)
			if (options == 'api') return this.Jcrop;
			// Otherwise, we just reset the options...
			else this.Jcrop.setOptions(options);
		}
		// If we haven't been attached, preload and attach
		else attachWhenDone(this);
	});

	// Return "this" so we're chainable a la jQuery plugin-style!
	return this;
};
/*}}}*/

})(jQuery);