Patch that adds the JS and CSS files for surveys.
The only update is in app/jquery/jquery-ui.core.js, from a non-release
(added by Paweł for the date picker) to a slightly updated released
version.
Reviewed by: Lennard de Rijk, Mario Ferraro
Patch by: Daniel Diniz, James Levy
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/app/jquery/jquery-editable-1.3.3.js Tue Jun 23 20:54:03 2009 +0200
@@ -0,0 +1,161 @@
+(function($){
+/*
+ * Editable 1.3.3
+ *
+ * Copyright (c) 2009 Arash Karimzadeh (arashkarimzadeh.com)
+ * Licensed under the MIT (MIT-LICENSE.txt)
+ * http://www.opensource.org/licenses/mit-license.php
+ *
+ * Date: Mar 02 2009
+ */
+$.fn.editable = function(options){
+ var defaults = {
+ onEdit: null,
+ onSubmit: null,
+ onCancel: null,
+ editClass: null,
+ submit: null,
+ cancel: null,
+ type: 'text', //text, textarea or select
+ submitBy: 'blur', //blur,change,dblclick,click
+ editBy: 'click',
+ options: null
+}
+ if(options=='disable')
+ return this.unbind(this.data('editable.options').editBy,this.data('editable.options').toEditable);
+ if(options=='enable')
+ return this.bind(this.data('editable.options').editBy,this.data('editable.options').toEditable);
+ if(options=='destroy')
+ return this.unbind(this.data('editable.options').editBy,this.data('editable.options').toEditable)
+ .data('editable.previous',null)
+ .data('editable.current',null)
+ .data('editable.options',null);
+
+ var options = $.extend(defaults, options);
+
+ options.toEditable = function(){
+ $this = $(this);
+ $this.data('editable.current',$this.html());
+ opts = $this.data('editable.options');
+ $.editableFactory[opts.type].toEditable($this.empty(),opts);
+ // Configure events,styles for changed content
+ $this.data('editable.previous',$this.data('editable.current'))
+ .children()
+ .focus()
+ .addClass(opts.editClass);
+ // Submit Event
+ if(opts.submit){
+ $('<button/>').appendTo($this)
+ .html(opts.submit)
+ .one('mouseup',function(){opts.toNonEditable($(this).parent(),true)});
+}else
+ $this.one(opts.submitBy,function(){opts.toNonEditable($(this),true)})
+ .children()
+ .one(opts.submitBy,function(){opts.toNonEditable($(this).parent(),true)});
+ // Cancel Event
+ if(opts.cancel)
+ $('<button/>').appendTo($this)
+ .html(opts.cancel)
+ .one('mouseup',function(){opts.toNonEditable($(this).parent(),false)});
+ // Call User Function
+ if($.isFunction(opts.onEdit))
+ opts.onEdit.apply( $this,
+ [{
+ current:$this.data('editable.current'),
+ previous:$this.data('editable.previous')
+}]
+ );
+}
+ options.toNonEditable = function($this,change){
+ opts = $this.data('editable.options');
+ // Configure events,styles for changed content
+ $this.one(opts.editBy,opts.toEditable)
+ .data( 'editable.current',
+ change
+ ?$.editableFactory[opts.type].getValue($this,opts)
+ :$this.data('editable.current')
+ )
+ .html(
+ opts.type=='password'
+ ?'*****'
+ :$this.data('editable.current')
+ );
+ // Call User Function
+ var func = null;
+ if($.isFunction(opts.onSubmit)&&change==true)
+ func = opts.onSubmit;
+ else if($.isFunction(opts.onCancel)&&change==false)
+ func = opts.onCancel;
+ if(func!=null)
+ func.apply($this,
+ [{
+ current:$this.data('editable.current'),
+ previous:$this.data('editable.previous')
+}]
+ );
+}
+ this.data('editable.options',options);
+ return this.one(options.editBy,options.toEditable);
+}
+$.editableFactory = {
+ 'text': {
+ toEditable: function($this,options){
+ $('<input/>').appendTo($this)
+ .val($this.data('editable.current'));
+},
+ getValue: function($this,options){
+ return $this.children().val();
+}
+},
+ 'password': {
+ toEditable: function($this,options){
+ $this.data('editable.current',$this.data('editable.password'));
+ $this.data('editable.previous',$this.data('editable.password'));
+ $('<input type="password"/>').appendTo($this)
+ .val($this.data('editable.current'));
+},
+ getValue: function($this,options){
+ $this.data('editable.password',$this.children().val());
+ return $this.children().val();
+}
+},
+ 'textarea': {
+ toEditable: function($this,options){
+ $('<textarea/>').appendTo($this)
+ .val($this.data('editable.current'));
+},
+ getValue: function($this,options){
+ return $this.children().val();
+}
+},
+ 'select': {
+ toEditable: function($this,options){
+ $select = $('<select/>').appendTo($this);
+ $.each( options.options,
+ function(key,value){
+ $('<option/>').appendTo($select)
+ .html(value)
+ .attr('value',key);
+}
+ )
+ $select.children().each(
+ function(){
+ var opt = $(this);
+ if(opt.text()==$this.data('editable.current'))
+ return opt.attr('selected', 'selected').text();
+}
+ )
+},
+ getValue: function($this,options){
+ var item = null;
+ $('select', $this).children().each(
+ function(){
+ if($(this).attr('selected'))
+ return item = $(this).text();
+}
+ )
+ return item;
+}
+}
+}
+})(jQuery);
\ No newline at end of file
--- a/app/jquery/jquery-ui.core.js Tue Jun 23 20:43:22 2009 +0200
+++ b/app/jquery/jquery-ui.core.js Tue Jun 23 20:54:03 2009 +0200
@@ -1,7 +1,7 @@
/*
- * jQuery UI @VERSION
+ * jQuery UI 1.6
*
- * Copyright (c) 2009 AUTHORS.txt (http://ui.jquery.com/about)
+ * Copyright (c) 2008 AUTHORS.txt (http://ui.jquery.com/about)
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
@@ -14,7 +14,8 @@
//Helper functions and ui object
$.ui = {
- version: "@VERSION",
+
+ version: "1.6",
// $.ui.plugin is deprecated. Use the proxy pattern instead.
plugin: {
@@ -38,15 +39,21 @@
},
contains: function(a, b) {
- return document.compareDocumentPosition
- ? a.compareDocumentPosition(b) & 16
- : a !== b && a.contains(b);
+ var safari2 = $.browser.safari && $.browser.version < 522;
+ if (a.contains && !safari2) {
+ return a.contains(b);
+ }
+ if (a.compareDocumentPosition)
+ return !!(a.compareDocumentPosition(b) & 16);
+ while (b = b.parentNode)
+ if (b == a) return true;
+ return false;
},
cssCache: {},
css: function(name) {
if ($.ui.cssCache[name]) { return $.ui.cssCache[name]; }
- var tmp = $('<div class="ui-gen"></div>').addClass(name).css({position:'absolute', top:'-5000px', left:'-5000px', display:'block'}).appendTo('body');
+ 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');
@@ -118,6 +125,7 @@
TAB: 9,
UP: 38
}
+
};
// WAI-ARIA normalization
@@ -153,6 +161,7 @@
//jQuery plugins
$.fn.extend({
+
remove: function() {
// Safari has a native remove event which actually removes DOM elements,
// so we have to use triggerHandler instead of trigger (#3037).
@@ -177,6 +186,7 @@
},
scrollParent: function() {
+
var scrollParent;
if(($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
scrollParent = this.parents().filter(function() {
@@ -189,41 +199,48 @@
}
return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
+
+
}
+
});
//Additional selectors
$.extend($.expr[':'], {
- data: function(elem, i, match) {
- return !!$.data(elem, match[3]);
+
+ data: function(a, i, m) {
+ return $.data(a, m[3]);
},
// TODO: add support for object, area
- tabbable: function(elem) {
- var nodeName = elem.nodeName.toLowerCase();
+ tabbable: function(a, i, m) {
+
+ var nodeName = a.nodeName.toLowerCase();
function isVisible(element) {
return !($(element).is(':hidden') || $(element).parents(':hidden').length);
}
return (
// in tab order
- elem.tabIndex >= 0 &&
+ a.tabIndex >= 0 &&
( // filter node types that participate in the tab order
// anchor tag
- ('a' == nodeName && elem.href) ||
+ ('a' == nodeName && a.href) ||
// enabled form element
(/input|select|textarea|button/.test(nodeName) &&
- 'hidden' != elem.type && !elem.disabled)
+ 'hidden' != a.type && !a.disabled)
) &&
// visible on page
- isVisible(elem)
+ isVisible(a)
);
+
}
+
});
@@ -282,7 +299,6 @@
$[namespace][name] = function(element, options) {
var self = this;
- this.namespace = namespace;
this.widgetName = name;
this.widgetEventPrefix = $[namespace][name].eventPrefix || name;
this.widgetBaseClass = namespace + '-' + name;
@@ -295,14 +311,10 @@
this.element = $(element)
.bind('setData.' + name, function(event, key, value) {
- if (event.target == element) {
- return self._setData(key, value);
- }
+ return self._setData(key, value);
})
.bind('getData.' + name, function(event, key) {
- if (event.target == element) {
- return self._getData(key);
- }
+ return self._getData(key);
})
.bind('remove', function() {
return self.destroy();
@@ -322,9 +334,7 @@
$.widget.prototype = {
_init: function() {},
destroy: function() {
- this.element.removeData(this.widgetName)
- .removeClass(this.widgetBaseClass + '-disabled' + ' ' + this.namespace + '-state-disabled')
- .removeAttr('aria-disabled');
+ this.element.removeData(this.widgetName);
},
option: function(key, value) {
@@ -350,11 +360,8 @@
this.options[key] = value;
if (key == 'disabled') {
- this.element
- [value ? 'addClass' : 'removeClass'](
- this.widgetBaseClass + '-disabled' + ' ' +
- this.namespace + '-state-disabled')
- .attr("aria-disabled", value);
+ this.element[value ? 'addClass' : 'removeClass'](
+ this.widgetBaseClass + '-disabled');
}
},
@@ -366,17 +373,10 @@
},
_trigger: function(type, event, data) {
- var callback = this.options[type],
- eventName = (type == this.widgetEventPrefix
- ? type : this.widgetEventPrefix + type);
-
- event = event ? $.event.fix(event) : $.Event();
- event.type = eventName;
-
- this.element.trigger(event, data);
-
- return !(callback && callback.call(this.element[0], event, data) === false
- || event.isDefaultPrevented());
+ var eventName = (type == this.widgetEventPrefix
+ ? type : this.widgetEventPrefix + type);
+ event = event || $.event.fix({ type: eventName, target: this.element[0] });
+ return this.element.triggerHandler(eventName, [event, data], this.options[type]);
}
};
@@ -463,8 +463,7 @@
// preventDefault() is used to prevent the selection of text here -
// however, in Safari, this causes select boxes not to be selectable
// anymore, so this fix is needed
- ($.browser.safari || event.preventDefault());
-
+ if(!$.browser.safari) event.preventDefault();
return true;
},
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/app/jquery/jquery-ui.dialog.js Tue Jun 23 20:54:03 2009 +0200
@@ -0,0 +1,607 @@
+/*
+ * jQuery UI Dialog 1.6
+ *
+ * Copyright (c) 2008 AUTHORS.txt (http://ui.jquery.com/about)
+ * 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
+ */
+(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", {
+
+ _init: function() {
+ this.originalTitle = this.element.attr('title');
+ this.options.title = this.options.title || this.originalTitle;
+
+ var self = this,
+ options = this.options,
+
+ uiDialogContent = this.element
+ .removeAttr('title')
+ .addClass('ui-dialog-content')
+ .wrap('<div></div>')
+ .wrap('<div></div>'),
+
+ uiDialogContainer = (this.uiDialogContainer = uiDialogContent.parent())
+ .addClass('ui-dialog-container')
+ .css({
+ position: 'relative',
+ width: '100%',
+ height: '100%'
+ }),
+
+ uiDialogTitlebar = (this.uiDialogTitlebar = $('<div></div>'))
+ .addClass('ui-dialog-titlebar')
+ .mousedown(function() {
+ self.moveToTop();
+ })
+ .prependTo(uiDialogContainer),
+
+ uiDialogTitlebarClose = $('<a href="#"/>')
+ .addClass('ui-dialog-titlebar-close')
+ .attr('role', 'button')
+ .appendTo(uiDialogTitlebar),
+
+ uiDialogTitlebarCloseText = (this.uiDialogTitlebarCloseText = $('<span/>'))
+ .text(options.closeText)
+ .appendTo(uiDialogTitlebarClose),
+
+ title = options.title || ' ',
+ titleId = $.ui.dialog.getTitleId(this.element),
+ uiDialogTitle = $('<span/>')
+ .addClass('ui-dialog-title')
+ .attr('id', titleId)
+ .html(title)
+ .prependTo(uiDialogTitlebar),
+
+ uiDialog = (this.uiDialog = uiDialogContainer.parent())
+ .appendTo(document.body)
+ .hide()
+ .addClass('ui-dialog')
+ .addClass(options.dialogClass)
+ .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) {
+ (options.closeOnEscape && ev.keyCode
+ && ev.keyCode == $.ui.keyCode.ESCAPE && self.close());
+ })
+ .attr({
+ role: 'dialog',
+ 'aria-labelledby': titleId
+ })
+ .mouseup(function() {
+ self.moveToTop();
+ }),
+
+ uiDialogButtonPane = (this.uiDialogButtonPane = $('<div></div>'))
+ .addClass('ui-dialog-buttonpane')
+ .css({
+ position: 'absolute',
+ bottom: 0
+ })
+ .appendTo(uiDialog),
+
+ 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;
+ });
+
+ uiDialogTitlebar.find("*").add(uiDialogTitlebar).disableSelection();
+
+ (options.draggable && $.fn.draggable && this._makeDraggable());
+ (options.resizable && $.fn.resizable && this._makeResizable());
+
+ this._createButtons(options.buttons);
+ this._isOpen = false;
+
+ (options.bgiframe && $.fn.bgiframe && uiDialog.bgiframe());
+ (options.autoOpen && this.open());
+ },
+
+ 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();
+
+ (this.originalTitle && this.element.attr('title', this.originalTitle));
+ },
+
+ close: function() {
+ if (false === this._trigger('beforeclose', null, { options: this.options })) {
+ return;
+ }
+
+ (this.overlay && this.overlay.destroy());
+ this.uiDialog
+ .hide(this.options.hide)
+ .unbind('keypress.ui-dialog');
+
+ this._trigger('close', null, { options: this.options });
+ $.ui.dialog.overlay.resize();
+
+ this._isOpen = false;
+ },
+
+ isOpen: function() {
+ return this._isOpen;
+ },
+
+ // 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._trigger('focus', null, { options: this.options });
+ }
+
+ 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));
+
+ //Save and then restore scroll since Opera 9.5+ resets when parent z-Index is changed.
+ // http://ui.jquery.com/bugs/ticket/3193
+ var saveScroll = { scrollTop: this.element.attr('scrollTop'), scrollLeft: this.element.attr('scrollLeft') };
+ this.uiDialog.css('z-index', ++maxZ);
+ this.element.attr(saveScroll);
+ this._trigger('focus', null, { options: this.options });
+ },
+
+ open: function() {
+ if (this._isOpen) { return; }
+
+ this.overlay = this.options.modal ? new $.ui.dialog.overlay(this) : null;
+ (this.uiDialog.next().length && this.uiDialog.appendTo('body'));
+ this._position(this.options.position);
+ this.uiDialog.show(this.options.show);
+ (this.options.autoResize && this._size());
+ this.moveToTop(true);
+
+ // prevent tabbing out of modal dialogs
+ (this.options.modal && this.uiDialog.bind('keypress.ui-dialog', function(event) {
+ if (event.keyCode != $.ui.keyCode.TAB) {
+ return;
+ }
+
+ var tabbables = $(':tabbable', this),
+ first = tabbables.filter(':first')[0],
+ last = tabbables.filter(':last')[0];
+
+ if (event.target == last && !event.shiftKey) {
+ setTimeout(function() {
+ first.focus();
+ }, 1);
+ } else if (event.target == first && event.shiftKey) {
+ setTimeout(function() {
+ last.focus();
+ }, 1);
+ }
+ }));
+
+ this.uiDialog.find(':tabbable:first').focus();
+ this._trigger('open', null, { options: this.options });
+ this._isOpen = true;
+ },
+
+ _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 type="button"></button>')
+ .text(name)
+ .click(function() { fn.apply(self.element[0], arguments); })
+ .appendTo(uiDialogButtonPane);
+ });
+ }
+ },
+
+ _makeDraggable: function() {
+ var self = this,
+ options = this.options;
+
+ this.uiDialog.draggable({
+ cancel: '.ui-dialog-content',
+ helper: options.dragHelper,
+ handle: '.ui-dialog-titlebar',
+ start: function() {
+ self.moveToTop();
+ (options.dragStart && options.dragStart.apply(self.element[0], arguments));
+ },
+ drag: function() {
+ (options.drag && options.drag.apply(self.element[0], arguments));
+ },
+ stop: function() {
+ (options.dragStop && options.dragStop.apply(self.element[0], arguments));
+ $.ui.dialog.overlay.resize();
+ }
+ });
+ },
+
+ _makeResizable: function(handles) {
+ handles = (handles === undefined ? this.options.resizable : handles);
+ var self = this,
+ options = this.options,
+ resizeHandles = typeof handles == 'string'
+ ? handles
+ : 'n,e,s,w,se,sw,ne,nw';
+
+ this.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() {
+ (options.autoResize && self._size.apply(self));
+ (options.resize && options.resize.apply(self.element[0], arguments));
+ },
+ handles: resizeHandles,
+ stop: function() {
+ (options.autoResize && self._size.apply(self));
+ (options.resizeStop && options.resizeStop.apply(self.element[0], arguments));
+ $.ui.dialog.overlay.resize();
+ }
+ });
+ },
+
+ _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.outerWidth();
+ break;
+ default:
+ case 'center':
+ pLeft += (wnd.width() - this.uiDialog.outerWidth()) / 2;
+ }
+ }
+ if (pos[1].constructor == Number) {
+ pTop += pos[1];
+ } else {
+ switch (pos[1]) {
+ case 'top':
+ pTop += 0;
+ break;
+ case 'bottom':
+ // Opera check fixes #3564, can go away with jQuery 1.3
+ pTop += ($.browser.opera ? window.innerHeight : wnd.height()) - this.uiDialog.outerHeight();
+ break;
+ default:
+ case 'middle':
+ // Opera check fixes #3564, can go away with jQuery 1.3
+ pTop += (($.browser.opera ? window.innerHeight : wnd.height()) - this.uiDialog.outerHeight()) / 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});
+ },
+
+ _setData: function(key, value){
+ (setDataSwitch[key] && this.uiDialog.data(setDataSwitch[key], value));
+ switch (key) {
+ case "buttons":
+ this._createButtons(value);
+ break;
+ case "closeText":
+ this.uiDialogTitlebarCloseText.text(value);
+ break;
+ case "draggable":
+ (value
+ ? this._makeDraggable()
+ : this.uiDialog.draggable('destroy'));
+ break;
+ case "height":
+ this.uiDialog.height(value);
+ break;
+ case "position":
+ this._position(value);
+ break;
+ case "resizable":
+ var uiDialog = this.uiDialog,
+ isResizable = this.uiDialog.is(':data(resizable)');
+
+ // currently resizable, becoming non-resizable
+ (isResizable && !value && uiDialog.resizable('destroy'));
+
+ // currently resizable, changing handles
+ (isResizable && typeof value == 'string' &&
+ uiDialog.resizable('option', 'handles', value));
+
+ // currently non-resizable, becoming resizable
+ (isResizable || this._makeResizable(value));
+
+ break;
+ case "title":
+ $(".ui-dialog-title", this.uiDialogTitlebar).html(value || ' ');
+ break;
+ case "width":
+ this.uiDialog.width(value);
+ break;
+ }
+
+ $.widget.prototype._setData.apply(this, arguments);
+ },
+
+ _size: function() {
+ var container = this.uiDialogContainer,
+ titlebar = this.uiDialogTitlebar,
+ content = this.element,
+ tbMargin = (parseInt(content.css('margin-top'), 10) || 0)
+ + (parseInt(content.css('margin-bottom'), 10) || 0),
+ lrMargin = (parseInt(content.css('margin-left'), 10) || 0)
+ + (parseInt(content.css('margin-right'), 10) || 0);
+ content.height(container.height() - titlebar.outerHeight() - tbMargin);
+ content.width(container.width() - lrMargin);
+ }
+
+});
+
+$.extend($.ui.dialog, {
+ version: "1.6",
+ defaults: {
+ autoOpen: true,
+ autoResize: true,
+ bgiframe: false,
+ buttons: {},
+ closeOnEscape: true,
+ closeText: 'close',
+ draggable: true,
+ height: 200,
+ minHeight: 100,
+ minWidth: 150,
+ modal: false,
+ overlay: {},
+ position: 'center',
+ resizable: true,
+ stack: true,
+ width: 300,
+ zIndex: 1000
+ },
+
+ getter: 'isOpen',
+
+ uuid: 0,
+
+ getTitleId: function($el) {
+ return 'ui-dialog-title-' + ($el.attr('id') || ++this.uuid);
+ },
+
+ 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(event) { return event + '.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
+ $(document).bind('keydown.dialog-overlay', function(event) {
+ (dialog.options.closeOnEscape && event.keyCode
+ && event.keyCode == $.ui.keyCode.ESCAPE && dialog.close());
+ });
+
+ // handle window resize
+ $(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
+ }
+
+ var $el = $('<div></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() {
+ // handle IE 6
+ 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';
+ }
+ // handle Opera
+ } else if ($.browser.opera) {
+ return Math.max(
+ window.innerHeight,
+ $(document).height()
+ ) + 'px';
+ // handle "good" browsers
+ } else {
+ return $(document).height() + 'px';
+ }
+ },
+
+ width: function() {
+ // handle IE 6
+ 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';
+ }
+ // handle Opera
+ } else if ($.browser.opera) {
+ return Math.max(
+ window.innerWidth,
+ $(document).width()
+ ) + 'px';
+ // handle "good" browsers
+ } 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);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/app/jquery/jquery-ui.draggable.js Tue Jun 23 20:54:03 2009 +0200
@@ -0,0 +1,711 @@
+/*
+ * jQuery UI Draggable 1.6
+ *
+ * Copyright (c) 2008 AUTHORS.txt (http://ui.jquery.com/about)
+ * 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() {
+
+ if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))
+ this.element[0].style.position = 'relative';
+
+ (this.options.cssNamespace && this.element.addClass(this.options.cssNamespace+"-draggable"));
+ (this.options.disabled && this.element.addClass('ui-draggable-disabled'));
+
+ this._mouseInit();
+
+ },
+
+ destroy: function() {
+ if(!this.element.data('draggable')) return;
+ this.element.removeData("draggable").unbind(".draggable").removeClass('ui-draggable ui-draggable-dragging ui-draggable-disabled');
+ this._mouseDestroy();
+ },
+
+ _mouseCapture: function(event) {
+
+ var o = this.options;
+
+ if (this.helper || o.disabled || $(event.target).is('.ui-resizable-handle'))
+ return false;
+
+ //Quit if we're not on a valid handle
+ this.handle = this._getHandle(event);
+ if (!this.handle)
+ return false;
+
+ return true;
+
+ },
+
+ _mouseStart: function(event) {
+
+ var o = this.options;
+
+ //Create and append the visible helper
+ this.helper = this._createHelper(event);
+
+ //Cache the helper size
+ this._cacheHelperProportions();
+
+ //If ddmanager is used for droppables, set the global draggable
+ if($.ui.ddmanager)
+ $.ui.ddmanager.current = this;
+
+ /*
+ * - Position generation -
+ * This block generates everything position related - it's the core of draggables.
+ */
+
+ //Cache the margins of the original element
+ this._cacheMargins();
+
+ //Store the helper's css position
+ this.cssPosition = this.helper.css("position");
+ this.scrollParent = this.helper.scrollParent();
+
+ //The element's absolute position on the page minus margins
+ this.offset = this.element.offset();
+ this.offset = {
+ top: this.offset.top - this.margins.top,
+ left: this.offset.left - this.margins.left
+ };
+
+ $.extend(this.offset, {
+ click: { //Where the click happened, relative to the element
+ left: event.pageX - this.offset.left,
+ top: event.pageY - this.offset.top
+ },
+ parent: this._getParentOffset(),
+ relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
+ });
+
+ //Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
+ if(o.cursorAt)
+ this._adjustOffsetFromHelper(o.cursorAt);
+
+ //Generate the original position
+ this.originalPosition = this._generatePosition(event);
+
+ //Set a containment if given in the options
+ if(o.containment)
+ this._setContainment();
+
+ //Call plugins and callbacks
+ this._propagate("start", event);
+
+ //Recache the helper size
+ this._cacheHelperProportions();
+
+ //Prepare the droppable offsets
+ if ($.ui.ddmanager && !o.dropBehaviour)
+ $.ui.ddmanager.prepareOffsets(this, event);
+
+ this.helper.addClass("ui-draggable-dragging");
+ this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
+ return true;
+ },
+
+ _mouseDrag: function(event, noPropagation) {
+
+ //Compute the helpers position
+ this.position = this._generatePosition(event);
+ this.positionAbs = this._convertPositionTo("absolute");
+
+ //Call plugins and callbacks and use the resulting position if something is returned
+ if(!noPropagation) this.position = this._propagate("drag", event) || 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, event);
+
+ return false;
+ },
+
+ _mouseStop: function(event) {
+
+ //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, event);
+
+ if((this.options.revert == "invalid" && !dropped) || (this.options.revert == "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
+ var self = this;
+ $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
+ self._propagate("stop", event);
+ self._clear();
+ });
+ } else {
+ this._propagate("stop", event);
+ this._clear();
+ }
+
+ return false;
+ },
+
+ _getHandle: function(event) {
+
+ var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
+ $(this.options.handle, this.element)
+ .find("*")
+ .andSelf()
+ .each(function() {
+ if(this == event.target) handle = true;
+ });
+
+ return handle;
+
+ },
+
+ _createHelper: function(event) {
+
+ var o = this.options;
+ var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper == 'clone' ? this.element.clone() : this.element);
+
+ if(!helper.parents('body').length)
+ helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));
+
+ if(helper[0] != this.element[0] && !(/(fixed|absolute)/).test(helper.css("position")))
+ helper.css("position", "absolute");
+
+ return helper;
+
+ },
+
+ _adjustOffsetFromHelper: function(obj) {
+ if(obj.left != undefined) this.offset.click.left = obj.left + this.margins.left;
+ if(obj.right != undefined) this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
+ if(obj.top != undefined) this.offset.click.top = obj.top + this.margins.top;
+ if(obj.bottom != undefined) this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
+ },
+
+ _getParentOffset: function() {
+
+ 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) //Ugly FF3 fix
+ || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
+ po = { top: 0, left: 0 };
+
+ return {
+ top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
+ left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
+ };
+
+ },
+
+ _getRelativeOffset: function() {
+
+ if(this.cssPosition == "relative") {
+ var p = this.element.position();
+ return {
+ top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
+ left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
+ };
+ } else {
+ return { top: 0, left: 0 };
+ }
+
+ },
+
+ _cacheMargins: function() {
+ this.margins = {
+ left: (parseInt(this.element.css("marginLeft"),10) || 0),
+ top: (parseInt(this.element.css("marginTop"),10) || 0)
+ };
+ },
+
+ _cacheHelperProportions: function() {
+ this.helperProportions = {
+ width: this.helper.outerWidth(),
+ height: this.helper.outerHeight()
+ };
+ },
+
+ _setContainment: function() {
+
+ var o = this.options;
+ 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();
+ var over = ($(ce).css("overflow") != 'hidden');
+
+ this.containment = [
+ co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left - this.margins.left,
+ co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top - this.margins.top,
+ co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left - this.helperProportions.width - this.margins.left,
+ co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top - this.helperProportions.height - this.margins.top
+ ];
+ }
+
+ },
+
+ _convertPositionTo: function(d, pos) {
+
+ if(!pos) pos = this.position;
+ var mod = d == "absolute" ? 1 : -1;
+ var scroll = this[(this.cssPosition == 'absolute' ? 'offset' : 'scroll')+'Parent'], scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+ 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.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * 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.scrollParent.scrollLeft() : ( scrollIsRootNode ? 0 : scroll.scrollLeft() ) ) * mod
+ + this.margins.left * mod //Add the margin (you don't want the margin counting in intersection methods)
+ )
+ };
+ },
+
+ _generatePosition: function(event) {
+
+ var o = this.options, scroll = this[(this.cssPosition == 'absolute' ? 'offset' : 'scroll')+'Parent'], scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+ var position = {
+ top: (
+ event.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.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) )
+ ),
+ left: (
+ event.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.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() )
+ )
+ };
+
+ 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;
+ },
+
+ _clear: function() {
+ this.helper.removeClass("ui-draggable-dragging");
+ if(this.helper[0] != this.element[0] && !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
+
+ _propagate: function(n, event) {
+ $.ui.plugin.call(this, n, [event, 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, [event, this._uiHash()], this.options[n]);
+ },
+
+ plugins: {},
+
+ _uiHash: function(event) {
+ return {
+ helper: this.helper,
+ position: this.position,
+ absolutePosition: this.positionAbs,
+ options: this.options
+ };
+ }
+
+}));
+
+$.extend($.ui.draggable, {
+ version: "1.6",
+ defaults: {
+ appendTo: "parent",
+ axis: false,
+ cancel: ":input",
+ connectToSortable: false,
+ containment: false,
+ cssNamespace: "ui",
+ cursor: "default",
+ cursorAt: null,
+ delay: 0,
+ distance: 1,
+ grid: false,
+ handle: false,
+ helper: "original",
+ iframeFix: false,
+ opacity: 1,
+ refreshPositions: false,
+ revert: false,
+ revertDuration: 500,
+ scope: "default",
+ scroll: true,
+ scrollSensitivity: 20,
+ scrollSpeed: 20,
+ snap: false,
+ snapMode: "both",
+ snapTolerance: 20,
+ stack: false,
+ zIndex: null
+ }
+});
+
+$.ui.plugin.add("draggable", "connectToSortable", {
+ start: function(event, ui) {
+
+ var inst = $(this).data("draggable");
+ inst.sortables = [];
+ $(ui.options.connectToSortable).each(function() {
+ // 'this' points to a string, and should therefore resolved as query, but instead, if the string is assigned to a variable, it loops through the strings properties,
+ // so we have to append '' to make it anonymous again
+ $(this+'').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", event, inst);
+ }
+ });
+ });
+
+ },
+ stop: function(event, 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(event);
+
+ //Also propagate receive event, since the sortable is actually receiving a element
+ this.instance.element.triggerHandler("sortreceive", [event, $.extend(this.instance._ui(), { sender: inst.element })], this.instance.options["receive"]);
+
+ this.instance.options.helper = this.instance.options._helper;
+
+ if(inst.options.helper == 'original') {
+ this.instance.currentItem.css({ top: 'auto', left: 'auto' });
+ }
+
+ } else {
+ this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
+ this.instance._propagate("deactivate", event, inst);
+ }
+
+ });
+
+ },
+ drag: function(event, ui) {
+
+ var inst = $(this).data("draggable"), self = this;
+
+ var checkPos = function(o) {
+ var dyClick = this.offset.click.top, dxClick = this.offset.click.left;
+ var helperTop = this.positionAbs.top, helperLeft = this.positionAbs.left;
+ var itemHeight = o.height, itemWidth = o.width;
+ var itemTop = o.top, itemLeft = o.left;
+
+ return $.ui.isOver(helperTop + dyClick, helperLeft + dxClick, itemTop, itemLeft, itemHeight, itemWidth);
+ };
+
+ $.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]; };
+
+ event.target = this.instance.currentItem[0];
+ this.instance._mouseCapture(event, true);
+ this.instance._mouseStart(event, 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", event);
+
+ }
+
+ //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(event);
+
+ } 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(event, 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", event);
+ }
+
+ };
+
+ });
+
+ }
+});
+
+$.ui.plugin.add("draggable", "cursor", {
+ start: function(event, ui) {
+ var t = $('body');
+ if (t.css("cursor")) ui.options._cursor = t.css("cursor");
+ t.css("cursor", ui.options.cursor);
+ },
+ stop: function(event, ui) {
+ if (ui.options._cursor) $('body').css("cursor", ui.options._cursor);
+ }
+});
+
+$.ui.plugin.add("draggable", "iframeFix", {
+ start: function(event, 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(event, ui) {
+ $("div.ui-draggable-iframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers
+ }
+});
+
+$.ui.plugin.add("draggable", "opacity", {
+ start: function(event, ui) {
+ var t = $(ui.helper);
+ if(t.css("opacity")) ui.options._opacity = t.css("opacity");
+ t.css('opacity', ui.options.opacity);
+ },
+ stop: function(event, ui) {
+ if(ui.options._opacity) $(ui.helper).css('opacity', ui.options._opacity);
+ }
+});
+
+$.ui.plugin.add("draggable", "scroll", {
+ start: function(event, ui) {
+ var o = ui.options;
+ var i = $(this).data("draggable");
+
+ if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') i.overflowOffset = i.scrollParent.offset();
+
+ },
+ drag: function(event, ui) {
+
+ var o = ui.options, scrolled = false;
+ var i = $(this).data("draggable");
+
+ if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') {
+
+ if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
+ i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
+ else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity)
+ i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
+
+ if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
+ i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
+ else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity)
+ i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
+
+ } else {
+
+ if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
+ scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+ else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
+ scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+
+ if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
+ scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
+ else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
+ scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
+
+ }
+
+ if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
+ $.ui.ddmanager.prepareOffsets(i, event);
+
+
+
+ // This is a special case where we need to modify a offset calculated on start, since the following happened:
+ // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
+ // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
+ // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
+ if(scrolled !== false && i.cssPosition == 'absolute' && i.scrollParent[0] != document && $.ui.contains(i.scrollParent[0], i.offsetParent[0])) {
+ i.offset.parent = i._getParentOffset();
+
+ }
+
+ // This is another very weird special case that only happens for relative elements:
+ // 1. If the css position is relative
+ // 2. and the scroll parent is the document or similar to the offset parent
+ // we have to refresh the relative offset during the scroll so there are no jumps
+ if(scrolled !== false && i.cssPosition == 'relative' && !(i.scrollParent[0] != document && i.scrollParent[0] != i.offsetParent[0])) {
+ i.offset.relative = i._getRelativeOffset();
+ }
+
+
+ }
+});
+
+$.ui.plugin.add("draggable", "snap", {
+ start: function(event, ui) {
+
+ var inst = $(this).data("draggable");
+ inst.snapElements = [];
+
+ $(ui.options.snap.constructor != String ? ( ui.options.snap.items || ':data(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(event, ui) {
+
+ var inst = $(this).data("draggable");
+ var d = ui.options.snapTolerance;
+
+ 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))) {
+ if(inst.snapElements[i].snapping) (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
+ inst.snapElements[i].snapping = false;
+ continue;
+ }
+
+ if(ui.options.snapMode != 'inner') {
+ var ts = Math.abs(t - y2) <= d;
+ var bs = Math.abs(b - y1) <= d;
+ var ls = Math.abs(l - x2) <= d;
+ var rs = Math.abs(r - x1) <= d;
+ 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;
+ }
+
+ var first = (ts || bs || ls || rs);
+
+ if(ui.options.snapMode != 'outer') {
+ var ts = Math.abs(t - y1) <= d;
+ var bs = Math.abs(b - y2) <= d;
+ var ls = Math.abs(l - x1) <= d;
+ var rs = Math.abs(r - x2) <= d;
+ 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;
+ }
+
+ if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first))
+ (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
+ inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
+
+ };
+
+ }
+});
+
+$.ui.plugin.add("draggable", "stack", {
+ start: function(event, 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;
+ }
+});
+
+$.ui.plugin.add("draggable", "zIndex", {
+ start: function(event, ui) {
+ var t = $(ui.helper);
+ if(t.css("zIndex")) ui.options._zIndex = t.css("zIndex");
+ t.css('zIndex', ui.options.zIndex);
+ },
+ stop: function(event, ui) {
+ if(ui.options._zIndex) $(ui.helper).css('zIndex', ui.options._zIndex);
+ }
+});
+
+})(jQuery);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/app/jquery/jquery-ui.sortable.js Tue Jun 23 20:54:03 2009 +0200
@@ -0,0 +1,1015 @@
+/*
+ * jQuery UI Sortable 1.6
+ *
+ * Copyright (c) 2008 AUTHORS.txt (http://ui.jquery.com/about)
+ * Dual licensed under the MIT (MIT-LICENSE.txt)
+ * and GPL (GPL-LICENSE.txt) licenses.
+ *
+ * http://docs.jquery.com/UI/Sortables
+ *
+ * Depends:
+ * ui.core.js
+ */
+(function($) {
+
+$.widget("ui.sortable", $.extend({}, $.ui.mouse, {
+ _init: function() {
+
+ var o = this.options;
+ this.containerCache = {};
+ this.element.addClass("ui-sortable");
+
+ //Get the items
+ this.refresh();
+
+ //Let's determine if the items are floating
+ this.floating = this.items.length ? (/left|right/).test(this.items[0].item.css('float')) : false;
+
+ //Let's determine the parent's offset
+ this.offset = this.element.offset();
+
+ //Initialize mouse events for interaction
+ this._mouseInit();
+
+ },
+
+ destroy: function() {
+ this.element
+ .removeClass("ui-sortable ui-sortable-disabled")
+ .removeData("sortable")
+ .unbind(".sortable");
+ this._mouseDestroy();
+
+ for ( var i = this.items.length - 1; i >= 0; i-- )
+ this.items[i].item.removeData("sortable-item");
+ },
+
+ _mouseCapture: function(event, overrideHandle) {
+
+ if (this.reverting) {
+ return false;
+ }
+
+ if(this.options.disabled || this.options.type == 'static') return false;
+
+ //We have to refresh the items data once first
+ this._refreshItems(event);
+
+ //Find out if the clicked node (or one of its parents) is a actual item in this.items
+ var currentItem = null, self = this, nodes = $(event.target).parents().each(function() {
+ if($.data(this, 'sortable-item') == self) {
+ currentItem = $(this);
+ return false;
+ }
+ });
+ if($.data(event.target, 'sortable-item') == self) currentItem = $(event.target);
+
+ if(!currentItem) return false;
+ if(this.options.handle && !overrideHandle) {
+ var validHandle = false;
+
+ $(this.options.handle, currentItem).find("*").andSelf().each(function() { if(this == event.target) validHandle = true; });
+ if(!validHandle) return false;
+ }
+
+ this.currentItem = currentItem;
+ this._removeCurrentsFromItems();
+ return true;
+
+ },
+
+ _mouseStart: function(event, overrideHandle, noActivation) {
+
+ var o = this.options;
+ this.currentContainer = this;
+
+ //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
+ this.refreshPositions();
+
+ //Create and append the visible helper
+ this.helper = this._createHelper(event);
+
+ //Cache the helper size
+ this._cacheHelperProportions();
+
+ /*
+ * - Position generation -
+ * This block generates everything position related - it's the core of draggables.
+ */
+
+ //Cache the margins of the original element
+ this._cacheMargins();
+
+ //Get the next scrolling parent
+ this.scrollParent = this.helper.scrollParent();
+
+ //The element's absolute position on the page minus margins
+ this.offset = this.currentItem.offset();
+
+ this.offset = {
+ top: this.offset.top - this.margins.top,
+ left: this.offset.left - this.margins.left
+ };
+
+ // Only after we got the offset, we can change the helper's position to absolute
+ // TODO: Still need to figure out a way to make relative sorting possible
+ this.helper.css("position", "absolute");
+ this.cssPosition = this.helper.css("position");
+
+ $.extend(this.offset, {
+ click: { //Where the click happened, relative to the element
+ left: event.pageX - this.offset.left,
+ top: event.pageY - this.offset.top
+ },
+ parent: this._getParentOffset(),
+ relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
+ });
+
+ //Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
+ if(o.cursorAt)
+ this._adjustOffsetFromHelper(o.cursorAt);
+
+ //Generate the original position
+ this.originalPosition = this._generatePosition(event);
+
+ //Cache the former DOM position
+ this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
+
+ //If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
+ if(this.helper[0] != this.currentItem[0]) {
+ this.currentItem.hide();
+ }
+
+ //Create the placeholder
+ this._createPlaceholder();
+
+ //Set a containment if given in the options
+ if(o.containment)
+ this._setContainment();
+
+ //Call plugins and callbacks
+ this._propagate("start", event);
+
+ //Recache the helper size
+ if(!this._preserveHelperProportions)
+ this._cacheHelperProportions();
+
+
+ //Post 'activate' events to possible containers
+ if(!noActivation) {
+ for (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i]._propagate("activate", event, this); }
+ }
+
+ //Prepare possible droppables
+ if($.ui.ddmanager)
+ $.ui.ddmanager.current = this;
+
+ if ($.ui.ddmanager && !o.dropBehaviour)
+ $.ui.ddmanager.prepareOffsets(this, event);
+
+ this.dragging = true;
+
+ this.helper.addClass('ui-sortable-helper');
+ this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
+ return true;
+
+ },
+
+ _mouseDrag: function(event) {
+
+ //Compute the helpers position
+ this.position = this._generatePosition(event);
+ this.positionAbs = this._convertPositionTo("absolute");
+
+ if (!this.lastPositionAbs) {
+ this.lastPositionAbs = this.positionAbs;
+ }
+
+ //Call the internal plugins
+ $.ui.plugin.call(this, "sort", [event, this._ui()]);
+
+ //Regenerate the absolute position used for position checks
+ this.positionAbs = this._convertPositionTo("absolute");
+
+ //Set the helper 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';
+
+ //Rearrange
+ for (var i = this.items.length - 1; i >= 0; i--) {
+
+ //Cache variables and intersection, continue if no intersection
+ var item = this.items[i], itemElement = item.item[0], intersection = this._intersectsWithPointer(item);
+ if (!intersection) continue;
+
+ if(itemElement != this.currentItem[0] //cannot intersect with itself
+ && this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before
+ && !$.ui.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked
+ && (this.options.type == 'semi-dynamic' ? !$.ui.contains(this.element[0], itemElement) : true)
+ ) {
+
+ this.direction = intersection == 1 ? "down" : "up";
+
+ if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) {
+ this.options.sortIndicator.call(this, event, item);
+ } else {
+ break;
+ }
+
+ this._propagate("change", event); //Call plugins and callbacks
+ break;
+ }
+ }
+
+ //Post events to containers
+ this._contactContainers(event);
+
+ //Interconnect with droppables
+ if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);
+
+ //Call callbacks
+ this._trigger('sort', event, this._ui());
+
+ this.lastPositionAbs = this.positionAbs;
+ return false;
+
+ },
+
+ _mouseStop: function(event, noPropagation) {
+
+ if(!event) return;
+
+ //If we are using droppables, inform the manager about the drop
+ if ($.ui.ddmanager && !this.options.dropBehaviour)
+ $.ui.ddmanager.drop(this, event);
+
+ if(this.options.revert) {
+ var self = this;
+ var cur = self.placeholder.offset();
+
+ self.reverting = true;
+
+ $(this.helper).animate({
+ left: cur.left - this.offset.parent.left - self.margins.left + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft),
+ top: cur.top - this.offset.parent.top - self.margins.top + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop)
+ }, parseInt(this.options.revert, 10) || 500, function() {
+ self._clear(event);
+ });
+ } else {
+ this._clear(event, noPropagation);
+ }
+
+ return false;
+
+ },
+
+ cancel: function() {
+
+ if(this.dragging) {
+
+ this._mouseUp();
+
+ if(this.options.helper == "original")
+ this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
+ else
+ this.currentItem.show();
+
+ //Post deactivating events to containers
+ for (var i = this.containers.length - 1; i >= 0; i--){
+ this.containers[i]._propagate("deactivate", null, this);
+ if(this.containers[i].containerCache.over) {
+ this.containers[i]._propagate("out", null, this);
+ this.containers[i].containerCache.over = 0;
+ }
+ }
+
+ }
+
+ //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
+ if(this.placeholder[0].parentNode) this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+ if(this.options.helper != "original" && this.helper && this.helper[0].parentNode) this.helper.remove();
+
+ $.extend(this, {
+ helper: null,
+ dragging: false,
+ reverting: false,
+ _noFinalSort: null
+ });
+
+ if(this.domPosition.prev) {
+ $(this.domPosition.prev).after(this.currentItem);
+ } else {
+ $(this.domPosition.parent).prepend(this.currentItem);
+ }
+
+ return true;
+
+ },
+
+ serialize: function(o) {
+
+ var items = this._getItemsAsjQuery(o && o.connected);
+ var str = []; o = o || {};
+
+ $(items).each(function() {
+ var res = ($(o.item || this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
+ if(res) str.push((o.key || res[1]+'[]')+'='+(o.key && o.expression ? res[1] : res[2]));
+ });
+
+ return str.join('&');
+
+ },
+
+ toArray: function(o) {
+
+ var items = this._getItemsAsjQuery(o && o.connected);
+ var ret = []; o = o || {};
+
+ items.each(function() { ret.push($(o.item || this).attr(o.attribute || 'id') || ''); });
+ return ret;
+
+ },
+
+ /* Be careful with the following core functions */
+ _intersectsWith: function(item) {
+
+ var x1 = this.positionAbs.left,
+ x2 = x1 + this.helperProportions.width,
+ y1 = this.positionAbs.top,
+ y2 = y1 + this.helperProportions.height;
+
+ var l = item.left,
+ r = l + item.width,
+ t = item.top,
+ b = t + item.height;
+
+ var dyClick = this.offset.click.top,
+ dxClick = this.offset.click.left;
+
+ var isOverElement = (y1 + dyClick) > t && (y1 + dyClick) < b && (x1 + dxClick) > l && (x1 + dxClick) < r;
+
+ if( this.options.tolerance == "pointer"
+ || this.options.forcePointerForContainers
+ || (this.options.tolerance != "pointer" && this.helperProportions[this.floating ? 'width' : 'height'] > item[this.floating ? 'width' : 'height'])
+ ) {
+ return isOverElement;
+ } else {
+
+ return (l < x1 + (this.helperProportions.width / 2) // Right Half
+ && x2 - (this.helperProportions.width / 2) < r // Left Half
+ && t < y1 + (this.helperProportions.height / 2) // Bottom Half
+ && y2 - (this.helperProportions.height / 2) < b ); // Top Half
+
+ }
+ },
+
+ _intersectsWithPointer: function(item) {
+
+ var isOverElementHeight = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
+ isOverElementWidth = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
+ isOverElement = isOverElementHeight && isOverElementWidth,
+ verticalDirection = this._getDragVerticalDirection(),
+ horizontalDirection = this._getDragHorizontalDirection();
+
+ if (!isOverElement)
+ return false;
+
+ return this.floating ?
+ ( ((horizontalDirection && horizontalDirection == "right") || verticalDirection == "down") ? 2 : 1 )
+ : ( verticalDirection && (verticalDirection == "down" ? 2 : 1) );
+
+ },
+
+ _intersectsWithSides: function(item) {
+
+ var isOverBottomHalf = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
+ isOverRightHalf = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
+ verticalDirection = this._getDragVerticalDirection(),
+ horizontalDirection = this._getDragHorizontalDirection();
+
+ if (this.floating && horizontalDirection) {
+ return ((horizontalDirection == "right" && isOverRightHalf) || (horizontalDirection == "left" && !isOverRightHalf));
+ } else {
+ return verticalDirection && ((verticalDirection == "down" && isOverBottomHalf) || (verticalDirection == "up" && !isOverBottomHalf));
+ }
+
+ },
+
+ _getDragVerticalDirection: function() {
+ var delta = this.positionAbs.top - this.lastPositionAbs.top;
+ return delta != 0 && (delta > 0 ? "down" : "up");
+ },
+
+ _getDragHorizontalDirection: function() {
+ var delta = this.positionAbs.left - this.lastPositionAbs.left;
+ return delta != 0 && (delta > 0 ? "right" : "left");
+ },
+
+ refresh: function(event) {
+ this._refreshItems(event);
+ this.refreshPositions();
+ },
+
+ _getItemsAsjQuery: function(connected) {
+
+ var self = this;
+ var items = [];
+ var queries = [];
+
+ if(this.options.connectWith && connected) {
+ for (var i = this.options.connectWith.length - 1; i >= 0; i--){
+ var cur = $(this.options.connectWith[i]);
+ for (var j = cur.length - 1; j >= 0; j--){
+ var inst = $.data(cur[j], 'sortable');
+ if(inst && inst != this && !inst.options.disabled) {
+ queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper"), inst]);
+ }
+ };
+ };
+ }
+
+ queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper"), this]);
+
+ for (var i = queries.length - 1; i >= 0; i--){
+ queries[i][0].each(function() {
+ items.push(this);
+ });
+ };
+
+ return $(items);
+
+ },
+
+ _removeCurrentsFromItems: function() {
+
+ var list = this.currentItem.find(":data(sortable-item)");
+
+ for (var i=0; i < this.items.length; i++) {
+
+ for (var j=0; j < list.length; j++) {
+ if(list[j] == this.items[i].item[0])
+ this.items.splice(i,1);
+ };
+
+ };
+
+ },
+
+ _refreshItems: function(event) {
+
+ this.items = [];
+ this.containers = [this];
+ var items = this.items;
+ var self = this;
+ var queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]];
+
+ if(this.options.connectWith) {
+ for (var i = this.options.connectWith.length - 1; i >= 0; i--){
+ var cur = $(this.options.connectWith[i]);
+ for (var j = cur.length - 1; j >= 0; j--){
+ var inst = $.data(cur[j], 'sortable');
+ if(inst && inst != this && !inst.options.disabled) {
+ queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
+ this.containers.push(inst);
+ }
+ };
+ };
+ }
+
+ for (var i = queries.length - 1; i >= 0; i--) {
+ var targetData = queries[i][1];
+ var _queries = queries[i][0];
+
+ for (var j=0, queriesLength = _queries.length; j < queriesLength; j++) {
+ var item = $(_queries[j]);
+
+ item.data('sortable-item', targetData); // Data for target checking (mouse manager)
+
+ items.push({
+ item: item,
+ instance: targetData,
+ width: 0, height: 0,
+ left: 0, top: 0
+ });
+ };
+ };
+
+ },
+
+ refreshPositions: function(fast) {
+
+ //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
+ if(this.offsetParent && this.helper) {
+ this.offset.parent = this._getParentOffset();
+ }
+
+ for (var i = this.items.length - 1; i >= 0; i--){
+ var item = this.items[i];
+
+ //We ignore calculating positions of all connected containers when we're not over them
+ if(item.instance != this.currentContainer && this.currentContainer && item.item[0] != this.currentItem[0])
+ continue;
+
+ var t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
+
+ if (!fast) {
+ if (this.options.accurateIntersection) {
+ item.width = t.outerWidth();
+ item.height = t.outerHeight();
+ }
+ else {
+ item.width = t[0].offsetWidth;
+ item.height = t[0].offsetHeight;
+ }
+ }
+
+ var p = t.offset();
+ item.left = p.left;
+ item.top = p.top;
+ };
+
+ if(this.options.custom && this.options.custom.refreshContainers) {
+ this.options.custom.refreshContainers.call(this);
+ } else {
+ for (var i = this.containers.length - 1; i >= 0; i--){
+ var p = this.containers[i].element.offset();
+ this.containers[i].containerCache.left = p.left;
+ this.containers[i].containerCache.top = p.top;
+ this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
+ this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
+ };
+ }
+
+ },
+
+ _createPlaceholder: function(that) {
+
+ var self = that || this, o = self.options;
+
+ if(!o.placeholder || o.placeholder.constructor == String) {
+ var className = o.placeholder;
+ o.placeholder = {
+ element: function() {
+
+ var el = $(document.createElement(self.currentItem[0].nodeName))
+ .addClass(className || self.currentItem[0].className+" ui-sortable-placeholder")
+ .removeClass('ui-sortable-helper')[0];
+
+ if(!className) {
+ el.style.visibility = "hidden";
+ document.body.appendChild(el);
+ // Name attributes are removed, otherwice causes elements to be unchecked
+ // Expando attributes also have to be removed because of stupid IE (no condition, doesn't hurt in other browsers)
+ el.innerHTML = self.currentItem[0].innerHTML.replace(/name\=\"[^\"\']+\"/g, '').replace(/jQuery[0-9]+\=\"[^\"\']+\"/g, '');
+ document.body.removeChild(el);
+ };
+
+ return el;
+ },
+ update: function(container, p) {
+ if(className && !o.forcePlaceholderSize) return;
+ if(!p.height()) { p.height(self.currentItem.innerHeight() - parseInt(self.currentItem.css('paddingTop')||0, 10) - parseInt(self.currentItem.css('paddingBottom')||0, 10)); };
+ if(!p.width()) { p.width(self.currentItem.innerWidth() - parseInt(self.currentItem.css('paddingLeft')||0, 10) - parseInt(self.currentItem.css('paddingRight')||0, 10)); };
+ }
+ };
+ }
+
+ //Create the placeholder
+ self.placeholder = $(o.placeholder.element.call(self.element, self.currentItem));
+
+ //Append it after the actual current item
+ self.currentItem.after(self.placeholder);
+
+ //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
+ o.placeholder.update(self, self.placeholder);
+
+ },
+
+ _contactContainers: function(event) {
+ for (var i = this.containers.length - 1; i >= 0; i--){
+
+ if(this._intersectsWith(this.containers[i].containerCache)) {
+ if(!this.containers[i].containerCache.over) {
+
+ if(this.currentContainer != this.containers[i]) {
+
+ //When entering a new container, we will find the item with the least distance and append our item near it
+ var dist = 10000; var itemWithLeastDistance = null; var base = this.positionAbs[this.containers[i].floating ? 'left' : 'top'];
+ for (var j = this.items.length - 1; j >= 0; j--) {
+ if(!$.ui.contains(this.containers[i].element[0], this.items[j].item[0])) continue;
+ var cur = this.items[j][this.containers[i].floating ? 'left' : 'top'];
+ if(Math.abs(cur - base) < dist) {
+ dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
+ }
+ }
+
+ if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled
+ continue;
+
+ this.currentContainer = this.containers[i];
+ itemWithLeastDistance ? this.options.sortIndicator.call(this, event, itemWithLeastDistance, null, true) : this.options.sortIndicator.call(this, event, null, this.containers[i].element, true);
+ this._propagate("change", event); //Call plugins and callbacks
+ this.containers[i]._propagate("change", event, this); //Call plugins and callbacks
+
+ //Update the placeholder
+ this.options.placeholder.update(this.currentContainer, this.placeholder);
+
+ }
+
+ this.containers[i]._propagate("over", event, this);
+ this.containers[i].containerCache.over = 1;
+ }
+ } else {
+ if(this.containers[i].containerCache.over) {
+ this.containers[i]._propagate("out", event, this);
+ this.containers[i].containerCache.over = 0;
+ }
+ }
+
+ };
+ },
+
+ _createHelper: function(event) {
+
+ var o = this.options;
+ var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper == 'clone' ? this.currentItem.clone() : this.currentItem);
+
+ if(!helper.parents('body').length) //Add the helper to the DOM if that didn't happen already
+ $(o.appendTo != 'parent' ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
+
+ if(helper[0] == this.currentItem[0])
+ this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
+
+ if(helper[0].style.width == '' || o.forceHelperSize) helper.width(this.currentItem.width());
+ if(helper[0].style.height == '' || o.forceHelperSize) helper.height(this.currentItem.height());
+
+ return helper;
+
+ },
+
+ _adjustOffsetFromHelper: function(obj) {
+ if(obj.left != undefined) this.offset.click.left = obj.left + this.margins.left;
+ if(obj.right != undefined) this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
+ if(obj.top != undefined) this.offset.click.top = obj.top + this.margins.top;
+ if(obj.bottom != undefined) this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
+ },
+
+ _getParentOffset: function() {
+
+ //Get the offsetParent and cache its position
+ this.offsetParent = this.helper.offsetParent(); var po = this.offsetParent.offset();
+
+ if((this.offsetParent[0] == document.body && $.browser.mozilla) //Ugly FF3 fix
+ || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
+ po = { top: 0, left: 0 };
+
+ return {
+ top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
+ left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
+ };
+
+ },
+
+ _getRelativeOffset: function() {
+
+ if(this.cssPosition == "relative") {
+ var p = this.currentItem.position();
+ return {
+ top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
+ left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
+ };
+ } else {
+ return { top: 0, left: 0 };
+ }
+
+ },
+
+ _cacheMargins: function() {
+ this.margins = {
+ left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
+ top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
+ };
+ },
+
+ _cacheHelperProportions: function() {
+ this.helperProportions = {
+ width: this.helper.outerWidth(),
+ height: this.helper.outerHeight()
+ };
+ },
+
+ _setContainment: function() {
+
+ var o = this.options;
+ 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.margins.left - (parseInt(this.currentItem.css("marginRight"),10) || 0),
+ ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.offset.relative.top - this.offset.parent.top - this.margins.top - (parseInt(this.currentItem.css("marginBottom"),10) || 0)
+ ];
+
+ if(!(/^(document|window|parent)$/).test(o.containment)) {
+ var ce = $(o.containment)[0];
+ var co = $(o.containment).offset();
+ var over = ($(ce).css("overflow") != 'hidden');
+
+ this.containment = [
+ co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left - this.margins.left,
+ co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top - this.margins.top,
+ co.left + (over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left - this.margins.left,
+ co.top + (over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top - this.margins.top
+ ];
+ }
+
+ },
+
+ _convertPositionTo: function(d, pos) {
+
+ if(!pos) pos = this.position;
+ var mod = d == "absolute" ? 1 : -1;
+ var scroll = this[(this.cssPosition == 'absolute' ? 'offset' : 'scroll')+'Parent'], scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+ 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.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * 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.scrollParent.scrollLeft() : ( scrollIsRootNode ? 0 : scroll.scrollLeft() ) ) * mod
+ + this.margins.left * mod //Add the margin (you don't want the margin counting in intersection methods)
+ )
+ };
+ },
+
+ _generatePosition: function(event) {
+
+ var o = this.options, scroll = this[(this.cssPosition == 'absolute' ? 'offset' : 'scroll')+'Parent'], scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+ var position = {
+ top: (
+ event.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.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) )
+ ),
+ left: (
+ event.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.scrollParent.scrollLeft() : ( scrollIsRootNode ? 0 : scroll.scrollLeft() ) )
+ )
+ };
+
+ 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.helperProportions.width > this.containment[2]) position.left = this.containment[2] - this.helperProportions.width;
+ if(position.top + this.helperProportions.height > this.containment[3]) position.top = this.containment[3] - this.helperProportions.height;
+ }
+
+ 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;
+ },
+
+ _rearrange: function(event, i, a, hardRefresh) {
+
+ a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction == 'down' ? i.item[0] : i.item[0].nextSibling));
+
+ //Various things done here to improve the performance:
+ // 1. we create a setTimeout, that calls refreshPositions
+ // 2. on the instance, we have a counter variable, that get's higher after every append
+ // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
+ // 4. this lets only the last addition to the timeout stack through
+ this.counter = this.counter ? ++this.counter : 1;
+ var self = this, counter = this.counter;
+
+ window.setTimeout(function() {
+ if(counter == self.counter) self.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
+ },0);
+
+ },
+
+ _clear: function(event, noPropagation) {
+
+ this.reverting = false;
+
+ //We first have to update the dom position of the actual currentItem
+ if(!this._noFinalSort) this.placeholder.before(this.currentItem);
+ this._noFinalSort = null;
+
+ if(this.helper[0] == this.currentItem[0]) {
+ for(var i in this._storedCSS) {
+ if(this._storedCSS[i] == 'auto' || this._storedCSS[i] == 'static') this._storedCSS[i] = '';
+ }
+ this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
+ } else {
+ this.currentItem.show();
+ }
+
+ if(this.domPosition.prev != this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent != this.currentItem.parent()[0]) this._propagate("update", event, null, noPropagation); //Trigger update callback if the DOM position has changed
+ if(!$.ui.contains(this.element[0], this.currentItem[0])) { //Node was moved out of the current element
+ this._propagate("remove", event, null, noPropagation);
+ for (var i = this.containers.length - 1; i >= 0; i--){
+ if($.ui.contains(this.containers[i].element[0], this.currentItem[0])) {
+ this.containers[i]._propagate("update", event, this, noPropagation);
+ this.containers[i]._propagate("receive", event, this, noPropagation);
+ }
+ };
+ };
+
+ //Post events to containers
+ for (var i = this.containers.length - 1; i >= 0; i--){
+ this.containers[i]._propagate("deactivate", event, this, noPropagation);
+ if(this.containers[i].containerCache.over) {
+ this.containers[i]._propagate("out", event, this);
+ this.containers[i].containerCache.over = 0;
+ }
+ }
+
+ this.dragging = false;
+ if(this.cancelHelperRemoval) {
+ this._propagate("beforeStop", event, null, noPropagation);
+ this._propagate("stop", event, null, noPropagation);
+ return false;
+ }
+
+ this._propagate("beforeStop", event, null, noPropagation);
+
+ //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
+ this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+
+ if(this.options.helper != "original") this.helper.remove(); this.helper = null;
+ this._propagate("stop", event, null, noPropagation);
+
+ return true;
+
+ },
+
+ _propagate: function(n, event, inst, noPropagation) {
+ $.ui.plugin.call(this, n, [event, this._ui(inst)]);
+ var dontCancel = !noPropagation ? this.element.triggerHandler(n == "sort" ? n : "sort"+n, [event, this._ui(inst)], this.options[n]) : true;
+ if(dontCancel === false) this.cancel();
+ },
+
+ plugins: {},
+
+ _ui: function(inst) {
+ var self = inst || this;
+ return {
+ helper: self.helper,
+ placeholder: self.placeholder || $([]),
+ position: self.position,
+ absolutePosition: self.positionAbs,
+ item: self.currentItem,
+ sender: inst ? inst.element : null
+ };
+ }
+
+}));
+
+$.extend($.ui.sortable, {
+ getter: "serialize toArray",
+ version: "1.6",
+ defaults: {
+ accurateIntersection: true,
+ appendTo: "parent",
+ cancel: ":input",
+ delay: 0,
+ distance: 1,
+ dropOnEmpty: true,
+ forcePlaceholderSize: false,
+ forceHelperSize: false,
+ helper: "original",
+ items: '> *',
+ scope: "default",
+ scroll: true,
+ scrollSensitivity: 20,
+ scrollSpeed: 20,
+ sortIndicator: $.ui.sortable.prototype._rearrange,
+ tolerance: "default",
+ zIndex: 1000
+ }
+});
+
+/*
+ * Sortable Extensions
+ */
+
+$.ui.plugin.add("sortable", "cursor", {
+ start: function(event, ui) {
+ var t = $('body'), i = $(this).data('sortable');
+ if (t.css("cursor")) i.options._cursor = t.css("cursor");
+ t.css("cursor", i.options.cursor);
+ },
+ beforeStop: function(event, ui) {
+ var i = $(this).data('sortable');
+ if (i.options._cursor) $('body').css("cursor", i.options._cursor);
+ }
+});
+
+$.ui.plugin.add("sortable", "opacity", {
+ start: function(event, ui) {
+ var t = ui.helper, i = $(this).data('sortable');
+ if(t.css("opacity")) i.options._opacity = t.css("opacity");
+ t.css('opacity', i.options.opacity);
+ },
+ beforeStop: function(event, ui) {
+ var i = $(this).data('sortable');
+ if(i.options._opacity) $(ui.helper).css('opacity', i.options._opacity);
+ }
+});
+
+$.ui.plugin.add("sortable", "scroll", {
+ start: function(event, ui) {
+ var i = $(this).data("sortable"), o = i.options;
+ if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') i.overflowOffset = i.scrollParent.offset();
+ },
+ sort: function(event, ui) {
+
+ var i = $(this).data("sortable"), o = i.options, scrolled = false;
+
+ if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') {
+
+ if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
+ i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
+ else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity)
+ i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
+
+ if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
+ i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
+ else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity)
+ i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
+
+ } else {
+
+ if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
+ scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+ else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
+ scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+
+ if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
+ scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
+ else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
+ scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
+
+ }
+
+ if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
+ $.ui.ddmanager.prepareOffsets(i, event);
+
+
+
+ //This is a special case where we need to modify a offset calculated on start, since the following happened:
+ // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
+ // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
+ // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
+ if(scrolled !== false && i.cssPosition == 'absolute' && i.scrollParent[0] != document && $.ui.contains(i.scrollParent[0], i.offsetParent[0])) {
+ i.offset.parent = i._getParentOffset();
+ }
+
+ // This is another very weird special case that only happens for relative elements:
+ // 1. If the css position is relative
+ // 2. and the scroll parent is the document or similar to the offset parent
+ // we have to refresh the relative offset during the scroll so there are no jumps
+ if(scrolled !== false && i.cssPosition == 'relative' && !(i.scrollParent[0] != document && i.scrollParent[0] != i.offsetParent[0])) {
+ i.offset.relative = i._getRelativeOffset();
+ }
+
+ }
+});
+
+$.ui.plugin.add("sortable", "zIndex", {
+ start: function(event, ui) {
+ var t = ui.helper, i = $(this).data('sortable');
+ if(t.css("zIndex")) i.options._zIndex = t.css("zIndex");
+ t.css('zIndex', i.options.zIndex);
+ },
+ beforeStop: function(event, ui) {
+ var i = $(this).data('sortable');
+ if(i.options._zIndex) $(ui.helper).css('zIndex', i.options._zIndex == 'auto' ? '' : i.options._zIndex);
+ }
+});
+
+})(jQuery);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/app/jquery/jquery.growfield.js Tue Jun 23 20:54:03 2009 +0200
@@ -0,0 +1,581 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2009 Johann Kuindji
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author Johann Kuindji, Dmitriy Likhten
+ * http://code.google.com/p/jquery-growfield/
+ */
+(function($) {
+if ($.support === undefined) {
+ $.support = { boxModel: $.boxModel };
+}
+var windowLoaded = false;
+$(window).one('load', function(){ windowLoaded=true; });
+
+// we need to adapt jquery animations for textareas.
+// by default, it changes display to 'block' if we're trying to
+// change width or height. We have to prevent this.
+// THIS WILL NOT ALTER JQUERY ORIGINAL BEHAVIORS, IT WILL HOWEVER ADD
+// SOME SO THAT GROWFIELD ANIMATIONS WORK CORRECTLY.
+$.fx.prototype.originalUpdate = $.fx.prototype.update;
+$.fx.prototype.update = false;
+$.fx.prototype.update = function () {
+ if (!this.options.inline) {
+ return this.originalUpdate.call(this);
+ }
+ if ( this.options.step ) {
+ this.options.step.call( this.elem, this.now, this );
+ }
+ (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
+};
+
+$.growfield = function(dom,options){
+ // Extend ptt(prototype) with our own private variables/
+ // shared's functions are re-referenced and not cloned so
+ // memory is kept at a minimum.
+ var that = $.extend({
+ dom: dom,
+ o: $(dom),
+ enabled: false,
+ dummy: false,
+ busy: false,
+ initial: false,
+ sizseRelated: false,
+ prevH: false,
+ firstH: false,
+ restoreH: false,
+ opt: $.extend({},$.fn.growfield.defaults,options)
+ },$.growfield.ptt);
+
+ return that;
+};
+
+//-----------------------------------------------------
+// This is the base class for all $.growfield objects
+// (their prototype)
+//-----------------------------------------------------
+$.growfield.ptt = (function(){
+ //-----------------------------------------------------
+ //EVENT HANDLERS for dealing with the growfield object
+ //-----------------------------------------------------
+ var manualKeyUp = function(e) {
+ var obj = e.data;
+ if (e.ctrlKey && (e.keyCode == 38 || e.keyCode == 40)){
+ obj.update(
+ obj.o.outerHeight() + (obj.opt.step*( e.keyCode==38? -1: 1)),
+ obj.opt.animate
+ );
+ }
+ };
+
+ var keyUp = function(e) {
+ var obj = e.data;
+ if (!obj.busy){
+ if ($.inArray(e.keyCode, [37,38,39,40]) === -1) {
+ obj.update(obj.getDummyHeight(), obj.opt.animate);
+ }
+ }
+ return true;
+ };
+
+ var focus = function(e) {
+ var obj = e.data;
+ if (!obj.busy) {
+ if (obj.opt.restore) {
+ obj.update(obj.dummy ? obj.getDummyHeight() : obj.restoreH, obj.opt.animate, 'growback');
+ }
+ }
+ };
+
+ var blur = function(e) {
+ var obj = e.data;
+ if (!obj.busy) {
+ if (obj.opt.restore) {
+ obj.update(0, obj.opt.animate, 'restore');
+ }
+ }
+ };
+
+ var prepareSizeRelated = function(e) {
+ var obj = e.data;
+ var o = obj.o;
+ var opt = obj.opt;
+
+ if (!opt.min) {
+ opt.min = parseInt(o.css('min-height'), 10) || obj.firstH || parseInt(o.height(), 10) || 20;
+ if (opt.min <= 0) {
+ opt.min = 20; // opera fix
+ }
+ if (!obj.firstH) {
+ obj.firstH = opt.min;
+ }
+ }
+ if (!opt.max) {
+ opt.max = parseInt(o.css('max-height'), 10) || false;
+ if (opt.max <= 0) {
+ opt.max = false; // opera fix
+ }
+ }
+ if (!opt.step) {
+ opt.step = parseInt(o.css('line-height'), 10) || parseInt(o.css('font-size'), 10) || 20;
+ }
+
+ var sr = {
+ pt: parseInt(o.css('paddingTop'), 10)||0,
+ pb: parseInt(o.css('paddingBottom'), 10)||0,
+ bt: parseInt(o.css('borderTopWidth'), 10)||0,
+ bb: parseInt(o.css('borderBottomWidth'), 10)||0,
+ lh: parseInt(o.css('lineHeight'), 10) || false,
+ fs: parseInt(o.css('fontSize'), 10) || false
+ };
+
+ obj.sizeRelated = sr;
+ };
+
+ /**
+ * Create a dummy if one does not yet exist.
+ */
+ var createDummy = function(e) {
+ var obj = e.data;
+ if(!obj.dummy){
+ var val = obj.o.val();
+ // we need dummy to calculate scrollHeight
+ // (there are some tricks that can't be applied to the textarea itself, otherwise user will see it)
+ // Also, dummy must be a textarea too, and must be placed at the same position in DOM
+ // in order to keep all the inherited styles
+ var dummy = obj.o.clone();
+ dummy.addClass('growfieldDummy');
+ dummy.attr('tabindex', -9999);
+ dummy.css({
+ position: 'absolute',
+ left: -9999,
+ top: 0,
+ height: '20px',
+ resize: 'none'});
+ // The dummy must be inserted after otherwise google chrome will
+ // focus on the dummy instead of on the actual text area, focus will always
+ // be lost.
+ dummy.insertAfter(obj.o);
+ dummy.show();
+
+ // if there is no initial value, we have to add some text, otherwise textarea will jitter
+ // at the first keydown
+ if (!val) {
+ dummy.val('dummy text');
+ }
+ obj.dummy = dummy;
+ // lets set the initial height
+ obj.update((!$.trim(val) || obj.opt.restore) ? 0 : obj.getDummyHeight(), false);
+ }
+ };
+
+ /**
+ * Remove the dummy if one exists
+ */
+ var removeDummy = function(e) {
+ obj = e.data;
+ if(obj.dummy){
+ obj.dummy.remove();
+ delete obj.dummy;
+ }
+ };
+
+ //-----------------------------------------------------
+ // END EVENT HANDLERS
+ //-----------------------------------------------------
+
+ // This will bind to $(document).ready if the height is loaded
+ // or a window.load event already occurred.
+ // OR it will just bind to the window.load event.
+ var executeWhenReady = function(data,fn){
+ if (data.o.height() !== 0 || windowLoaded) {
+ $(document).ready(function(){
+ fn({data:data});
+ });
+ }
+ else {
+ $(window).one('load', data, fn);
+ }
+ };
+
+ //-----------------------------------------------------
+ // Public methods.
+ //-----------------------------------------------------
+ var that = {
+ // Toggle the functionality.
+ // enable or true will enable growfield
+ // disable or false will disable growfield
+ toggle: function(mode) {
+ if ((mode=='disable' || mode===false)&&this.enabled) {
+ this.unbind();
+ }
+ else if ((mode=='enable' || mode===true)&&!this.enabled) {
+ this.bind();
+ }
+ return this;
+ },
+
+ // Bind all growfield events to the object.
+ bind: function(){
+ executeWhenReady(this,prepareSizeRelated);
+ var opt = this.opt;
+ var o = this.o;
+
+ // auto mode, textarea grows as you type
+ if (opt.auto) {
+
+ o.bind('keyup.growfield', this, keyUp);
+ this.initial = {
+ overflow: this.o.css('overflow'),
+ cssResize: this.o.css('resize')
+ };
+ // We want to ensure that safari and google chrome do not allow
+ // the user to drag-to-resize the field. This should only be enabled
+ // if auto mode is disabled.
+ if ($.browser.safari) {
+ o.css('resize', 'none');
+ }
+ o.css('overflow','hidden');
+
+ o.bind('focus.growfield', this, createDummy);
+ // all styles must be loaded before prepare elements
+ // we need to ensure the dummy exists at least for a short
+ // time so that we can calculate the initial state...
+ executeWhenReady(this, createDummy);
+ executeWhenReady(this, removeDummy);
+ }
+ // manual mode, textarea grows as you type ctrl + up|down
+ else {
+ o.bind('keydown.growfield', this, manualKeyUp);
+ o.css('overflow-y', 'auto');
+ executeWhenReady(this,function(e){
+ e.data.update(e.data.o.height());
+ });
+ }
+ o.bind('focus.growfield', this, focus);
+ o.bind('blur.growfield', this, blur);
+ o.bind('blur.growfield', this, removeDummy);
+
+ // Custom events provided in options
+ if (opt.onHeightChange) {
+ o.bind('onHeightChange.growfield', opt.onHeightChange);
+ }
+ if (opt.onRestore) {
+ o.bind('onRestore.growfield', opt.onRestore);
+ }
+ if (opt.onGrowBack) {
+ o.bind('onGrowBack.growfield', opt.onGrowBack);
+ }
+
+ this.enabled = true;
+
+ return this;
+ },
+
+ // Unbind all growfield events from the object (including custom events)
+ unbind: function() {
+ removeDummy({data:this});
+ this.o.unbind('.growfield');
+ this.o.css('overflow', this.initial.overflow);
+ if ($.browser.safari) {
+ this.o.css('resize', this.initial.cssResize);
+ }
+ this.enabled = false;
+
+ return this;
+ },
+
+ // Trigger custom events according to updateMode
+ triggerEvents: function(updateMode) {
+ var o = this.o;
+ o.trigger('onHeightChange.growfield');
+ if (updateMode == 'restore') {
+ o.trigger('onRestore.growfield');
+ }
+ if (updateMode == 'growback') {
+ o.trigger('onGrowBack.growfield');
+ }
+ },
+
+ update: function(h, animate, updateMode) {
+ var sr = this.sizeRelated;
+ var val = this.o.val();
+ var opt = this.opt;
+ var dom = this.dom;
+ var o = this.o;
+ var th = this;
+ var prev = this.prevH;
+ var noHidden = !opt.auto;
+ var noFocus = opt.auto;
+
+ h = this.convertHeight(Math.round(h), 'inner');
+ // get the right height according to min and max value
+ h = opt.min > h ? opt.min :
+ opt.max && h > opt.max ? opt.max :
+ opt.auto && !val ? opt.min : h;
+
+ if (opt.max && opt.auto) {
+ if (prev != opt.max && h == opt.max) { // now we reached maximum height
+ o.css('overflow-y', 'scroll');
+ if (!opt.animate) {
+ o.focus(); // browsers do loose cursor after changing overflow :(
+ }
+ noHidden = true;
+ noFocus = false;
+ }
+ if (prev == opt.max && h < opt.max) {
+ o.css('overflow-y', 'hidden');
+ if (!opt.animate) {
+ o.focus();
+ }
+ noFocus = false;
+ }
+ }
+
+ if (h == prev) {
+ return true;
+ }
+ // in case of restore in manual mode we have to store
+ // previous height (we can't get it from dummy)
+ if (!opt.auto && updateMode == 'restore') {
+ this.restoreH = this.convertHeight(this.prevH, 'outer');
+ }
+ this.prevH = h;
+
+ if (animate) {
+ th.busy = true;
+ o.animate({height: h}, {
+ duration: opt.animate,
+ easing: ($.easing ? opt.easing : null),
+ overflow: null,
+ inline: true, // this option isn't jquery's. I added it by myself, see above
+ complete: function(){
+ // safari/chrome fix
+ // somehow textarea turns to overflow:scroll after animation
+ // i counldn't find it in jquery fx :(, so it looks like some bug
+ if (!noHidden) {
+ o.css('overflow', 'hidden');
+ }
+ // but if we still need to change overflow (due to opt.max option)
+ // we have to invoke focus() event, otherwise browser will loose cursor
+ if (!noFocus && updateMode != 'restore') {
+ o.focus();
+ }
+ if (updateMode == 'growback') {
+ dom.scrollTop = dom.scrollHeight;
+ }
+ th.busy = false;
+ th.triggerEvents(updateMode);
+ },
+ queue: false
+ });
+ } else {
+ dom.style.height = h+'px';
+ this.triggerEvents(updateMode);
+ }
+ },
+
+ getDummyHeight: function() {
+ var val = this.o.val();
+ var h = 0;
+ var sr = this.sizeRelated;
+ var add = "\n111\n111";
+
+ // Safari has some defect with double new line symbol at the end
+ // It inserts additional new line even if you have only one
+ // But that't not the point :)
+ // Another question is how much pixels to keep at the bottom of textarea.
+ // We'll kill many rabbits at the same time by adding two new lines at the end
+ // (but if we have font-size and line-height defined, we'll add two line-heights)
+ if ($.browser.safari) {
+ val = val.substring(0, val.length-1); // safari has an additional new line ;(
+ }
+
+ if (!sr.lh || !sr.fs) {
+ val += add;
+ }
+
+ this.dummy.val(val);
+
+ // IE requires to change height value in order to recalculate scrollHeight.
+ // otherwise it stops recalculating scrollHeight after some magical number of pixels
+ if ($.browser.msie) {
+ this.dummy[0].style.height = this.dummy[0].scrollHeight+'px';
+ }
+
+ h = this.dummy[0].scrollHeight;
+
+ // if line-height is greater than font-size we'll add line-height + font-size
+ // otherwise font-size * 2
+ // there is no special logic in this behavior, it's been developed from visual testing
+ if (sr.lh && sr.fs) {
+ h += sr.lh > sr.fs ? sr.lh+sr.fs : sr.fs * 2;
+ }
+
+ // now we have to minimize dummy back, or we'll get wrong scrollHeight next time
+ //if ($.browser.msie) {
+ // this.dummy[0].style.height = '20px'; // random number
+ //}
+
+ return h;
+ },
+
+ convertHeight: function(h, to) {
+ var sr = this.sizeRelated, mod = (to=='inner' ? -1 : 1), bm = $.support.boxModel;
+ // what we get here in 'h' is scrollHeight value.
+ // so we need to subtract paddings not because of boxModel,
+ // but only if browser includes them to the scroll height (which is not defined by box model)
+ return h
+ + (bm ? sr.bt : 0) * mod
+ + (bm ? sr.bb : 0) * mod
+ + (bm ? sr.pt : 0) * mod
+ + (bm ? sr.pb : 0) * mod;
+ }
+
+ };
+
+ return that;
+})();
+
+/**
+ * The growfield function. This will make a textarea a growing text area.
+ *
+ * @param {Object} options - See API for details on possible paramaters.
+ */
+$.fn.growfield = function(options) {
+ // enable/disable is same thing as true/false
+ switch(options){
+ case 'enable':
+ options = true;
+ break;
+ case 'disable':
+ options = false;
+ break;
+ }
+
+ // we need to know what was passed as the options
+ var tp = typeof options;
+
+ // These variables are used to reduce string comparisons
+ // happening over and over.
+ var conditions = {
+ bool: tp == 'boolean',
+ string: tp == 'string',
+ object: tp == 'object',
+ restart: options == 'restart',
+ destroy: options == 'destroy'
+ };
+
+ // If the type of the options is a string
+ // and is not one of the pre-defined ones, then
+ // options is a preset.
+ if(conditions.string && !conditions.destroy && !conditions.restart){
+ options = $.fn.growfield.presets[options];
+ // change to new conditions
+ conditions.string = false;
+ conditions.object = true;
+ }
+
+ // completely remove growfield from the dom elements
+ if (conditions.destroy) {
+ this.each(function() {
+ var self = $(this);
+ var gf = self.data('growfield');
+ if (gf !== undefined) {
+ gf.unbind();
+ self.removeData('growfield');
+ }
+ });
+ }
+ // Apply growfield
+ else {
+ var textareaRegex = /textarea/i;
+ this.each(function() {
+ // only deal with textareas which are not dummy fields.
+ if (textareaRegex.test(this.tagName) && !$(this).hasClass('growfieldDummy')) {
+ var o = $(this);
+ var gf = o.data('growfield');
+ // Create the new options
+ if (gf === undefined) {
+ gf = $.growfield(this,options);
+ o.data('growfield', gf);
+
+ // Bind only if the options is not a boolean
+ // or is not "false". Because options = a false boolean
+ // indicates intial bind should not happen.
+ if(!conditions.bool || options){
+ gf.bind();
+ }
+ }
+ // Otherwise apply actions based on the options provided
+ else {
+ // If new options provided, set them
+ if(conditions.object && options) {
+ $.extend(gf.opt,options);
+ }
+ // If toggling enable/disable then do it
+ else if (conditions.bool) {
+ gf.toggle(options);
+ }
+ // If restarting, restart
+ else if (conditions.restart) {
+ gf.unbind();
+ gf.bind();
+ }
+ }
+ }
+ });
+ }
+
+ return this;
+};
+
+/**
+ * These are the default options to use, unless specified when invoking growfield.
+ */
+$.fn.growfield.defaults ={
+ // Should the growfield automatically expand?
+ auto: true,
+ // The animation speed for expanding (false = off)
+ animate: 100,
+ // The easiny function to use, if the jquery.easing plugin is not present during
+ // execution, this will always be treated as null regardless of the set value
+ easing: null,
+ // The minimum height (defaults to CSS min-height, or the current height of the element)
+ min: false,
+ // The maximum height (defaults to CSS max-height, or unlimited)
+ max: false,
+ // Should the element restore to it's original size after focus is lost?
+ restore: false,
+ // How many pixels to expand when the user is about to have to scroll. Defaults to 1 line.
+ step: false
+};
+
+/**
+ * These are presets. The presets are indexed by name containing different preset
+ * option objects. When growfield is invoked with the preset's name, that options object
+ * is loaded without having to be specified each time.
+ */
+$.fn.growfield.presets = {};
+
+})(jQuery);
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/app/soc/content/css/ui.all.css Tue Jun 23 20:54:03 2009 +0200
@@ -0,0 +1,610 @@
+/*
+ * jQuery UI screen structure and presentation
+ * This CSS file was generated by ThemeRoller, a Filament Group Project for jQuery UI
+ * Author: Scott Jehl, scott@filamentgroup.com, http://www.filamentgroup.com
+ * Visit ThemeRoller.com
+*/
+
+/*
+ * Note: If your ThemeRoller settings have a font size set in ems, your components will scale according to their parent element's font size.
+ * As a rule of thumb, set your body's font size to 62.5% to make 1em = 10px.
+ * body {font-size: 62.5%;}
+*/
+
+
+
+/*UI accordion*/
+.ui-accordion {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif;
+ font-size: 1.1em;
+ border-bottom: 1px solid #cccccc;
+}
+.ui-accordion-group {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ border: 1px solid #cccccc;
+ border-bottom: none;
+}
+.ui-accordion-header {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ cursor: pointer;
+ background: #f6f6f6 url(images/f6f6f6_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+}
+.ui-accordion-header a {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ display: block;
+ font-size: 1em;
+ font-weight: bold;
+ text-decoration: none;
+ padding: .5em .5em .5em 1.7em;
+ color: #1c94c4;
+ background: url(images/ef8c08_7x7_arrow_right.gif) .5em 50% no-repeat;
+}
+.ui-accordion-header a:hover {
+ background: url(images/ef8c08_7x7_arrow_right.gif) .5em 50% no-repeat;
+ color: #c77405;
+}
+.ui-accordion-header:hover {
+ background: #fdf5ce url(images/fdf5ce_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ color: #c77405;
+}
+.selected .ui-accordion-header, .selected .ui-accordion-header:hover {
+ background: #ffffff url(images/ffffff_40x100_textures_02_glass_65.png) 0 50% repeat-x;
+}
+.selected .ui-accordion-header a, .selected .ui-accordion-header a:hover {
+ color: #eb8f00;
+ background: url(images/ef8c08_7x7_arrow_down.gif) .5em 50% no-repeat;
+}
+.ui-accordion-content {
+ background: #eeeeee url(images/eeeeee_40x100_textures_03_highlight_soft_100.png) 0 0 repeat-x;
+ color: #333333;
+ font-size: 1em;
+}
+.ui-accordion-content p {
+ padding: 1em 1.7em 0.6em;
+}
+
+
+
+
+
+
+/*UI tabs*/
+.ui-tabs-nav {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif;
+ font-size: 1.1em;
+ float: left;
+ position: relative;
+ z-index: 1;
+ border-right: 1px solid #cccccc;
+ bottom: -1px;
+}
+.ui-tabs-nav ul {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+}
+.ui-tabs-nav li {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ float: left;
+ border: 1px solid #cccccc;
+ border-right: none;
+}
+.ui-tabs-nav li a {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ float: left;
+ font-size: 1em;
+ font-weight: bold;
+ text-decoration: none;
+ padding: .5em 1.7em;
+ color: #1c94c4;
+ background: #f6f6f6 url(images/f6f6f6_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+}
+.ui-tabs-nav li a:hover {
+ background: #fdf5ce url(images/fdf5ce_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ color: #c77405;
+}
+.ui-tabs-nav li.ui-tabs-selected {
+ border-bottom-color: #ffffff;
+}
+.ui-tabs-nav li.ui-tabs-selected a, .ui-tabs-nav li.ui-tabs-selected a:hover {
+ background: #ffffff url(images/ffffff_40x100_textures_02_glass_65.png) 0 50% repeat-x;
+ color: #eb8f00;
+}
+.ui-tabs-panel {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif;
+ clear:left;
+ border: 1px solid #cccccc;
+ background: #eeeeee url(images/eeeeee_40x100_textures_03_highlight_soft_100.png) 0 0 repeat-x;
+ color: #333333;
+ padding: 1.5em 1.7em;
+ font-size: 1.1em;
+}
+.ui-tabs-hide {
+ display: none;/* for accessible hiding: position: absolute; left: -99999999px*/;
+}
+
+
+
+
+
+/*slider*/
+.ui-slider {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif;
+ font-size: 1.1em;
+ background: #eeeeee url(images/eeeeee_40x100_textures_03_highlight_soft_100.png) 0 0 repeat-x;
+ border: 1px solid #dddddd;
+ height: .8em;
+ position: relative;
+}
+.ui-slider-handle {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ position: absolute;
+ z-index: 2;
+ top: -3px;
+ width: 1.2em;
+ height: 1.2em;
+ background: #f6f6f6 url(images/f6f6f6_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ border: 1px solid #cccccc;
+}
+.ui-slider-handle:hover {
+ background: #fdf5ce url(images/fdf5ce_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ border: 1px solid #fbcb09;
+}
+.ui-slider-handle-active, .ui-slider-handle-active:hover {
+ background: #ffffff url(images/ffffff_40x100_textures_02_glass_65.png) 0 50% repeat-x;
+ border: 1px solid #fbd850;
+}
+.ui-slider-range {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ height: .8em;
+ background: #fdf5ce url(images/fdf5ce_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ position: absolute;
+ border: 1px solid #cccccc;
+ border-left: 0;
+ border-right: 0;
+ top: -1px;
+ z-index: 1;
+ opacity:.7;
+ filter:Alpha(Opacity=70);
+}
+
+
+
+
+
+
+/*dialog*/
+.ui-dialog {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif;
+ font-size: 1.1em;
+ background: #eeeeee url(images/eeeeee_40x100_textures_03_highlight_soft_100.png) 0 0 repeat-x;
+ color: #333333;
+ border: 4px solid #dddddd;
+ position: relative;
+}
+.ui-resizable-handle {
+ position: absolute;
+ font-size: 0.1px;
+ z-index: 99999;
+}
+.ui-resizable .ui-resizable-handle {
+ display: block;
+}
+body .ui-resizable-disabled .ui-resizable-handle { display: none; } /* use 'body' to make it more specific (css order) */
+body .ui-resizable-autohide .ui-resizable-handle { display: none; } /* use 'body' to make it more specific (css order) */
+.ui-resizable-n {
+ cursor: n-resize;
+ height: 7px;
+ width: 100%;
+ top: -5px;
+ left: 0px;
+}
+.ui-resizable-s {
+ cursor: s-resize;
+ height: 7px;
+ width: 100%;
+ bottom: -5px;
+ left: 0px;
+}
+.ui-resizable-e {
+ cursor: e-resize;
+ width: 7px;
+ right: -5px;
+ top: 0px;
+ height: 100%;
+}
+.ui-resizable-w {
+ cursor: w-resize;
+ width: 7px;
+ left: -5px;
+ top: 0px;
+ height: 100%;
+}
+.ui-resizable-se {
+ cursor: se-resize;
+ width: 13px;
+ height: 13px;
+ right: 0px;
+ bottom: 0px;
+ background: url(images/222222_11x11_icon_resize_se.gif) no-repeat 0 0;
+}
+.ui-resizable-sw {
+ cursor: sw-resize;
+ width: 9px;
+ height: 9px;
+ left: 0px;
+ bottom: 0px;
+}
+.ui-resizable-nw {
+ cursor: nw-resize;
+ width: 9px;
+ height: 9px;
+ left: 0px;
+ top: 0px;
+}
+.ui-resizable-ne {
+ cursor: ne-resize;
+ width: 9px;
+ height: 9px;
+ right: 0px;
+ top: 0px;
+}
+.ui-dialog-titlebar {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ padding: .5em 1.5em .5em 1em;
+ color: #1c94c4;
+ background: #f6f6f6 url(images/f6f6f6_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ border-bottom: 1px solid #cccccc;
+ font-size: 1em;
+ font-weight: bold;
+ position: relative;
+}
+.ui-dialog-title {}
+.ui-dialog-titlebar-close {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ background: url(images/ef8c08_11x11_icon_close.gif) 0 0 no-repeat;
+ position: absolute;
+ right: 8px;
+ top: .7em;
+ width: 11px;
+ height: 11px;
+ z-index: 100;
+}
+.ui-dialog-titlebar-close-hover, .ui-dialog-titlebar-close:hover {
+ background: url(images/ef8c08_11x11_icon_close.gif) 0 0 no-repeat;
+}
+.ui-dialog-titlebar-close:active {
+ background: url(images/ef8c08_11x11_icon_close.gif) 0 0 no-repeat;
+}
+.ui-dialog-titlebar-close span {
+ display: none;
+}
+.ui-dialog-content {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ color: #333333;
+ padding: 1.5em 1.7em;
+}
+.ui-dialog-buttonpane {
+ position: absolute;
+ bottom: 0;
+ width: 100%;
+ text-align: left;
+ border-top: 1px solid #dddddd;
+ background: #eeeeee;
+}
+.ui-dialog-buttonpane button {
+ margin: .5em 0 .5em 8px;
+ color: #1c94c4;
+ background: #f6f6f6 url(images/f6f6f6_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ font-size: 1em;
+ border: 1px solid #cccccc;
+ cursor: pointer;
+ padding: .2em .6em .3em .6em;
+ line-height: 1.4em;
+}
+.ui-dialog-buttonpane button:hover {
+ color: #c77405;
+ background: #fdf5ce url(images/fdf5ce_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ border: 1px solid #fbcb09;
+}
+.ui-dialog-buttonpane button:active {
+ color: #eb8f00;
+ background: #ffffff url(images/ffffff_40x100_textures_02_glass_65.png) 0 50% repeat-x;
+ border: 1px solid #fbd850;
+}
+/* This file skins dialog */
+.ui-dialog.ui-draggable .ui-dialog-titlebar,
+.ui-dialog.ui-draggable .ui-dialog-titlebar {
+ cursor: move;
+}
+
+
+
+
+
+
+
+/*datepicker*/
+/* Main Style Sheet for jQuery UI date picker */
+.ui-datepicker-div, .ui-datepicker-inline, #ui-datepicker-div {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif;
+ background: #eeeeee url(images/eeeeee_40x100_textures_03_highlight_soft_100.png) 0 0 repeat-x;
+ font-size: 1.1em;
+ border: 4px solid #dddddd;
+ width: 15.5em;
+ padding: 2.5em .5em .5em .5em;
+ position: relative;
+}
+.ui-datepicker-div, #ui-datepicker-div {
+ z-index: 9999; /*must have*/
+ display: none;
+}
+.ui-datepicker-inline {
+ float: left;
+ display: block;
+}
+.ui-datepicker-control {
+ display: none;
+}
+.ui-datepicker-current {
+ display: none;
+}
+.ui-datepicker-next, .ui-datepicker-prev {
+ position: absolute;
+ left: .5em;
+ top: .5em;
+ background: #f6f6f6 url(images/f6f6f6_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+}
+.ui-datepicker-next {
+ left: 14.6em;
+}
+.ui-datepicker-next:hover, .ui-datepicker-prev:hover {
+ background: #fdf5ce url(images/fdf5ce_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+}
+.ui-datepicker-next a, .ui-datepicker-prev a {
+ text-indent: -999999px;
+ width: 1.3em;
+ height: 1.4em;
+ display: block;
+ font-size: 1em;
+ background: url(images/ef8c08_7x7_arrow_left.gif) 50% 50% no-repeat;
+ border: 1px solid #cccccc;
+ cursor: pointer;
+}
+.ui-datepicker-next a {
+ background: url(images/ef8c08_7x7_arrow_right.gif) 50% 50% no-repeat;
+}
+.ui-datepicker-prev a:hover {
+ background: url(images/ef8c08_7x7_arrow_left.gif) 50% 50% no-repeat;
+}
+.ui-datepicker-next a:hover {
+ background: url(images/ef8c08_7x7_arrow_right.gif) 50% 50% no-repeat;
+}
+.ui-datepicker-prev a:active {
+ background: url(images/ef8c08_7x7_arrow_left.gif) 50% 50% no-repeat;
+}
+.ui-datepicker-next a:active {
+ background: url(images/ef8c08_7x7_arrow_right.gif) 50% 50% no-repeat;
+}
+.ui-datepicker-header select {
+ border: 1px solid #cccccc;
+ color: #1c94c4;
+ background: #f6f6f6;
+ font-size: 1em;
+ line-height: 1.4em;
+ position: absolute;
+ top: .5em;
+ margin: 0 !important;
+}
+.ui-datepicker-header option:focus, .ui-datepicker-header option:hover {
+ background: #fdf5ce;
+}
+.ui-datepicker-header select.ui-datepicker-new-month {
+ width: 7em;
+ left: 2.2em;
+}
+.ui-datepicker-header select.ui-datepicker-new-year {
+ width: 5em;
+ left: 9.4em;
+}
+table.ui-datepicker {
+ width: 15.5em;
+ text-align: right;
+}
+table.ui-datepicker td a {
+ padding: .1em .3em .1em 0;
+ display: block;
+ color: #1c94c4;
+ background: #f6f6f6 url(images/f6f6f6_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ cursor: pointer;
+ border: 1px solid #eeeeee;
+}
+table.ui-datepicker td a:hover {
+ border: 1px solid #fbcb09;
+ color: #c77405;
+ background: #fdf5ce url(images/fdf5ce_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+}
+table.ui-datepicker td a:active {
+ border: 1px solid #fbd850;
+ color: #eb8f00;
+ background: #ffffff url(images/ffffff_40x100_textures_02_glass_65.png) 0 50% repeat-x;
+}
+table.ui-datepicker .ui-datepicker-title-row td {
+ padding: .3em 0;
+ text-align: center;
+ font-size: .9em;
+ color: #333333;
+ text-transform: uppercase;
+}
+table.ui-datepicker .ui-datepicker-title-row td a {
+ color: #333333;
+}
+.ui-datepicker-cover {
+ display: none;
+ display/**/: block;
+ position: absolute;
+ z-index: -1;
+ filter: mask();
+ top: -4px;
+ left: -4px;
+ width: 193px;
+ height: 200px;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+Generic ThemeRoller Classes
+>> Make your jQuery Components ThemeRoller-Compatible!
+*/
+
+/*component global class*/
+.ui-component {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+ font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif;
+ font-size: 1.1em;
+}
+/*component content styles*/
+.ui-component-content {
+ border: 1px solid #dddddd;
+ background: #eeeeee url(images/eeeeee_40x100_textures_03_highlight_soft_100.png) 0 0 repeat-x;
+ color: #333333;
+}
+.ui-component-content a {
+ color: #333333;
+ text-decoration: underline;
+}
+/*component states*/
+.ui-default-state {
+ border: 1px solid #cccccc;
+ background: #f6f6f6 url(images/f6f6f6_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ font-weight: bold;
+ color: #1c94c4 !important;
+}
+.ui-default-state a {
+ color: #1c94c4;
+}
+.ui-default-state:hover, .ui-hover-state {
+ border: 1px solid #fbcb09;
+ background: #fdf5ce url(images/fdf5ce_40x100_textures_02_glass_100.png) 0 50% repeat-x;
+ font-weight: bold;
+ color: #c77405 !important;
+}
+.ui-hover-state a {
+ color: #c77405;
+}
+.ui-default-state:active, .ui-active-state {
+ border: 1px solid #fbd850;
+ background: #ffffff url(images/ffffff_40x100_textures_02_glass_65.png) 0 50% repeat-x;
+ font-weight: bold;
+ color: #eb8f00 !important;
+ outline: none;
+}
+.ui-active-state a {
+ color: #eb8f00;
+ outline: none;
+}
+/*icons*/
+.ui-arrow-right-default {background: url(images/ef8c08_7x7_arrow_right.gif) no-repeat 50% 50%;}
+.ui-arrow-right-default:hover, .ui-arrow-right-hover {background: url(images/ef8c08_7x7_arrow_right.gif) no-repeat 50% 50%;}
+.ui-arrow-right-default:active, .ui-arrow-right-active {background: url(images/ef8c08_7x7_arrow_right.gif) no-repeat 50% 50%;}
+.ui-arrow-right-content {background: url(images/222222_7x7_arrow_right.gif) no-repeat 50% 50%;}
+
+.ui-arrow-left-default {background: url(images/ef8c08_7x7_arrow_left.gif) no-repeat 50% 50%;}
+.ui-arrow-left-default:hover, .ui-arrow-left-hover {background: url(images/ef8c08_7x7_arrow_left.gif) no-repeat 50% 50%;}
+.ui-arrow-left-default:active, .ui-arrow-left-active {background: url(images/ef8c08_7x7_arrow_left.gif) no-repeat 50% 50%;}
+.ui-arrow-left-content {background: url(images/222222_7x7_arrow_left.gif) no-repeat 50% 50%;}
+
+.ui-arrow-down-default {background: url(images/ef8c08_7x7_arrow_down.gif) no-repeat 50% 50%;}
+.ui-arrow-down-default:hover, .ui-arrow-down-hover {background: url(images/ef8c08_7x7_arrow_down.gif) no-repeat 50% 50%;}
+.ui-arrow-down-default:active, .ui-arrow-down-active {background: url(images/ef8c08_7x7_arrow_down.gif) no-repeat 50% 50%;}
+.ui-arrow-down-content {background: url(images/222222_7x7_arrow_down.gif) no-repeat 50% 50%;}
+
+.ui-arrow-up-default {background: url(images/ef8c08_7x7_arrow_up.gif) no-repeat 50% 50%;}
+.ui-arrow-up-default:hover, .ui-arrow-up-hover {background: url(images/ef8c08_7x7_arrow_up.gif) no-repeat 50% 50%;}
+.ui-arrow-up-default:active, .ui-arrow-up-active {background: url(images/ef8c08_7x7_arrow_up.gif) no-repeat 50% 50%;}
+.ui-arrow-up-content {background: url(images/222222_7x7_arrow_up.gif) no-repeat 50% 50%;}
+
+.ui-close-default {background: url(images/ef8c08_11x11_icon_close.gif) no-repeat 50% 50%;}
+.ui-close-default:hover, .ui-close-hover {background: url(images/ef8c08_11x11_icon_close.gif) no-repeat 50% 50%;}
+.ui-close-default:active, .ui-close-active {background: url(images/ef8c08_11x11_icon_close.gif) no-repeat 50% 50%;}
+.ui-close-content {background: url(images/ef8c08_11x11_icon_close.gif) no-repeat 50% 50%;}
+
+.ui-folder-closed-default {background: url(images/ef8c08_11x11_icon_folder_closed.gif) no-repeat 50% 50%;}
+.ui-folder-closed-default:hover, .ui-folder-closed-hover {background: url(images/ef8c08_11x11_icon_folder_closed.gif) no-repeat 50% 50%;}
+.ui-folder-closed-default:active, .ui-folder-closed-active {background: url(images/ef8c08_11x11_icon_folder_closed.gif) no-repeat 50% 50%;}
+.ui-folder-closed-content {background: url(images/ef8c08_11x11_icon_folder_closed.gif) no-repeat 50% 50%;}
+
+.ui-folder-open-default {background: url(images/ef8c08_11x11_icon_folder_open.gif) no-repeat 50% 50%;}
+.ui-folder-open-default:hover, .ui-folder-open-hover {background: url(images/ef8c08_11x11_icon_folder_open.gif) no-repeat 50% 50%;}
+.ui-folder-open-default:active, .ui-folder-open-active {background: url(images/ef8c08_11x11_icon_folder_open.gif) no-repeat 50% 50%;}
+.ui-folder-open-content {background: url(images/ef8c08_11x11_icon_folder_open.gif) no-repeat 50% 50%;}
+
+.ui-doc-default {background: url(images/ef8c08_11x11_icon_doc.gif) no-repeat 50% 50%;}
+.ui-doc-default:hover, .ui-doc-hover {background: url(images/ef8c08_11x11_icon_doc.gif) no-repeat 50% 50%;}
+.ui-doc-default:active, .ui-doc-active {background: url(images/ef8c08_11x11_icon_doc.gif) no-repeat 50% 50%;}
+.ui-doc-content {background: url(images/222222_11x11_icon_doc.gif) no-repeat 50% 50%;}
+
+.ui-arrows-leftright-default {background: url(images/ef8c08_11x11_icon_arrows_leftright.gif) no-repeat 50% 50%;}
+.ui-arrows-leftright-default:hover, .ui-arrows-leftright-hover {background: url(images/ef8c08_11x11_icon_arrows_leftright.gif) no-repeat 50% 50%;}
+.ui-arrows-leftright-default:active, .ui-arrows-leftright-active {background: url(images/ef8c08_11x11_icon_arrows_leftright.gif) no-repeat 50% 50%;}
+.ui-arrows-leftright-content {background: url(images/222222_11x11_icon_arrows_leftright.gif) no-repeat 50% 50%;}
+
+.ui-arrows-updown-default {background: url(images/ef8c08_11x11_icon_arrows_updown.gif) no-repeat 50% 50%;}
+.ui-arrows-updown-default:hover, .ui-arrows-updown-hover {background: url(images/ef8c08_11x11_icon_arrows_updown.gif) no-repeat 50% 50%;}
+.ui-arrows-updown-default:active, .ui-arrows-updown-active {background: url(images/ef8c08_11x11_icon_arrows_updown.gif) no-repeat 50% 50%;}
+.ui-arrows-updown-content {background: url(images/222222_11x11_icon_arrows_updown.gif) no-repeat 50% 50%;}
+
+.ui-minus-default {background: url(images/ef8c08_11x11_icon_minus.gif) no-repeat 50% 50%;}
+.ui-minus-default:hover, .ui-minus-hover {background: url(images/ef8c08_11x11_icon_minus.gif) no-repeat 50% 50%;}
+.ui-minus-default:active, .ui-minus-active {background: url(images/ef8c08_11x11_icon_minus.gif) no-repeat 50% 50%;}
+.ui-minus-content {background: url(images/222222_11x11_icon_minus.gif) no-repeat 50% 50%;}
+
+.ui-plus-default {background: url(images/ef8c08_11x11_icon_plus.gif) no-repeat 50% 50%;}
+.ui-plus-default:hover, .ui-plus-hover {background: url(images/ef8c08_11x11_icon_plus.gif) no-repeat 50% 50%;}
+.ui-plus-default:active, .ui-plus-active {background: url(images/ef8c08_11x11_icon_plus.gif) no-repeat 50% 50%;}
+.ui-plus-content {background: url(images/222222_11x11_icon_plus.gif) no-repeat 50% 50%;}
+
+/*hidden elements*/
+.ui-hidden {
+ display: none;/* for accessible hiding: position: absolute; left: -99999999px*/;
+}
+.ui-accessible-hidden {
+ position: absolute; left: -99999999px;
+}
+/*reset styles*/
+.ui-reset {
+ /*resets*/margin: 0; padding: 0; border: 0; outline: 0; line-height: 1.3; text-decoration: none; font-size: 100%; list-style: none;
+}
+/*clearfix class*/
+.ui-clearfix:after {
+ content: ".";
+ display: block;
+ height: 0;
+ clear: both;
+ visibility: hidden;
+}
+.ui-clearfix {display: inline-block;}
+/* Hides from IE-mac \*/
+* html .ui-clearfix {height: 1%;}
+.ui-clearfix {display: block;}
+/* End hide from IE-mac */
+
+/* Note: for resizable styles, use the styles listed above in the dialog section */
+
+