/*
* jQuery UI 1.5.2
*
* Copyright (c) 2008 Paul Bakaus (ui.jquery.com)
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* http://docs.jquery.com/UI
*/
; (function($) {

    $.ui = {
        plugin: {
            add: function(module, option, set) {
                var proto = $.ui[module].prototype;
                for (var i in set) {
                    proto.plugins[i] = proto.plugins[i] || [];
                    proto.plugins[i].push([option, set[i]]);
                }
            },
            call: function(instance, name, args) {
                var set = instance.plugins[name];
                if (!set) { return; }

                for (var i = 0; i < set.length; i++) {
                    if (instance.options[set[i][0]]) {
                        set[i][1].apply(instance.element, args);
                    }
                }
            }
        },
        cssCache: {},
        css: function(name) {
            if ($.ui.cssCache[name]) { return $.ui.cssCache[name]; }
            var tmp = $('<div class="ui-gen">').addClass(name).css({ position: 'absolute', top: '-5000px', left: '-5000px', display: 'block' }).appendTo('body');

            //if (!$.browser.safari)
            //tmp.appendTo('body'); 

            //Opera and Safari set width and height to 0px instead of auto
            //Safari returns rgba(0,0,0,0) when bgcolor is not set
            $.ui.cssCache[name] = !!(
			(!(/auto|default/).test(tmp.css('cursor')) || (/^[1-9]/).test(tmp.css('height')) || (/^[1-9]/).test(tmp.css('width')) ||
			!(/none/).test(tmp.css('backgroundImage')) || !(/transparent|rgba\(0, 0, 0, 0\)/).test(tmp.css('backgroundColor')))
		);
            try { $('body').get(0).removeChild(tmp.get(0)); } catch (e) { }
            return $.ui.cssCache[name];
        },
        disableSelection: function(el) {
            $(el).attr('unselectable', 'on').css('MozUserSelect', 'none');
        },
        enableSelection: function(el) {
            $(el).attr('unselectable', 'off').css('MozUserSelect', '');
        },
        hasScroll: function(e, a) {
            var scroll = /top/.test(a || "top") ? 'scrollTop' : 'scrollLeft', has = false;
            if (e[scroll] > 0) return true; e[scroll] = 1;
            has = e[scroll] > 0 ? true : false; e[scroll] = 0;
            return has;
        }
    };


    /** jQuery core modifications and additions **/

    var _remove = $.fn.remove;
    $.fn.remove = function() {
        $("*", this).add(this).triggerHandler("remove");
        return _remove.apply(this, arguments);
    };

    // $.widget is a factory to create jQuery plugins
    // taking some boilerplate code out of the plugin code
    // created by Scott Gonz?lez and J?rn Zaefferer
    function getter(namespace, plugin, method) {
        var methods = $[namespace][plugin].getter || [];
        methods = (typeof methods == "string" ? methods.split(/,?\s+/) : methods);
        return ($.inArray(method, methods) != -1);
    }

    $.widget = function(name, prototype) {
        var namespace = name.split(".")[0];
        name = name.split(".")[1];

        // create plugin method
        $.fn[name] = function(options) {
            var isMethodCall = (typeof options == 'string'),
			args = Array.prototype.slice.call(arguments, 1);

            if (isMethodCall && getter(namespace, name, options)) {
                var instance = $.data(this[0], name);
                return (instance ? instance[options].apply(instance, args)
				: undefined);
            }

            return this.each(function() {
                var instance = $.data(this, name);
                if (isMethodCall && instance && $.isFunction(instance[options])) {
                    instance[options].apply(instance, args);
                } else if (!isMethodCall) {
                    $.data(this, name, new $[namespace][name](this, options));
                }
            });
        };

        // create widget constructor
        $[namespace][name] = function(element, options) {
            var self = this;

            this.widgetName = name;
            this.widgetBaseClass = namespace + '-' + name;

            this.options = $.extend({}, $.widget.defaults, $[namespace][name].defaults, options);
            this.element = $(element)
			.bind('setData.' + name, function(e, key, value) {
			    return self.setData(key, value);
			})
			.bind('getData.' + name, function(e, key) {
			    return self.getData(key);
			})
			.bind('remove', function() {
			    return self.destroy();
			});
            this.init();
        };

        // add widget prototype
        $[namespace][name].prototype = $.extend({}, $.widget.prototype, prototype);
    };

    $.widget.prototype = {
        init: function() { },
        destroy: function() {
            this.element.removeData(this.widgetName);
        },

        getData: function(key) {
            return this.options[key];
        },
        setData: function(key, value) {
            this.options[key] = value;

            if (key == 'disabled') {
                this.element[value ? 'addClass' : 'removeClass'](
				this.widgetBaseClass + '-disabled');
            }
        },

        enable: function() {
            this.setData('disabled', false);
        },
        disable: function() {
            this.setData('disabled', true);
        }
    };

    $.widget.defaults = {
        disabled: false
    };


    /** Mouse Interaction Plugin **/

    $.ui.mouse = {
        mouseInit: function() {
            var self = this;

            this.element.bind('mousedown.' + this.widgetName, function(e) {
                return self.mouseDown(e);
            });

            // Prevent text selection in IE
            if ($.browser.msie) {
                this._mouseUnselectable = this.element.attr('unselectable');
                this.element.attr('unselectable', 'on');
            }

            this.started = false;
        },

        // TODO: make sure destroying one instance of mouse doesn't mess with
        // other instances of mouse
        mouseDestroy: function() {
            this.element.unbind('.' + this.widgetName);

            // Restore text selection in IE
            ($.browser.msie
			&& this.element.attr('unselectable', this._mouseUnselectable));
        },

        mouseDown: function(e) {
            // we may have missed mouseup (out of window)
            (this._mouseStarted && this.mouseUp(e));

            this._mouseDownEvent = e;

            var self = this,
			btnIsLeft = (e.which == 1),
			elIsCancel = (typeof this.options.cancel == "string" ? $(e.target).parents().add(e.target).filter(this.options.cancel).length : false);
            if (!btnIsLeft || elIsCancel || !this.mouseCapture(e)) {
                return true;
            }

            this._mouseDelayMet = !this.options.delay;
            if (!this._mouseDelayMet) {
                this._mouseDelayTimer = setTimeout(function() {
                    self._mouseDelayMet = true;
                }, this.options.delay);
            }

            if (this.mouseDistanceMet(e) && this.mouseDelayMet(e)) {
                this._mouseStarted = (this.mouseStart(e) !== false);
                if (!this._mouseStarted) {
                    e.preventDefault();
                    return true;
                }
            }

            // these delegates are required to keep context
            this._mouseMoveDelegate = function(e) {
                return self.mouseMove(e);
            };
            this._mouseUpDelegate = function(e) {
                return self.mouseUp(e);
            };
            $(document)
			.bind('mousemove.' + this.widgetName, this._mouseMoveDelegate)
			.bind('mouseup.' + this.widgetName, this._mouseUpDelegate);

            return false;
        },

        mouseMove: function(e) {
            // IE mouseup check - mouseup happened when mouse was out of window
            if ($.browser.msie && !e.button) {
                return this.mouseUp(e);
            }

            if (this._mouseStarted) {
                this.mouseDrag(e);
                return false;
            }

            if (this.mouseDistanceMet(e) && this.mouseDelayMet(e)) {
                this._mouseStarted =
				(this.mouseStart(this._mouseDownEvent, e) !== false);
                (this._mouseStarted ? this.mouseDrag(e) : this.mouseUp(e));
            }

            return !this._mouseStarted;
        },

        mouseUp: function(e) {
            $(document)
			.unbind('mousemove.' + this.widgetName, this._mouseMoveDelegate)
			.unbind('mouseup.' + this.widgetName, this._mouseUpDelegate);

            if (this._mouseStarted) {
                this._mouseStarted = false;
                this.mouseStop(e);
            }

            return false;
        },

        mouseDistanceMet: function(e) {
            return (Math.max(
				Math.abs(this._mouseDownEvent.pageX - e.pageX),
				Math.abs(this._mouseDownEvent.pageY - e.pageY)
			) >= this.options.distance
		);
        },

        mouseDelayMet: function(e) {
            return this._mouseDelayMet;
        },

        // These are placeholder methods, to be overriden by extending plugin
        mouseStart: function(e) { },
        mouseDrag: function(e) { },
        mouseStop: function(e) { },
        mouseCapture: function(e) { return true; }
    };

    $.ui.mouse.defaults = {
        cancel: null,
        distance: 1,
        delay: 0
    };

})(jQuery);


/*
* jQuery UI Draggable
*
* Copyright (c) 2008 Paul Bakaus
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
* 
* http://docs.jquery.com/UI/Draggables
*
* Depends:
*	ui.core.js
*/
(function($) {

    $.widget("ui.draggable", $.extend({}, $.ui.mouse, {
        init: function() {

            //Initialize needed constants
            var o = this.options;

            //Position the node
            if (o.helper == 'original' && !(/(relative|absolute|fixed)/).test(this.element.css('position')))
                this.element.css('position', 'relative');

            this.element.addClass('ui-draggable');
            (o.disabled && this.element.addClass('ui-draggable-disabled'));

            this.mouseInit();

        },
        mouseStart: function(e) {
            var o = this.options;

            if (this.helper || o.disabled || $(e.target).is('.ui-resizable-handle')) return false;

            var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;


            $(this.options.handle, this.element).find("*").andSelf().each(function() {
                if (this == e.target) handle = true;
            });
            if (!handle) return false;

            if ($.ui.ddmanager) $.ui.ddmanager.current = this;

            //Create and append the visible helper
            this.helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [e])) : (o.helper == 'clone' ? this.element.clone() : this.element);
            if (!this.helper.parents('body').length) this.helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));
            if (this.helper[0] != this.element[0] && !(/(fixed|absolute)/).test(this.helper.css("position"))) this.helper.css("position", "absolute");

            /*
            * - Position generation -
            * This block generates everything position related - it's the core of draggables.
            */

            this.margins = {																				//Cache the margins
                left: (parseInt(this.element.css("marginLeft"), 10) || 0),
                top: (parseInt(this.element.css("marginTop"), 10) || 0)
            };

            this.cssPosition = this.helper.css("position"); 												//Store the helper's css position
            this.offset = this.element.offset(); 														//The element's absolute position on the page
            this.offset = {																					//Substract the margins from the element's absolute offset
                top: this.offset.top - this.margins.top,
                left: this.offset.left - this.margins.left
            };

            this.offset.click = {																			//Where the click happened, relative to the element
                left: e.pageX - this.offset.left,
                top: e.pageY - this.offset.top
            };

            this.offsetParent = this.helper.offsetParent(); var po = this.offsetParent.offset(); 		//Get the offsetParent and cache its position
            if (this.offsetParent[0] == document.body && $.browser.mozilla) po = { top: 0, left: 0 }; 	//Ugly FF3 fix
            this.offset.parent = {																			//Store its position plus border
                top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
                left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
            };

            var p = this.element.position(); 															//This is a relative to absolute position minus the actual position calculation - only used for relative positioned helpers
            this.offset.relative = this.cssPosition == "relative" ? {
                top: p.top - (parseInt(this.helper.css("top"), 10) || 0) + this.offsetParent[0].scrollTop,
                left: p.left - (parseInt(this.helper.css("left"), 10) || 0) + this.offsetParent[0].scrollLeft
} : { top: 0, left: 0 };

                this.originalPosition = this.generatePosition(e); 											//Generate the original position
                this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() }; //Cache the helper size

                if (o.cursorAt) {
                    if (o.cursorAt.left != undefined) this.offset.click.left = o.cursorAt.left + this.margins.left;
                    if (o.cursorAt.right != undefined) this.offset.click.left = this.helperProportions.width - o.cursorAt.right + this.margins.left;
                    if (o.cursorAt.top != undefined) this.offset.click.top = o.cursorAt.top + this.margins.top;
                    if (o.cursorAt.bottom != undefined) this.offset.click.top = this.helperProportions.height - o.cursorAt.bottom + this.margins.top;
                }


                /*
                * - Position constraining -
                * Here we prepare position constraining like grid and containment.
                */

                if (o.containment) {
                    if (o.containment == 'parent') o.containment = this.helper[0].parentNode;
                    if (o.containment == 'document' || o.containment == 'window') this.containment = [
				0 - this.offset.relative.left - this.offset.parent.left,
				0 - this.offset.relative.top - this.offset.parent.top,
				$(o.containment == 'document' ? document : window).width() - this.offset.relative.left - this.offset.parent.left - this.helperProportions.width - this.margins.left - (parseInt(this.element.css("marginRight"), 10) || 0),
				($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.offset.relative.top - this.offset.parent.top - this.helperProportions.height - this.margins.top - (parseInt(this.element.css("marginBottom"), 10) || 0)
			];

                    if (!(/^(document|window|parent)$/).test(o.containment)) {
                        var ce = $(o.containment)[0];
                        var co = $(o.containment).offset();

                        this.containment = [
					co.left + (parseInt($(ce).css("borderLeftWidth"), 10) || 0) - this.offset.relative.left - this.offset.parent.left,
					co.top + (parseInt($(ce).css("borderTopWidth"), 10) || 0) - this.offset.relative.top - this.offset.parent.top,
					co.left + Math.max(ce.scrollWidth, ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"), 10) || 0) - this.offset.relative.left - this.offset.parent.left - this.helperProportions.width - this.margins.left - (parseInt(this.element.css("marginRight"), 10) || 0),
					co.top + Math.max(ce.scrollHeight, ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"), 10) || 0) - this.offset.relative.top - this.offset.parent.top - this.helperProportions.height - this.margins.top - (parseInt(this.element.css("marginBottom"), 10) || 0)
				];
                    }
                }

                //Call plugins and callbacks
                this.propagate("start", e);

                this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() }; //Recache the helper size
                if ($.ui.ddmanager && !o.dropBehaviour) $.ui.ddmanager.prepareOffsets(this, e);

                this.helper.addClass("ui-draggable-dragging");
                this.mouseDrag(e); //Execute the drag once - this causes the helper not to be visible before getting its correct position
                return true;
            },
            convertPositionTo: function(d, pos) {
                if (!pos) pos = this.position;
                var mod = d == "absolute" ? 1 : -1;
                return {
                    top: (
				pos.top																	// the calculated relative position
				+ this.offset.relative.top * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
				+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
				- (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollTop) * mod	// The offsetParent's scroll position, not if the element is fixed
				+ (this.cssPosition == "fixed" ? $(document).scrollTop() : 0) * mod
				+ this.margins.top * mod												//Add the margin (you don't want the margin counting in intersection methods)
			),
                    left: (
				pos.left																// the calculated relative position
				+ this.offset.relative.left * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
				+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
				- (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollLeft) * mod	// The offsetParent's scroll position, not if the element is fixed
				+ (this.cssPosition == "fixed" ? $(document).scrollLeft() : 0) * mod
				+ this.margins.left * mod												//Add the margin (you don't want the margin counting in intersection methods)
			)
                };
            },
            generatePosition: function(e) {

                var o = this.options;
                var position = {
                    top: (
				e.pageY																	// The absolute mouse position
				- this.offset.click.top													// Click offset (relative to the element)
				- this.offset.relative.top												// Only for relative positioned nodes: Relative offset from element to offset parent
				- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
				+ (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollTop)	// The offsetParent's scroll position, not if the element is fixed
				- (this.cssPosition == "fixed" ? $(document).scrollTop() : 0)
			),
                    left: (
				e.pageX																	// The absolute mouse position
				- this.offset.click.left												// Click offset (relative to the element)
				- this.offset.relative.left												// Only for relative positioned nodes: Relative offset from element to offset parent
				- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
				+ (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollLeft)	// The offsetParent's scroll position, not if the element is fixed
				- (this.cssPosition == "fixed" ? $(document).scrollLeft() : 0)
			)
                };

                if (!this.originalPosition) return position; 									//If we are not dragging yet, we won't check for options

                /*
                * - Position constraining -
                * Constrain the position to a mix of grid, containment.
                */
                if (this.containment) {
                    if (position.left < this.containment[0]) position.left = this.containment[0];
                    if (position.top < this.containment[1]) position.top = this.containment[1];
                    if (position.left > this.containment[2]) position.left = this.containment[2];
                    if (position.top > this.containment[3]) position.top = this.containment[3];
                }

                if (o.grid) {
                    var top = this.originalPosition.top + Math.round((position.top - this.originalPosition.top) / o.grid[1]) * o.grid[1];
                    position.top = this.containment ? (!(top < this.containment[1] || top > this.containment[3]) ? top : (!(top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;

                    var left = this.originalPosition.left + Math.round((position.left - this.originalPosition.left) / o.grid[0]) * o.grid[0];
                    position.left = this.containment ? (!(left < this.containment[0] || left > this.containment[2]) ? left : (!(left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
                }

                return position;
            },
            mouseDrag: function(e) {

                //Compute the helpers position
                this.position = this.generatePosition(e);
                this.positionAbs = this.convertPositionTo("absolute");

                //Call plugins and callbacks and use the resulting position if something is returned		
                this.position = this.propagate("drag", e) || this.position;

                if (!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left + 'px';
                if (!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top + 'px';
                if ($.ui.ddmanager) $.ui.ddmanager.drag(this, e);

                return false;
            },
            mouseStop: function(e) {

                //If we are using droppables, inform the manager about the drop
                var dropped = false;
                if ($.ui.ddmanager && !this.options.dropBehaviour)
                    var dropped = $.ui.ddmanager.drop(this, e);

                if ((this.options.revert == "invalid" && !dropped) || (this.options.revert == "valid" && dropped) || this.options.revert === true) {
                    var self = this;
                    $(this.helper).animate(this.originalPosition, parseInt(this.options.revert, 10) || 500, function() {
                        self.propagate("stop", e);
                        self.clear();
                    });
                } else {
                    this.propagate("stop", e);
                    this.clear();
                }

                return false;
            },
            clear: function() {
                this.helper.removeClass("ui-draggable-dragging");
                if (this.options.helper != 'original' && !this.cancelHelperRemoval) this.helper.remove();
                //if($.ui.ddmanager) $.ui.ddmanager.current = null;
                this.helper = null;
                this.cancelHelperRemoval = false;
            },

            // From now on bulk stuff - mainly helpers
            plugins: {},
            uiHash: function(e) {
                return {
                    helper: this.helper,
                    position: this.position,
                    absolutePosition: this.positionAbs,
                    options: this.options
                };
            },
            propagate: function(n, e) {
                $.ui.plugin.call(this, n, [e, this.uiHash()]);
                if (n == "drag") this.positionAbs = this.convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins
                return this.element.triggerHandler(n == "drag" ? n : "drag" + n, [e, this.uiHash()], this.options[n]);
            },
            destroy: function() {
                if (!this.element.data('draggable')) return;
                this.element.removeData("draggable").unbind(".draggable").removeClass('ui-draggable');
                this.mouseDestroy();
            }
        }));

        $.extend($.ui.draggable, {
            defaults: {
                appendTo: "parent",
                axis: false,
                cancel: ":input",
                delay: 0,
                distance: 1,
                helper: "original"
            }
        });

        $.ui.plugin.add("draggable", "cursor", {
            start: function(e, ui) {
                var t = $('body');
                if (t.css("cursor")) ui.options._cursor = t.css("cursor");
                t.css("cursor", ui.options.cursor);
            },
            stop: function(e, ui) {
                if (ui.options._cursor) $('body').css("cursor", ui.options._cursor);
            }
        });

        $.ui.plugin.add("draggable", "zIndex", {
            start: function(e, ui) {
                var t = $(ui.helper);
                if (t.css("zIndex")) ui.options._zIndex = t.css("zIndex");
                t.css('zIndex', ui.options.zIndex);
            },
            stop: function(e, ui) {
                if (ui.options._zIndex) $(ui.helper).css('zIndex', ui.options._zIndex);
            }
        });

        $.ui.plugin.add("draggable", "opacity", {
            start: function(e, ui) {
                var t = $(ui.helper);
                if (t.css("opacity")) ui.options._opacity = t.css("opacity");
                t.css('opacity', ui.options.opacity);
            },
            stop: function(e, ui) {
                if (ui.options._opacity) $(ui.helper).css('opacity', ui.options._opacity);
            }
        });

        $.ui.plugin.add("draggable", "iframeFix", {
            start: function(e, ui) {
                $(ui.options.iframeFix === true ? "iframe" : ui.options.iframeFix).each(function() {
                    $('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')
			.css({
			    width: this.offsetWidth + "px", height: this.offsetHeight + "px",
			    position: "absolute", opacity: "0.001", zIndex: 1000
			})
			.css($(this).offset())
			.appendTo("body");
                });
            },
            stop: function(e, ui) {
                $("div.DragDropIframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers	
            }
        });

        $.ui.plugin.add("draggable", "scroll", {
            start: function(e, ui) {
                var o = ui.options;
                var i = $(this).data("draggable");
                o.scrollSensitivity = o.scrollSensitivity || 20;
                o.scrollSpeed = o.scrollSpeed || 20;

                i.overflowY = function(el) {
                    do { if (/auto|scroll/.test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-y'))) return el; el = el.parent(); } while (el[0].parentNode);
                    return $(document);
                } (this);
                i.overflowX = function(el) {
                    do { if (/auto|scroll/.test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-x'))) return el; el = el.parent(); } while (el[0].parentNode);
                    return $(document);
                } (this);

                if (i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') i.overflowYOffset = i.overflowY.offset();
                if (i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') i.overflowXOffset = i.overflowX.offset();

            },
            drag: function(e, ui) {

                var o = ui.options;
                var i = $(this).data("draggable");

                if (i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') {
                    if ((i.overflowYOffset.top + i.overflowY[0].offsetHeight) - e.pageY < o.scrollSensitivity)
                        i.overflowY[0].scrollTop = i.overflowY[0].scrollTop + o.scrollSpeed;
                    if (e.pageY - i.overflowYOffset.top < o.scrollSensitivity)
                        i.overflowY[0].scrollTop = i.overflowY[0].scrollTop - o.scrollSpeed;

                } else {
                    if (e.pageY - $(document).scrollTop() < o.scrollSensitivity)
                        $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
                    if ($(window).height() - (e.pageY - $(document).scrollTop()) < o.scrollSensitivity)
                        $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
                }

                if (i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') {
                    if ((i.overflowXOffset.left + i.overflowX[0].offsetWidth) - e.pageX < o.scrollSensitivity)
                        i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft + o.scrollSpeed;
                    if (e.pageX - i.overflowXOffset.left < o.scrollSensitivity)
                        i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft - o.scrollSpeed;
                } else {
                    if (e.pageX - $(document).scrollLeft() < o.scrollSensitivity)
                        $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
                    if ($(window).width() - (e.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
                        $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
                }

            }
        });

        $.ui.plugin.add("draggable", "snap", {
            start: function(e, ui) {

                var inst = $(this).data("draggable");
                inst.snapElements = [];
                $(ui.options.snap === true ? '.ui-draggable' : ui.options.snap).each(function() {
                    var $t = $(this); var $o = $t.offset();
                    if (this != inst.element[0]) inst.snapElements.push({
                        item: this,
                        width: $t.outerWidth(), height: $t.outerHeight(),
                        top: $o.top, left: $o.left
                    });
                });

            },
            drag: function(e, ui) {

                var inst = $(this).data("draggable");
                var d = ui.options.snapTolerance || 20;
                var x1 = ui.absolutePosition.left, x2 = x1 + inst.helperProportions.width,
			y1 = ui.absolutePosition.top, y2 = y1 + inst.helperProportions.height;

                for (var i = inst.snapElements.length - 1; i >= 0; i--) {

                    var l = inst.snapElements[i].left, r = l + inst.snapElements[i].width,
				t = inst.snapElements[i].top, b = t + inst.snapElements[i].height;

                    //Yes, I know, this is insane ;)
                    if (!((l - d < x1 && x1 < r + d && t - d < y1 && y1 < b + d) || (l - d < x1 && x1 < r + d && t - d < y2 && y2 < b + d) || (l - d < x2 && x2 < r + d && t - d < y1 && y1 < b + d) || (l - d < x2 && x2 < r + d && t - d < y2 && y2 < b + d))) continue;

                    if (ui.options.snapMode != 'inner') {
                        var ts = Math.abs(t - y2) <= 20;
                        var bs = Math.abs(b - y1) <= 20;
                        var ls = Math.abs(l - x2) <= 20;
                        var rs = Math.abs(r - x1) <= 20;
                        if (ts) ui.position.top = inst.convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
                        if (bs) ui.position.top = inst.convertPositionTo("relative", { top: b, left: 0 }).top;
                        if (ls) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
                        if (rs) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: r }).left;
                    }

                    if (ui.options.snapMode != 'outer') {
                        var ts = Math.abs(t - y1) <= 20;
                        var bs = Math.abs(b - y2) <= 20;
                        var ls = Math.abs(l - x1) <= 20;
                        var rs = Math.abs(r - x2) <= 20;
                        if (ts) ui.position.top = inst.convertPositionTo("relative", { top: t, left: 0 }).top;
                        if (bs) ui.position.top = inst.convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
                        if (ls) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: l }).left;
                        if (rs) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
                    }

                };
            }
        });

        $.ui.plugin.add("draggable", "connectToSortable", {
            start: function(e, ui) {

                var inst = $(this).data("draggable");
                inst.sortables = [];
                $(ui.options.connectToSortable).each(function() {
                    if ($.data(this, 'sortable')) {
                        var sortable = $.data(this, 'sortable');
                        inst.sortables.push({
                            instance: sortable,
                            shouldRevert: sortable.options.revert
                        });
                        sortable.refreshItems(); //Do a one-time refresh at start to refresh the containerCache	
                        sortable.propagate("activate", e, inst);
                    }
                });

            },
            stop: function(e, ui) {

                //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
                var inst = $(this).data("draggable");

                $.each(inst.sortables, function() {
                    if (this.instance.isOver) {
                        this.instance.isOver = 0;
                        inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
                        this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
                        if (this.shouldRevert) this.instance.options.revert = true; //revert here
                        this.instance.mouseStop(e);

                        //Also propagate receive event, since the sortable is actually receiving a element
                        this.instance.element.triggerHandler("sortreceive", [e, $.extend(this.instance.ui(), { sender: inst.element })], this.instance.options["receive"]);

                        this.instance.options.helper = this.instance.options._helper;
                    } else {
                        this.instance.propagate("deactivate", e, inst);
                    }

                });

            },
            drag: function(e, ui) {

                var inst = $(this).data("draggable"), self = this;

                var checkPos = function(o) {

                    var l = o.left, r = l + o.width,
				t = o.top, b = t + o.height;

                    return (l < (this.positionAbs.left + this.offset.click.left) && (this.positionAbs.left + this.offset.click.left) < r
					&& t < (this.positionAbs.top + this.offset.click.top) && (this.positionAbs.top + this.offset.click.top) < b);
                };

                $.each(inst.sortables, function(i) {

                    if (checkPos.call(inst, this.instance.containerCache)) {

                        //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
                        if (!this.instance.isOver) {
                            this.instance.isOver = 1;

                            //Now we fake the start of dragging for the sortable instance,
                            //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
                            //We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
                            this.instance.currentItem = $(self).clone().appendTo(this.instance.element).data("sortable-item", true);
                            this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
                            this.instance.options.helper = function() { return ui.helper[0]; };

                            e.target = this.instance.currentItem[0];
                            this.instance.mouseCapture(e, true);
                            this.instance.mouseStart(e, true, true);

                            //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
                            this.instance.offset.click.top = inst.offset.click.top;
                            this.instance.offset.click.left = inst.offset.click.left;
                            this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
                            this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;

                            inst.propagate("toSortable", e);

                        }

                        //Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
                        if (this.instance.currentItem) this.instance.mouseDrag(e);

                    } else {

                        //If it doesn't intersect with the sortable, and it intersected before,
                        //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
                        if (this.instance.isOver) {
                            this.instance.isOver = 0;
                            this.instance.cancelHelperRemoval = true;
                            this.instance.options.revert = false; //No revert here
                            this.instance.mouseStop(e, true);
                            this.instance.options.helper = this.instance.options._helper;

                            //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
                            this.instance.currentItem.remove();
                            if (this.instance.placeholder) this.instance.placeholder.remove();

                            inst.propagate("fromSortable", e);
                        }

                    };

                });

            }
        });

        $.ui.plugin.add("draggable", "stack", {
            start: function(e, ui) {
                var group = $.makeArray($(ui.options.stack.group)).sort(function(a, b) {
                    return (parseInt($(a).css("zIndex"), 10) || ui.options.stack.min) - (parseInt($(b).css("zIndex"), 10) || ui.options.stack.min);
                });

                $(group).each(function(i) {
                    this.style.zIndex = ui.options.stack.min + i;
                });

                this[0].style.zIndex = ui.options.stack.min + group.length;
            }
        });

    })(jQuery);

    /*
    * jQuery UI Resizable
    *
    * Copyright (c) 2008 Paul Bakaus
    * Dual licensed under the MIT (MIT-LICENSE.txt)
    * and GPL (GPL-LICENSE.txt) licenses.
    * 
    * http://docs.jquery.com/UI/Resizables
    *
    * Depends:
    *	ui.core.js
    */
    (function($) {

        $.widget("ui.resizable", $.extend({}, $.ui.mouse, {
            init: function() {

                var self = this, o = this.options;

                var elpos = this.element.css('position');

                this.originalElement = this.element;

                // simulate .ui-resizable { position: relative; }
                this.element.addClass("ui-resizable").css({ position: /static/.test(elpos) ? 'relative' : elpos });

                $.extend(o, {
                    _aspectRatio: !!(o.aspectRatio),
                    helper: o.helper || o.ghost || o.animate ? o.helper || 'proxy' : null,
                    knobHandles: o.knobHandles === true ? 'ui-resizable-knob-handle' : o.knobHandles
                });

                //Default Theme
                var aBorder = '1px solid #222';

                o.defaultTheme = {
                    'ui-resizable': { display: 'block' },
                    'ui-resizable-handle': { position: 'absolute', background: '#222', fontSize: '0.1px' },
                    'ui-resizable-n': { cursor: 'n-resize', height: '4px', left: '0px', right: '0px', borderTop: aBorder },
                    'ui-resizable-s': { cursor: 's-resize', height: '4px', left: '0px', right: '0px', borderBottom: aBorder },
                    'ui-resizable-e': { cursor: 'e-resize', width: '4px', top: '0px', bottom: '0px', borderRight: aBorder },
                    'ui-resizable-w': { cursor: 'w-resize', width: '4px', top: '0px', bottom: '0px', borderLeft: aBorder },
                    'ui-resizable-se': { cursor: 'se-resize', width: '4px', height: '4px', borderRight: aBorder, borderBottom: aBorder },
                    'ui-resizable-sw': { cursor: 'sw-resize', width: '4px', height: '4px', borderBottom: aBorder, borderLeft: aBorder },
                    'ui-resizable-ne': { cursor: 'ne-resize', width: '4px', height: '4px', borderRight: aBorder, borderTop: aBorder },
                    'ui-resizable-nw': { cursor: 'nw-resize', width: '4px', height: '4px', borderLeft: aBorder, borderTop: aBorder }
                };

                o.knobTheme = {
                    'ui-resizable-handle': { background: '#000', border: '1px solid #000', height: '8px', width: '8px' },
                    'ui-resizable-n': { cursor: 'n-resize', top: '0px', left: '45%' },
                    'ui-resizable-s': { cursor: 's-resize', bottom: '0px', left: '45%' },
                    'ui-resizable-e': { cursor: 'e-resize', right: '0px', top: '45%' },
                    'ui-resizable-w': { cursor: 'w-resize', left: '0px', top: '45%' },
                    'ui-resizable-se': { cursor: 'se-resize', right: '0px', bottom: '0px' },
                    'ui-resizable-sw': { cursor: 'sw-resize', left: '0px', bottom: '0px' },
                    'ui-resizable-nw': { cursor: 'nw-resize', left: '0px', top: '0px' },
                    'ui-resizable-ne': { cursor: 'ne-resize', right: '0px', top: '0px' }
                };

                o._nodeName = this.element[0].nodeName;

                //Wrap the element if it cannot hold child nodes
                if (o._nodeName.match(/canvas|textarea|input|select|button|img/i)) {
                    var el = this.element;

                    //Opera fixing relative position
                    if (/relative/.test(el.css('position')) && $.browser.opera)
                        el.css({ position: 'relative', top: 'auto', left: 'auto' });

                    //Create a wrapper element and set the wrapper to the new current internal element
                    el.wrap(
				$('<div class="ui-wrapper"	style="overflow: hidden;"></div>').css({
				    position: el.css('position'),
				    width: el.outerWidth(),
				    height: el.outerHeight(),
				    top: el.css('top'),
				    left: el.css('left')
				})
			);

                    var oel = this.element; this.element = this.element.parent();

                    // store instance on wrapper
                    this.element.data('resizable', this);

                    //Move margins to the wrapper
                    this.element.css({ marginLeft: oel.css("marginLeft"), marginTop: oel.css("marginTop"),
                        marginRight: oel.css("marginRight"), marginBottom: oel.css("marginBottom")
                    });

                    oel.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0 });

                    //Prevent Safari textarea resize
                    if ($.browser.safari && o.preventDefault) oel.css('resize', 'none');

                    o.proportionallyResize = oel.css({ position: 'static', zoom: 1, display: 'block' });

                    // avoid IE jump
                    this.element.css({ margin: oel.css('margin') });

                    // fix handlers offset
                    this._proportionallyResize();
                }

                if (!o.handles) o.handles = !$('.ui-resizable-handle', this.element).length ? "e,s,se" : { n: '.ui-resizable-n', e: '.ui-resizable-e', s: '.ui-resizable-s', w: '.ui-resizable-w', se: '.ui-resizable-se', sw: '.ui-resizable-sw', ne: '.ui-resizable-ne', nw: '.ui-resizable-nw' };
                if (o.handles.constructor == String) {

                    o.zIndex = o.zIndex || 1000;

                    if (o.handles == 'all') o.handles = 'n,e,s,w,se,sw,ne,nw';

                    var n = o.handles.split(","); o.handles = {};

                    // insertions are applied when don't have theme loaded
                    var insertionsDefault = {
                        handle: 'position: absolute; display: none; overflow:hidden;',
                        n: 'top: 0pt; width:100%;',
                        e: 'right: 0pt; height:100%;',
                        s: 'bottom: 0pt; width:100%;',
                        w: 'left: 0pt; height:100%;',
                        se: 'bottom: 0pt; right: 0px;',
                        sw: 'bottom: 0pt; left: 0px;',
                        ne: 'top: 0pt; right: 0px;',
                        nw: 'top: 0pt; left: 0px;'
                    };

                    for (var i = 0; i < n.length; i++) {
                        var handle = $.trim(n[i]), dt = o.defaultTheme, hname = 'ui-resizable-' + handle, loadDefault = !$.ui.css(hname) && !o.knobHandles, userKnobClass = $.ui.css('ui-resizable-knob-handle'),
							allDefTheme = $.extend(dt[hname], dt['ui-resizable-handle']), allKnobTheme = $.extend(o.knobTheme[hname], !userKnobClass ? o.knobTheme['ui-resizable-handle'] : {});

                        // increase zIndex of sw, se, ne, nw axis
                        var applyZIndex = /sw|se|ne|nw/.test(handle) ? { zIndex: ++o.zIndex} : {};

                        var defCss = (loadDefault ? insertionsDefault[handle] : ''),
					axis = $(['<div class="ui-resizable-handle ', hname, '" style="', defCss, insertionsDefault.handle, '"></div>'].join('')).css(applyZIndex);
                        o.handles[handle] = '.ui-resizable-' + handle;

                        this.element.append(
                        //Theme detection, if not loaded, load o.defaultTheme
					axis.css(loadDefault ? allDefTheme : {})
                        // Load the knobHandle css, fix width, height, top, left...
						.css(o.knobHandles ? allKnobTheme : {}).addClass(o.knobHandles ? 'ui-resizable-knob-handle' : '').addClass(o.knobHandles)
				);
                    }

                    if (o.knobHandles) this.element.addClass('ui-resizable-knob').css(!$.ui.css('ui-resizable-knob') ? { /*border: '1px #fff dashed'*/} : {});
                }

                this._renderAxis = function(target) {
                    target = target || this.element;

                    for (var i in o.handles) {
                        if (o.handles[i].constructor == String)
                            o.handles[i] = $(o.handles[i], this.element).show();

                        if (o.transparent)
                            o.handles[i].css({ opacity: 0 });

                        //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
                        if (this.element.is('.ui-wrapper') &&
					o._nodeName.match(/textarea|input|select|button/i)) {

                            var axis = $(o.handles[i], this.element), padWrapper = 0;

                            //Checking the correct pad and border
                            padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();

                            //The padding type i have to apply...
                            var padPos = ['padding',
						/ne|nw|n/.test(i) ? 'Top' :
						/se|sw|s/.test(i) ? 'Bottom' :
						/^e$/.test(i) ? 'Right' : 'Left'].join("");

                            if (!o.transparent)
                                target.css(padPos, padWrapper);

                            this._proportionallyResize();
                        }
                        if (!$(o.handles[i]).length) continue;
                    }
                };

                this._renderAxis(this.element);
                o._handles = $('.ui-resizable-handle', self.element);

                if (o.disableSelection)
                    o._handles.each(function(i, e) { $.ui.disableSelection(e); });

                //Matching axis name
                o._handles.mouseover(function() {
                    if (!o.resizing) {
                        if (this.className)
                            var axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
                        //Axis, default = se
                        self.axis = o.axis = axis && axis[1] ? axis[1] : 'se';
                    }
                });

                //If we want to auto hide the elements
                if (o.autoHide) {
                    o._handles.hide();
                    $(self.element).addClass("ui-resizable-autohide").hover(function() {
                        $(this).removeClass("ui-resizable-autohide");
                        o._handles.show();
                    },
			function() {
			    if (!o.resizing) {
			        $(this).addClass("ui-resizable-autohide");
			        o._handles.hide();
			    }
			});
                }

                this.mouseInit();
            },
            plugins: {},
            ui: function() {
                return {
                    originalElement: this.originalElement,
                    element: this.element,
                    helper: this.helper,
                    position: this.position,
                    size: this.size,
                    options: this.options,
                    originalSize: this.originalSize,
                    originalPosition: this.originalPosition
                };
            },
            propagate: function(n, e) {
                $.ui.plugin.call(this, n, [e, this.ui()]);
                if (n != "resize") this.element.triggerHandler(["resize", n].join(""), [e, this.ui()], this.options[n]);
            },
            destroy: function() {
                var el = this.element, wrapped = el.children(".ui-resizable").get(0);

                this.mouseDestroy();

                var _destroy = function(exp) {
                    $(exp).removeClass("ui-resizable ui-resizable-disabled")
				.removeData("resizable").unbind(".resizable").find('.ui-resizable-handle').remove();
                };

                _destroy(el);

                if (el.is('.ui-wrapper') && wrapped) {
                    el.parent().append(
				$(wrapped).css({
				    position: el.css('position'),
				    width: el.outerWidth(),
				    height: el.outerHeight(),
				    top: el.css('top'),
				    left: el.css('left')
				})
			).end().remove();

                    _destroy(wrapped);
                }
            },
            mouseStart: function(e) {
                if (this.options.disabled) return false;

                var handle = false;
                for (var i in this.options.handles) {
                    if ($(this.options.handles[i])[0] == e.target) handle = true;
                }
                if (!handle) return false;

                var o = this.options, iniPos = this.element.position(), el = this.element,
			num = function(v) { return parseInt(v, 10) || 0; }, ie6 = $.browser.msie && $.browser.version < 7;
                o.resizing = true;
                o.documentScroll = { top: $(document).scrollTop(), left: $(document).scrollLeft() };

                // bugfix #1749
                if (el.is('.ui-draggable') || (/absolute/).test(el.css('position'))) {

                    // sOffset decides if document scrollOffset will be added to the top/left of the resizable element
                    var sOffset = $.browser.msie && !o.containment && (/absolute/).test(el.css('position')) && !(/relative/).test(el.parent().css('position'));
                    var dscrollt = sOffset ? o.documentScroll.top : 0, dscrolll = sOffset ? o.documentScroll.left : 0;

                    el.css({ position: 'absolute', top: (iniPos.top + dscrollt), left: (iniPos.left + dscrolll) });
                }

                //Opera fixing relative position
                if ($.browser.opera && /relative/.test(el.css('position')))
                    el.css({ position: 'relative', top: 'auto', left: 'auto' });

                this._renderProxy();

                var curleft = num(this.helper.css('left')), curtop = num(this.helper.css('top'));

                if (o.containment) {
                    curleft += $(o.containment).scrollLeft() || 0;
                    curtop += $(o.containment).scrollTop() || 0;
                }

                //Store needed variables
                this.offset = this.helper.offset();
                this.position = { left: curleft, top: curtop };
                this.size = o.helper || ie6 ? { width: el.outerWidth(), height: el.outerHeight()} : { width: el.width(), height: el.height() };
                this.originalSize = o.helper || ie6 ? { width: el.outerWidth(), height: el.outerHeight()} : { width: el.width(), height: el.height() };
                this.originalPosition = { left: curleft, top: curtop };
                this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
                this.originalMousePosition = { left: e.pageX, top: e.pageY };

                //Aspect Ratio
                o.aspectRatio = (typeof o.aspectRatio == 'number') ? o.aspectRatio : ((this.originalSize.height / this.originalSize.width) || 1);

                if (o.preserveCursor)
                    $('body').css('cursor', this.axis + '-resize');

                this.propagate("start", e);
                return true;
            },
            mouseDrag: function(e) {

                //Increase performance, avoid regex
                var el = this.helper, o = this.options, props = {},
			self = this, smp = this.originalMousePosition, a = this.axis;

                var dx = (e.pageX - smp.left) || 0, dy = (e.pageY - smp.top) || 0;
                var trigger = this._change[a];
                if (!trigger) return false;

                // Calculate the attrs that will be change
                var data = trigger.apply(this, [e, dx, dy]), ie6 = $.browser.msie && $.browser.version < 7, csdif = this.sizeDiff;

                if (o._aspectRatio || e.shiftKey)
                    data = this._updateRatio(data, e);

                data = this._respectSize(data, e);

                // plugins callbacks need to be called first
                this.propagate("resize", e);

                el.css({
                    top: this.position.top + "px", left: this.position.left + "px",
                    width: this.size.width + "px", height: this.size.height + "px"
                });

                if (!o.helper && o.proportionallyResize)
                    this._proportionallyResize();

                this._updateCache(data);

                // calling the user callback at the end
                this.element.triggerHandler("resize", [e, this.ui()], this.options["resize"]);

                return false;
            },
            mouseStop: function(e) {

                this.options.resizing = false;
                var o = this.options, num = function(v) { return parseInt(v, 10) || 0; }, self = this;

                if (o.helper) {
                    var pr = o.proportionallyResize, ista = pr && (/textarea/i).test(pr.get(0).nodeName),
						soffseth = ista && $.ui.hasScroll(pr.get(0), 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
							soffsetw = ista ? 0 : self.sizeDiff.width;

                    var s = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
				left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null,
				top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null;

                    if (!o.animate)
                        this.element.css($.extend(s, { top: top, left: left }));

                    if (o.helper && !o.animate) this._proportionallyResize();
                }

                if (o.preserveCursor)
                    $('body').css('cursor', 'auto');

                this.propagate("stop", e);

                if (o.helper) this.helper.remove();

                return false;
            },
            _updateCache: function(data) {
                var o = this.options;
                this.offset = this.helper.offset();
                if (data.left) this.position.left = data.left;
                if (data.top) this.position.top = data.top;
                if (data.height) this.size.height = data.height;
                if (data.width) this.size.width = data.width;
            },
            _updateRatio: function(data, e) {
                var o = this.options, cpos = this.position, csize = this.size, a = this.axis;

                if (data.height) data.width = (csize.height / o.aspectRatio);
                else if (data.width) data.height = (csize.width * o.aspectRatio);

                if (a == 'sw') {
                    data.left = cpos.left + (csize.width - data.width);
                    data.top = null;
                }
                if (a == 'nw') {
                    data.top = cpos.top + (csize.height - data.height);
                    data.left = cpos.left + (csize.width - data.width);
                }

                return data;
            },
            _respectSize: function(data, e) {

                var el = this.helper, o = this.options, pRatio = o._aspectRatio || e.shiftKey, a = this.axis,
				ismaxw = data.width && o.maxWidth && o.maxWidth < data.width, ismaxh = data.height && o.maxHeight && o.maxHeight < data.height,
					isminw = data.width && o.minWidth && o.minWidth > data.width, isminh = data.height && o.minHeight && o.minHeight > data.height;

                if (isminw) data.width = o.minWidth;
                if (isminh) data.height = o.minHeight;
                if (ismaxw) data.width = o.maxWidth;
                if (ismaxh) data.height = o.maxHeight;

                var dw = this.originalPosition.left + this.originalSize.width, dh = this.position.top + this.size.height;
                var cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);

                if (isminw && cw) data.left = dw - o.minWidth;
                if (ismaxw && cw) data.left = dw - o.maxWidth;
                if (isminh && ch) data.top = dh - o.minHeight;
                if (ismaxh && ch) data.top = dh - o.maxHeight;

                // fixing jump error on top/left - bug #2330
                var isNotwh = !data.width && !data.height;
                if (isNotwh && !data.left && data.top) data.top = null;
                else if (isNotwh && !data.top && data.left) data.left = null;

                return data;
            },
            _proportionallyResize: function() {
                var o = this.options;
                if (!o.proportionallyResize) return;
                var prel = o.proportionallyResize, el = this.helper || this.element;

                if (!o.borderDif) {
                    var b = [prel.css('borderTopWidth'), prel.css('borderRightWidth'), prel.css('borderBottomWidth'), prel.css('borderLeftWidth')],
				p = [prel.css('paddingTop'), prel.css('paddingRight'), prel.css('paddingBottom'), prel.css('paddingLeft')];

                    o.borderDif = $.map(b, function(v, i) {
                        var border = parseInt(v, 10) || 0, padding = parseInt(p[i], 10) || 0;
                        return border + padding;
                    });
                }
                prel.css({
                    height: (el.height() - o.borderDif[0] - o.borderDif[2]) + "px",
                    width: (el.width() - o.borderDif[1] - o.borderDif[3]) + "px"
                });
            },
            _renderProxy: function() {
                var el = this.element, o = this.options;
                this.elementOffset = el.offset();

                if (o.helper) {
                    this.helper = this.helper || $('<div style="overflow:hidden;"></div>');

                    // fix ie6 offset
                    var ie6 = $.browser.msie && $.browser.version < 7, ie6offset = (ie6 ? 1 : 0),
			pxyoffset = (ie6 ? 2 : -1);

                    this.helper.addClass(o.helper).css({
                        width: el.outerWidth() + pxyoffset,
                        height: el.outerHeight() + pxyoffset,
                        position: 'absolute',
                        left: this.elementOffset.left - ie6offset + 'px',
                        top: this.elementOffset.top - ie6offset + 'px',
                        zIndex: ++o.zIndex
                    });

                    this.helper.appendTo("body");

                    if (o.disableSelection)
                        $.ui.disableSelection(this.helper.get(0));

                } else {
                    this.helper = el;
                }
            },
            _change: {
                e: function(e, dx, dy) {
                    return { width: this.originalSize.width + dx };
                },
                w: function(e, dx, dy) {
                    var o = this.options, cs = this.originalSize, sp = this.originalPosition;
                    return { left: sp.left + dx, width: cs.width - dx };
                },
                n: function(e, dx, dy) {
                    var o = this.options, cs = this.originalSize, sp = this.originalPosition;
                    return { top: sp.top + dy, height: cs.height - dy };
                },
                s: function(e, dx, dy) {
                    return { height: this.originalSize.height + dy };
                },
                se: function(e, dx, dy) {
                    return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [e, dx, dy]));
                },
                sw: function(e, dx, dy) {
                    return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [e, dx, dy]));
                },
                ne: function(e, dx, dy) {
                    return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [e, dx, dy]));
                },
                nw: function(e, dx, dy) {
                    return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [e, dx, dy]));
                }
            }
        }));

        $.extend($.ui.resizable, {
            defaults: {
                cancel: ":input",
                distance: 1,
                delay: 0,
                preventDefault: true,
                transparent: false,
                minWidth: 10,
                minHeight: 10,
                aspectRatio: false,
                disableSelection: true,
                preserveCursor: true,
                autoHide: false,
                knobHandles: false
            }
        });

        /*
        * Resizable Extensions
        */

        $.ui.plugin.add("resizable", "containment", {

            start: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"), el = self.element;
                var oc = o.containment, ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
                if (!ce) return;

                self.containerElement = $(ce);

                if (/document/.test(oc) || oc == document) {
                    self.containerOffset = { left: 0, top: 0 };
                    self.containerPosition = { left: 0, top: 0 };

                    self.parentData = {
                        element: $(document), left: 0, top: 0,
                        width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
                    };
                }


                // i'm a node, so compute top, left, right, bottom
                else {
                    self.containerOffset = $(ce).offset();
                    self.containerPosition = $(ce).position();
                    self.containerSize = { height: $(ce).innerHeight(), width: $(ce).innerWidth() };

                    var co = self.containerOffset, ch = self.containerSize.height, cw = self.containerSize.width,
						width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw), height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);

                    self.parentData = {
                        element: ce, left: co.left, top: co.top, width: width, height: height
                    };
                }
            },

            resize: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"),
				ps = self.containerSize, co = self.containerOffset, cs = self.size, cp = self.position,
				pRatio = o._aspectRatio || e.shiftKey, cop = { top: 0, left: 0 }, ce = self.containerElement;

                if (ce[0] != document && /static/.test(ce.css('position')))
                    cop = self.containerPosition;

                if (cp.left < (o.helper ? co.left : cop.left)) {
                    self.size.width = self.size.width + (o.helper ? (self.position.left - co.left) : (self.position.left - cop.left));
                    if (pRatio) self.size.height = self.size.width * o.aspectRatio;
                    self.position.left = o.helper ? co.left : cop.left;
                }

                if (cp.top < (o.helper ? co.top : 0)) {
                    self.size.height = self.size.height + (o.helper ? (self.position.top - co.top) : self.position.top);
                    if (pRatio) self.size.width = self.size.height / o.aspectRatio;
                    self.position.top = o.helper ? co.top : 0;
                }

                var woset = (o.helper ? self.offset.left - co.left : (self.position.left - cop.left)) + self.sizeDiff.width,
					hoset = (o.helper ? self.offset.top - co.top : self.position.top) + self.sizeDiff.height;

                if (woset + self.size.width >= self.parentData.width) {
                    self.size.width = self.parentData.width - woset;
                    if (pRatio) self.size.height = self.size.width * o.aspectRatio;
                }

                if (hoset + self.size.height >= self.parentData.height) {
                    self.size.height = self.parentData.height - hoset;
                    if (pRatio) self.size.width = self.size.height / o.aspectRatio;
                }
            },

            stop: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"), cp = self.position,
				co = self.containerOffset, cop = self.containerPosition, ce = self.containerElement;

                var helper = $(self.helper), ho = helper.offset(), w = helper.innerWidth(), h = helper.innerHeight();


                if (o.helper && !o.animate && /relative/.test(ce.css('position')))
                    $(this).css({ left: (ho.left - co.left), top: (ho.top - co.top), width: w, height: h });

                if (o.helper && !o.animate && /static/.test(ce.css('position')))
                    $(this).css({ left: cop.left + (ho.left - co.left), top: cop.top + (ho.top - co.top), width: w, height: h });

            }
        });

        $.ui.plugin.add("resizable", "grid", {

            resize: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"), cs = self.size, os = self.originalSize, op = self.originalPosition, a = self.axis, ratio = o._aspectRatio || e.shiftKey;
                o.grid = typeof o.grid == "number" ? [o.grid, o.grid] : o.grid;
                var ox = Math.round((cs.width - os.width) / (o.grid[0] || 1)) * (o.grid[0] || 1), oy = Math.round((cs.height - os.height) / (o.grid[1] || 1)) * (o.grid[1] || 1);

                if (/^(se|s|e)$/.test(a)) {
                    self.size.width = os.width + ox;
                    self.size.height = os.height + oy;
                }
                else if (/^(ne)$/.test(a)) {
                    self.size.width = os.width + ox;
                    self.size.height = os.height + oy;
                    self.position.top = op.top - oy;
                }
                else if (/^(sw)$/.test(a)) {
                    self.size.width = os.width + ox;
                    self.size.height = os.height + oy;
                    self.position.left = op.left - ox;
                }
                else {
                    self.size.width = os.width + ox;
                    self.size.height = os.height + oy;
                    self.position.top = op.top - oy;
                    self.position.left = op.left - ox;
                }
            }

        });

        $.ui.plugin.add("resizable", "animate", {

            stop: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable");

                var pr = o.proportionallyResize, ista = pr && (/textarea/i).test(pr.get(0).nodeName),
						soffseth = ista && $.ui.hasScroll(pr.get(0), 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
							soffsetw = ista ? 0 : self.sizeDiff.width;

                var style = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
					left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null,
						top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null;

                self.element.animate(
			$.extend(style, top && left ? { top: top, left: left} : {}), {
			    duration: o.animateDuration || "slow", easing: o.animateEasing || "swing",
			    step: function() {

			        var data = {
			            width: parseInt(self.element.css('width'), 10),
			            height: parseInt(self.element.css('height'), 10),
			            top: parseInt(self.element.css('top'), 10),
			            left: parseInt(self.element.css('left'), 10)
			        };

			        if (pr) pr.css({ width: data.width, height: data.height });

			        // propagating resize, and updating values for each animation step
			        self._updateCache(data);
			        self.propagate("animate", e);

			    }
			}
		);
            }

        });

        $.ui.plugin.add("resizable", "ghost", {

            start: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize, cs = self.size;

                if (!pr) self.ghost = self.element.clone();
                else self.ghost = pr.clone();

                self.ghost.css(
			{ opacity: .25, display: 'block', position: 'relative', height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 }
		)
		.addClass('ui-resizable-ghost').addClass(typeof o.ghost == 'string' ? o.ghost : '');

                self.ghost.appendTo(self.helper);

            },

            resize: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize;

                if (self.ghost) self.ghost.css({ position: 'relative', height: self.size.height, width: self.size.width });

            },

            stop: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize;
                if (self.ghost && self.helper) self.helper.get(0).removeChild(self.ghost.get(0));
            }

        });

        $.ui.plugin.add("resizable", "alsoResize", {

            start: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"),

		_store = function(exp) {
		    $(exp).each(function() {
		        $(this).data("resizable-alsoresize", {
		            width: parseInt($(this).width(), 10), height: parseInt($(this).height(), 10),
		            left: parseInt($(this).css('left'), 10), top: parseInt($(this).css('top'), 10)
		        });
		    });
		};

                if (typeof (o.alsoResize) == 'object') {
                    if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
                    else { $.each(o.alsoResize, function(exp, c) { _store(exp); }); }
                } else {
                    _store(o.alsoResize);
                }
            },

            resize: function(e, ui) {
                var o = ui.options, self = $(this).data("resizable"), os = self.originalSize, op = self.originalPosition;

                var delta = {
                    height: (self.size.height - os.height) || 0, width: (self.size.width - os.width) || 0,
                    top: (self.position.top - op.top) || 0, left: (self.position.left - op.left) || 0
                },

		_alsoResize = function(exp, c) {
		    $(exp).each(function() {
		        var start = $(this).data("resizable-alsoresize"), style = {}, css = c && c.length ? c : ['width', 'height', 'top', 'left'];

		        $.each(css || ['width', 'height', 'top', 'left'], function(i, prop) {
		            var sum = (start[prop] || 0) + (delta[prop] || 0);
		            if (sum && sum >= 0)
		                style[prop] = sum || null;
		        });
		        $(this).css(style);
		    });
		};

                if (typeof (o.alsoResize) == 'object') {
                    $.each(o.alsoResize, function(exp, c) { _alsoResize(exp, c); });
                } else {
                    _alsoResize(o.alsoResize);
                }
            },

            stop: function(e, ui) {
                $(this).removeData("resizable-alsoresize-start");
            }
        });

    })(jQuery);


    /*
    * jQuery UI Dialog
    *
    * Copyright (c) 2008 Richard D. Worth (rdworth.org)
    * Dual licensed under the MIT (MIT-LICENSE.txt)
    * and GPL (GPL-LICENSE.txt) licenses.
    * 
    * http://docs.jquery.com/UI/Dialog
    *
    * Depends:
    *	ui.core.js
    *	ui.draggable.js
    *	ui.resizable.js
    *
    * Changes by Jackson Caset - www.profissionaisti.com.br
    * 	-> Line 122/148: allow to maximize dialog (on the maximize icon and with doubleclick on titlebar) - maximize:true/false (true is default)
    * 	-> Line 61/476: allow to remove the close icon and not allow to close with ESC if closable is false - closable:true/false (true is default)
    *  -> Line 175: not allow to drag the dialog outside the document or a specific element - containment:element (document is default)
    *  -> Line 300: major precision on the content size and scroll (is necessary more tests with diferent themas)
    *  -> Line 344 - 365: functions maximize, restore and adjust content on dialog
    *  -> Line 428: new options closable and maximize
    */
    (function($) {

        var setDataSwitch = {
            dragStart: "start.draggable",
            drag: "drag.draggable",
            dragStop: "stop.draggable",
            maxHeight: "maxHeight.resizable",
            minHeight: "minHeight.resizable",
            maxWidth: "maxWidth.resizable",
            minWidth: "minWidth.resizable",
            resizeStart: "start.resizable",
            resize: "drag.resizable",
            resizeStop: "stop.resizable"
        };

        $.widget("ui.dialog", {
            maximized: false,

            init: function() {
                var self = this,

			options = this.options,
			resizeHandles = typeof options.resizable == 'string'
				? options.resizable
				: 'n,e,s,w,se,sw,ne,nw',

			uiDialogContent = this.element
				.addClass('ui-dialog-content')
				.wrap('<div/>')
				.wrap('<div/>'),

			uiDialogContainer = (this.uiDialogContainer = uiDialogContent.parent()
				.addClass('ui-dialog-container')
				.css({ position: 'relative', width: '100%', height: '100%' })),

			title = options.title || uiDialogContent.attr('title') || '',
			uiDialogTitlebar = (this.uiDialogTitlebar =
				$('<div class="ui-dialog-titlebar"/>'))
				.append('<span class="ui-dialog-title">' + title + '</span>');

                /* Verifify if the dialog is closable by the close button. | by Jackson Caset - www.profissionaisti.com.br */
                if (this.options.closable) {
                    uiDialogTitlebar.append('<a href="#" class="ui-dialog-titlebar-close"><span>X</span></a>');
                }
                /* ******************************************************************************************************* */

                uiDialogTitlebar.prependTo(uiDialogContainer),

			uiDialog = (this.uiDialog = uiDialogContainer.parent())
				.appendTo(document.body)
				.hide()
				.addClass('ui-dialog')
				.addClass(options.dialogClass)
                // add content classes to dialog
                // to inherit theme at top level of element
				.addClass(uiDialogContent.attr('className'))
					.removeClass('ui-dialog-content')
				.css({
				    position: 'absolute',
				    width: options.width,
				    height: options.height,
				    overflow: 'hidden',
				    zIndex: options.zIndex
				})
                // setting tabIndex makes the div focusable
                // setting outline to 0 prevents a border on focus in Mozilla
				.attr('tabIndex', -1).css('outline', 0).keydown(function(ev) {
				    if (options.closeOnEscape && options.closable) {
				        var ESC = 27;
				        (ev.keyCode && ev.keyCode == ESC && self.close());
				    }
				})
				.mousedown(function() {
				    self.moveToTop();
				}),

			uiDialogButtonPane = (this.uiDialogButtonPane = $('<div/>'))
				.addClass('ui-dialog-buttonpane').css({ position: 'absolute', bottom: 5 /* Adjust the button. Default is 0 */ })
				.appendTo(uiDialog);

                this.uiDialogTitlebarClose = $('.ui-dialog-titlebar-close', uiDialogTitlebar)
			.hover(
				function() {
				    $(this).addClass('ui-dialog-titlebar-close-hover');
				},
				function() {
				    $(this).removeClass('ui-dialog-titlebar-close-hover');
				}
			)
			.mousedown(function(ev) {
			    ev.stopPropagation();
			})
			.click(function() {
			    self.close();
			    return false;
			});

                this.uiDialogTitlebar.find("*").add(this.uiDialogTitlebar).each(function() {
                    $.ui.disableSelection(this);
                });

                /* Verifify if the dialog is maximizable. | by Jackson Caset - www.profissionaisti.com.br */
                if (options.maximize) {
                    uiDialogTitlebar.append('<a href="#" id="dialog-restore" class="ui-dialog-titlebar-rest"><span>Min</span></a>');
                    this.uiDialogTitlebarMin = $('#dialog-restore', uiDialogTitlebar).hover(function() {
                        $(this).addClass('ui-dialog-titlebar-rest-hover');
                    }, function() {
                        $(this).removeClass('ui-dialog-titlebar-rest-hover');
                    }).mousedown(function(ev) {
                        ev.stopPropagation();
                    }).click(function() {
                        self.restore();
                        return false;
                    }).hide();

                    uiDialogTitlebar.append('<a href="#" id="dialog-maximize" class="ui-dialog-titlebar-max"><span>Max</span></a>');
                    this.uiDialogTitlebarMax = $('#dialog-maximize', uiDialogTitlebar).hover(function() {
                        $(this).addClass('ui-dialog-titlebar-max-hover');
                    }, function() {
                        $(this).removeClass('ui-dialog-titlebar-max-hover');
                    }).mousedown(function(ev) {
                        ev.stopPropagation();
                    }).click(function() {
                        self.maximize();
                        return false;
                    });

                    /* Allow titlebar doubleclick to maximize/restore the dialog. | by Jackson Caset - www.profissionaisti.com.br */
                    uiDialogTitlebar.bind("dblclick", function() {
                        if (self.maximized) {
                            self.restore();
                        } else {
                            self.maximize();
                        }
                    });
                }
                /* ********************************************************************************************* */

                if ($.fn.draggable) {
                    uiDialog.draggable({
                        cancel: '.ui-dialog-content',
                        helper: options.dragHelper,
                        handle: '.ui-dialog-titlebar',
                        start: function(e, ui) {
                            self.moveToTop();
                            (options.dragStart && options.dragStart.apply(self.element[0], arguments));
                        },
                        drag: function(e, ui) {
                            (options.drag && options.drag.apply(self.element[0], arguments));
                        },
                        stop: function(e, ui) {
                            (options.dragStop && options.dragStop.apply(self.element[0], arguments));
                            $.ui.dialog.overlay.resize();
                        },
                        /* Containment the dialog. By default the document is the container. | by Jackson Caset - www.profissionaisti.com.br */
                        containment: options.containment || 'document'
                    });
                    (options.draggable || uiDialog.draggable('disable'));
                }

                if ($.fn.resizable) {
                    uiDialog.resizable({
                        cancel: '.ui-dialog-content',
                        helper: options.resizeHelper,
                        maxWidth: options.maxWidth,
                        maxHeight: options.maxHeight,
                        minWidth: options.minWidth,
                        minHeight: options.minHeight,
                        start: function() {
                            (options.resizeStart && options.resizeStart.apply(self.element[0], arguments));
                        },
                        resize: function(e, ui) {
                            (options.autoResize && self.size.apply(self));
                            (options.resize && options.resize.apply(self.element[0], arguments));
                        },
                        handles: resizeHandles,
                        stop: function(e, ui) {
                            (options.autoResize && self.size.apply(self));
                            (options.resizeStop && options.resizeStop.apply(self.element[0], arguments));
                            $.ui.dialog.overlay.resize();
                        }
                    });
                    (options.resizable || uiDialog.resizable('disable'));
                }

                this.createButtons(options.buttons);
                this.isOpen = false;

                (options.bgiframe && $.fn.bgiframe && uiDialog.bgiframe());
                (options.autoOpen && this.open());
            },

            setData: function(key, value) {
                (setDataSwitch[key] && this.uiDialog.data(setDataSwitch[key], value));
                switch (key) {
                    case "buttons":
                        this.createButtons(value);
                        break;
                    case "draggable":
                        this.uiDialog.draggable(value ? 'enable' : 'disable');
                        break;
                    case "height":
                        this.uiDialog.height(value);
                        break;
                    case "position":
                        this.position(value);
                        break;
                    case "resizable":
                        (typeof value == 'string' && this.uiDialog.data('handles.resizable', value));
                        this.uiDialog.resizable(value ? 'enable' : 'disable');
                        break;
                    case "title":
                        $(".ui-dialog-title", this.uiDialogTitlebar).text(value);
                        break;
                    case "width":
                        this.uiDialog.width(value);
                        break;
                }

                $.widget.prototype.setData.apply(this, arguments);
            },

            position: function(pos) {
                var wnd = $(window), doc = $(document),
			pTop = doc.scrollTop(), pLeft = doc.scrollLeft(),
			minTop = pTop;

                if ($.inArray(pos, ['center', 'top', 'right', 'bottom', 'left']) >= 0) {
                    pos = [
				pos == 'right' || pos == 'left' ? pos : 'center',
				pos == 'top' || pos == 'bottom' ? pos : 'middle'
			];
                }
                if (pos.constructor != Array) {
                    pos = ['center', 'middle'];
                }
                if (pos[0].constructor == Number) {
                    pLeft += pos[0];
                } else {
                    switch (pos[0]) {
                        case 'left':
                            pLeft += 0;
                            break;
                        case 'right':
                            pLeft += wnd.width() - this.uiDialog.width();
                            break;
                        default:
                        case 'center':
                            pLeft += (wnd.width() - this.uiDialog.width()) / 2;
                    }
                }
                if (pos[1].constructor == Number) {
                    pTop += pos[1];
                } else {
                    switch (pos[1]) {
                        case 'top':
                            pTop += 0;
                            break;
                        case 'bottom':
                            pTop += wnd.height() - this.uiDialog.height();
                            break;
                        default:
                        case 'middle':
                            pTop += (wnd.height() - this.uiDialog.height()) / 2;
                    }
                }

                // prevent the dialog from being too high (make sure the titlebar
                // is accessible)
                pTop = Math.max(pTop, minTop);
                this.uiDialog.css({ top: pTop, left: pLeft });
            },

            size: function() {
                var container = this.uiDialogContainer,
			titlebar = this.uiDialogTitlebar,
			content = this.element,
			tbMargin = parseInt(content.css('margin-top'), 10) + parseInt(content.css('margin-bottom'), 10),
			lrMargin = parseInt(content.css('margin-left'), 10) + parseInt(content.css('margin-right'), 10);
                content.height(container.height() - titlebar.outerHeight() - tbMargin /* More precision on scroll content | by Jackson Caset -> */ - 8);
                content.width(container.width() - lrMargin);
            },

            open: function() {
                if (this.isOpen) { return; }

                this.overlay = this.options.modal ? new $.ui.dialog.overlay(this) : null;
                (this.uiDialog.next().length > 0) && this.uiDialog.appendTo('body');
                this.position(this.options.position);
                this.uiDialog.show(this.options.show);
                this.options.autoResize && this.size();
                this.moveToTop(true);

                // CALLBACK: open
                var openEV = null;
                var openUI = {
                    options: this.options
                };
                this.uiDialogTitlebarClose.focus();
                this.element.triggerHandler("dialogopen", [openEV, openUI], this.options.open);

                this.isOpen = true;
            },

            // the force parameter allows us to move modal dialogs to their correct
            // position on open
            moveToTop: function(force) {
                if ((this.options.modal && !force)
			|| (!this.options.stack && !this.options.modal)) { return this.element.triggerHandler("dialogfocus", [null, { options: this.options}], this.options.focus); }

                var maxZ = this.options.zIndex, options = this.options;
                $('.ui-dialog:visible').each(function() {
                    maxZ = Math.max(maxZ, parseInt($(this).css('z-index'), 10) || options.zIndex);
                });
                (this.overlay && this.overlay.$el.css('z-index', ++maxZ));
                this.uiDialog.css('z-index', ++maxZ);

                this.element.triggerHandler("dialogfocus", [null, { options: this.options}], this.options.focus);
            },

            /* Adjuste the content inside the dialog on maximize/restore | by Jackson Caset - www.profissionaisti.com.br */
            adjustScrollContent: function() {
                $('.ui-dialog-content').css('width', this.uiDialog.width() - 16, 'height', this.uiDialog.height() - 16);
            },
            /* Allow maximize/restore the dialog | by Jackson Caset - www.profissionaisti.com.br */
            restore: function() {
                this.maximized = false; /* save the current state: restored */
                this.uiDialog.css({ width: this.options.width, height: this.options.height });
                this.size();
                this.adjustScrollContent();

                this.position(this.options.position);

                $('#dialog-maximize').show();
                $('#dialog-restore').hide();
                $('html, body').css("overflow", "auto");
            },
            maximize: function() {
                this.maximized = true; /* save the current state: maximized */
                this.uiDialog.css({ left: 0, top: 0, width: $(window.body).width(), height: $(window).height() });
                this.size();
                $('html, body').animate({ scrollTop: 0 }, 'fast'); /*added by parag */
                this.adjustScrollContent();
                $('#dialog-restore').show();
                $('#dialog-maximize').hide();
                $('html, body').css("overflow", "hidden"); /*added by parag */
            },
            /* ********************************************************************************************* */

            close: function() {
                (this.overlay && this.overlay.destroy());
                this.uiDialog.hide(this.options.hide);

                // CALLBACK: close
                var closeEV = null;
                var closeUI = {
                    options: this.options
                };
                this.element.triggerHandler("dialogclose", [closeEV, closeUI], this.options.close);
                $.ui.dialog.overlay.resize();

                this.isOpen = false;
                $('html, body').css("overflow", "auto");
            },

            destroy: function() {
                (this.overlay && this.overlay.destroy());
                this.uiDialog.hide();
                this.element
			.unbind('.dialog')
			.removeData('dialog')
			.removeClass('ui-dialog-content')
			.hide().appendTo('body');
                this.uiDialog.remove();
             $('html, body').css("overflow", "auto");
            },

            createButtons: function(buttons) {
                var self = this,
			hasButtons = false,
			uiDialogButtonPane = this.uiDialogButtonPane;

                // remove any existing buttons
                uiDialogButtonPane.empty().hide();

                $.each(buttons, function() { return !(hasButtons = true); });
                if (hasButtons) {
                    uiDialogButtonPane.show();
                    $.each(buttons, function(name, fn) {
                        $('<button/>')
					.text(name)
					.click(function() { fn.apply(self.element[0], arguments); })
					.appendTo(uiDialogButtonPane);
                    });
                }
            }
        });

        $.extend($.ui.dialog, {
            defaults: {
                autoOpen: true,
                autoResize: true,
                bgiframe: false,
                buttons: {},
                closeOnEscape: true,
                draggable: true,
                height: 200,
                minHeight: 100,
                minWidth: 150,
                modal: false,
                overlay: {},
                position: 'center',

                /* Closable and Maximize | by Jackson Caset - www.profissionaisti.com.br */
                closable: true, maximize: true,

                resizable: true,
                stack: true,
                width: 300,
                zIndex: 1000
            },

            overlay: function(dialog) {
                this.$el = $.ui.dialog.overlay.create(dialog);
            }
        });

        $.extend($.ui.dialog.overlay, {
            instances: [],
            events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
		function(e) { return e + '.dialog-overlay'; }).join(' '),
            create: function(dialog) {
                if (this.instances.length === 0) {
                    // prevent use of anchors and inputs
                    // we use a setTimeout in case the overlay is created from an
                    // event that we're going to be cancelling (see #2804)
                    setTimeout(function() {
                        $('a, :input').bind($.ui.dialog.overlay.events, function() {
                            // allow use of the element if inside a dialog and
                            // - there are no modal dialogs
                            // - there are modal dialogs, but we are in front of the topmost modal
                            var allow = false;
                            var $dialog = $(this).parents('.ui-dialog');
                            if ($dialog.length) {
                                var $overlays = $('.ui-dialog-overlay');
                                if ($overlays.length) {
                                    var maxZ = parseInt($overlays.css('z-index'), 10);
                                    $overlays.each(function() {
                                        maxZ = Math.max(maxZ, parseInt($(this).css('z-index'), 10));
                                    });
                                    allow = parseInt($dialog.css('z-index'), 10) > maxZ;
                                } else {
                                    allow = true;
                                }
                            }
                            return allow;
                        });
                    }, 1);

                    // allow closing by pressing the escape key			
                    if (dialog.options.closable) { /* Just if the dialog is closable | by Jackson Caset - www.profissionaisti.com.br */
                        $(document).bind('keydown.dialog-overlay', function(e) {
                            var ESC = 27;
                            (e.keyCode && e.keyCode == ESC && dialog.close());
                        });
                    }

                    // handle window resize
                    $(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
                }

                var $el = $('<div/>').appendTo(document.body)
			.addClass('ui-dialog-overlay').css($.extend({
			    borderWidth: 0, margin: 0, padding: 0,
			    position: 'absolute', top: 0, left: 0,
			    width: this.width(),
			    height: this.height()
			}, dialog.options.overlay));

                (dialog.options.bgiframe && $.fn.bgiframe && $el.bgiframe());

                this.instances.push($el);
                return $el;
            },

            destroy: function($el) {
                this.instances.splice($.inArray(this.instances, $el), 1);

                if (this.instances.length === 0) {
                    $('a, :input').add([document, window]).unbind('.dialog-overlay');
                }

                $el.remove();
            },

            height: function() {
                if ($.browser.msie && $.browser.version < 7) {
                    var scrollHeight = Math.max(
				document.documentElement.scrollHeight,
				document.body.scrollHeight
			);
                    var offsetHeight = Math.max(
				document.documentElement.offsetHeight,
				document.body.offsetHeight
			);

                    if (scrollHeight < offsetHeight) {
                        return $(window).height() + 'px';
                    } else {
                        return scrollHeight + 'px';
                    }
                } else {
                    return $(document).height() + 'px';
                }
            },

            width: function() {
                if ($.browser.msie && $.browser.version < 7) {
                    var scrollWidth = Math.max(
				document.documentElement.scrollWidth,
				document.body.scrollWidth
			);
                    var offsetWidth = Math.max(
				document.documentElement.offsetWidth,
				document.body.offsetWidth
			);

                    if (scrollWidth < offsetWidth) {
                        return $(window).width() + 'px';
                    } else {
                        return scrollWidth + 'px';
                    }
                } else {
                    return $(document).width() + 'px';
                }
            },

            resize: function() {
                /* If the dialog is draggable and the user drags it past the
                * right edge of the window, the document becomes wider so we
                * need to stretch the overlay. If the user then drags the
                * dialog back to the left, the document will become narrower,
                * so we need to shrink the overlay to the appropriate size.
                * This is handled by shrinking the overlay before setting it
                * to the full document size.
                */
                var $overlays = $([]);
                $.each($.ui.dialog.overlay.instances, function() {
                    $overlays = $overlays.add(this);
                });

                $overlays.css({
                    width: 0,
                    height: 0
                }).css({
                    width: $.ui.dialog.overlay.width(),
                    height: $.ui.dialog.overlay.height()
                });
            }
        });

        $.extend($.ui.dialog.overlay.prototype, {
            destroy: function() {
                $.ui.dialog.overlay.destroy(this.$el);
            }
        });

    })(jQuery);