网络

开发平台：

Unix_Linux

jquery.ui-all-1.5b3.js：源码内容

stop: this.stop,
drag: this.drag,
condition: function(e) {
if(this.options.disabled || this.options.type == 'static') return false;
//Find out if the clicked node (or one of its parents) is a actual item in this.items
var currentItem = null, nodes = $(e.target).parents().each(function() {
if($.data(this, 'sortable-item')) {
currentItem = $(this);
return false;
}
});
if($.data(e.target, 'sortable-item')) currentItem = $(e.target);
if(!currentItem) return false;
if(this.options.handle) {
var validHandle = false;
$(this.options.handle, currentItem).each(function() { if(this == e.target) validHandle = true; });
if(!validHandle) return false;
}
this.currentItem = currentItem;
return true;
}
});
},
plugins: {},
ui: function(inst) {
return {
helper: (inst || this)["helper"],
placeholder: (inst || this)["placeholder"] || $([]),
position: (inst || this)["position"].current,
absolutePosition: (inst || this)["position"].absolute,
instance: this,
options: this.options,
element: this.element,
item: (inst || this)["currentItem"],
sender: inst ? inst.element : null
};
},
propagate: function(n,e,inst) {
$.ui.plugin.call(this, n, [e, this.ui(inst)]);
this.element.triggerHandler(n == "sort" ? n : "sort"+n, [e, this.ui(inst)], this.options[n]);
},
serialize: function(o) {
var items = $(this.options.items, this.element).not('.ui-sortable-helper'); //Only the items of the sortable itself
var str = []; o = o || {};
items.each(function() {
var res = ($(this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
if(res) str.push((o.key || res[1])+'[]='+(o.key ? res[1] : res[2]));
});
return str.join('&');
},
toArray: function(attr) {
var items = $(this.options.items, this.element).not('.ui-sortable-helper'); //Only the items of the sortable itself
var ret = [];
items.each(function() { ret.push($(this).attr(attr || 'id')); });
return ret;
},
enable: function() {
this.element.removeClass("ui-sortable-disabled");
this.options.disabled = false;
},
disable: function() {
this.element.addClass("ui-sortable-disabled");
this.options.disabled = true;
},
/* Be careful with the following core functions */
intersectsWith: function(item) {
var x1 = this.position.absolute.left, x2 = x1 + this.helperProportions.width,
y1 = this.position.absolute.top, y2 = y1 + this.helperProportions.height;
var l = item.left, r = l + item.width,
t = item.top, b = t + item.height;
if(this.options.tolerance == "pointer") {
return (y1 + this.clickOffset.top > t && y1 + this.clickOffset.top < b && x1 + this.clickOffset.left > l && x1 + this.clickOffset.left < r);
} 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
}
},
intersectsWithEdge: function(item) {
var x1 = this.position.absolute.left, x2 = x1 + this.helperProportions.width,
y1 = this.position.absolute.top, y2 = y1 + this.helperProportions.height;
var l = item.left, r = l + item.width,
t = item.top, b = t + item.height;
if(this.options.tolerance == "pointer") {
if(!(y1 + this.clickOffset.top > t && y1 + this.clickOffset.top < b && x1 + this.clickOffset.left > l && x1 + this.clickOffset.left < r)) return false;
if(this.floating) {
if(x1 + this.clickOffset.left > l && x1 + this.clickOffset.left < l + item.width/2) return 2;
if(x1 + this.clickOffset.left > l+item.width/2 && x1 + this.clickOffset.left < r) return 1;
} else {
if(y1 + this.clickOffset.top > t && y1 + this.clickOffset.top < t + item.height/2) return 2;
if(y1 + this.clickOffset.top > t+item.height/2 && y1 + this.clickOffset.top < b) return 1;
}
} else {
if (!(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 )) return false; // Top Half
if(this.floating) {
if(x2 > l && x1 < l) return 2; //Crosses left edge
if(x1 < r && x2 > r) return 1; //Crosses right edge
} else {
if(y2 > t && y1 < t) return 1; //Crosses top edge
if(y1 < b && y2 > b) return 2; //Crosses bottom edge
}
}
return false;
},
//This method checks approximately if the item is dragged in a container, but doesn't touch any items
inEmptyZone: function(container) {
if(!$(container.options.items, container.element).length) {
return container.options.dropOnEmpty ? true : false;
};
var last = $(container.options.items, container.element).not('.ui-sortable-helper'); last = $(last[last.length-1]);
var top = last.offset()[this.floating ? 'left' : 'top'] + last[0][this.floating ? 'offsetWidth' : 'offsetHeight'];
return (this.position.absolute[this.floating ? 'left' : 'top'] > top);
},
refresh: function() {
this.refreshItems();
this.refreshPositions();
},
refreshItems: function() {
this.items = [];
this.containers = [this];
var items = this.items;
var queries = [$(this.options.items, this.element)];
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.options.disabled) {
queries.push($(inst.options.items, inst.element));
this.containers.push(inst);
}
};
};
}
for (var i = queries.length - 1; i >= 0; i--){
queries[i].each(function() {
$.data(this, 'sortable-item', true); // Data for target checking (mouse manager)
items.push({
item: $(this),
width: 0, height: 0,
left: 0, top: 0
});
});
};
},
refreshPositions: function(fast) {
for (var i = this.items.length - 1; i >= 0; i--){
var t = this.items[i].item;
if(!fast) this.items[i].width = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).outerWidth();
if(!fast) this.items[i].height = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).outerHeight();
var p = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).offset();
this.items[i].left = p.left;
this.items[i].top = p.top;
};
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();
};
},
destroy: function() {
this.element
.removeClass("ui-sortable ui-sortable-disabled")
.removeData("sortable")
.unbind(".sortable")
.mouse("destroy");
for ( var i = this.items.length - 1; i >= 0; i-- )
this.items[i].item.removeData("sortable-item");
},
createPlaceholder: function(that) {
(that || this).placeholderElement = this.options.placeholderElement ? $(this.options.placeholderElement, (that || this).currentItem) : (that || this).currentItem;
(that || this).placeholder = $('<div></div>')
.addClass(this.options.placeholder)
.appendTo('body')
.css({ position: 'absolute' })
.css((that || this).placeholderElement.offset())
.css({ width: (that || this).placeholderElement.outerWidth(), height: (that || this).placeholderElement.outerHeight() })
;
},
contactContainers: function(e) {
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.position.absolute[this.containers[i].floating ? 'left' : 'top'];
for (var j = this.items.length - 1; j >= 0; j--) {
if(!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];
}
}
//We also need to exchange the placeholder
if(this.placeholder) this.placeholder.remove();
if(this.containers[i].options.placeholder) {
this.containers[i].createPlaceholder(this);
} else {
this.placeholder = null; this.placeholderElement = null;
}
itemWithLeastDistance ? this.rearrange(e, itemWithLeastDistance) : this.rearrange(e, null, this.containers[i].element);
this.propagate("change", e); //Call plugins and callbacks
this.containers[i].propagate("change", e, this); //Call plugins and callbacks
this.currentContainer = this.containers[i];
}
this.containers[i].propagate("over", e, this);
this.containers[i].containerCache.over = 1;
}
} else {
if(this.containers[i].containerCache.over) {
this.containers[i].propagate("out", e, this);
this.containers[i].containerCache.over = 0;
}
}
};
},
start: function(e,el) {
var o = this.options;
this.currentContainer = this;
this.refresh();
//Create and append the visible helper
this.helper = typeof o.helper == 'function' ? $(o.helper.apply(this.element[0], [e, this.currentItem])) : this.currentItem.clone();
if(!this.helper.parents('body').length) this.helper.appendTo(o.appendTo || this.currentItem[0].parentNode); //Add the helper to the DOM if that didn't happen already
this.helper.css({ position: 'absolute', clear: 'both' }).addClass('ui-sortable-helper'); //Position it absolutely and add a helper class
//Prepare variables for position generation
$.extend(this, {
offsetParent: this.helper.offsetParent(),
offsets: {
absolute: this.currentItem.offset()
},
mouse: {
start: { top: e.pageY, left: e.pageX }
},
margins: {
top: parseInt(this.currentItem.css("marginTop")) || 0,
left: parseInt(this.currentItem.css("marginLeft")) || 0
}
});
//The relative click offset
this.offsets.parent = this.offsetParent.offset();
this.clickOffset = { left: e.pageX - this.offsets.absolute.left, top: e.pageY - this.offsets.absolute.top };
this.originalPosition = {
left: this.offsets.absolute.left - this.offsets.parent.left - this.margins.left,
top: this.offsets.absolute.top - this.offsets.parent.top - this.margins.top
}
//Generate a flexible offset that will later be subtracted from e.pageX/Y
//I hate margins - they need to be removed before positioning the element absolutely..
this.offset = {
left: e.pageX - this.originalPosition.left,
top: e.pageY - this.originalPosition.top
};
//Save the first time position
$.extend(this, {
position: {
current: { top: e.pageY - this.offset.top, left: e.pageX - this.offset.left },
absolute: { left: e.pageX - this.clickOffset.left, top: e.pageY - this.clickOffset.top },
dom: this.currentItem.prev()[0]
}
});
//If o.placeholder is used, create a new element at the given position with the class
if(o.placeholder) this.createPlaceholder();
this.propagate("start", e); //Call plugins and callbacks
this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() }; //Save and store the helper proportions
//If we have something in cursorAt, we'll use it
if(o.cursorAt) {
if(o.cursorAt.top != undefined || o.cursorAt.bottom != undefined) {
this.offset.top -= this.clickOffset.top - (o.cursorAt.top != undefined ? o.cursorAt.top : (this.helperProportions.height - o.cursorAt.bottom));
this.clickOffset.top = (o.cursorAt.top != undefined ? o.cursorAt.top : (this.helperProportions.height - o.cursorAt.bottom));
}
if(o.cursorAt.left != undefined || o.cursorAt.right != undefined) {
this.offset.left -= this.clickOffset.left - (o.cursorAt.left != undefined ? o.cursorAt.left : (this.helperProportions.width - o.cursorAt.right));
this.clickOffset.left = (o.cursorAt.left != undefined ? o.cursorAt.left : (this.helperProportions.width - o.cursorAt.right));
}
}
if(this.options.placeholder != 'clone') $(this.currentItem).css('visibility', 'hidden'); //Set the original element visibility to hidden to still fill out the white space
for (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i].propagate("activate", e, this); } //Post 'activate' events to possible containers
//Prepare possible droppables
if($.ui.ddmanager) $.ui.ddmanager.current = this;
if ($.ui.ddmanager && !o.dropBehaviour) $.ui.ddmanager.prepareOffsets(this, e);
this.dragging = true;
return false;
},
stop: function(e) {
this.propagate("stop", e); //Call plugins and trigger callbacks
if(this.position.dom != this.currentItem.prev()[0]) this.propagate("update", e); //Trigger update callback if the DOM position has changed
if(!contains(this.element[0], this.currentItem[0])) { //Node was moved out of the current element
this.propagate("remove", e);
for (var i = this.containers.length - 1; i >= 0; i--){
if(contains(this.containers[i].element[0], this.currentItem[0])) {
this.containers[i].propagate("update", e, this);
this.containers[i].propagate("receive", e, this);
}
};
};
//Post events to containers
for (var i = this.containers.length - 1; i >= 0; i--){
this.containers[i].propagate("deactivate", e, this);
if(this.containers[i].containerCache.over) {
this.containers[i].propagate("out", e, this);
this.containers[i].containerCache.over = 0;
}
}
//If we are using droppables, inform the manager about the drop
if ($.ui.ddmanager && !this.options.dropBehaviour) $.ui.ddmanager.drop(this, e);
this.dragging = false;
if(this.cancelHelperRemoval) return false;
$(this.currentItem).css('visibility', '');
if(this.placeholder) this.placeholder.remove();
this.helper.remove();
return false;
},
drag: function(e) {
//Compute the helpers position
this.position.current = { top: e.pageY - this.offset.top, left: e.pageX - this.offset.left };
this.position.absolute = { left: e.pageX - this.clickOffset.left, top: e.pageY - this.clickOffset.top };
//Rearrange
for (var i = this.items.length - 1; i >= 0; i--) {
var intersection = this.intersectsWithEdge(this.items[i]);
if(!intersection) continue;
if(this.items[i].item[0] != this.currentItem[0] //cannot intersect with itself
&& this.currentItem[intersection == 1 ? "next" : "prev"]()[0] != this.items[i].item[0] //no useless actions that have been done before
&& !contains(this.currentItem[0], this.items[i].item[0]) //no action if the item moved is the parent of the item checked
&& (this.options.type == 'semi-dynamic' ? !contains(this.element[0], this.items[i].item[0]) : true)
) {
this.direction = intersection == 1 ? "down" : "up";
this.rearrange(e, this.items[i]);
this.propagate("change", e); //Call plugins and callbacks
break;
}
}
//Post events to containers
this.contactContainers(e);
//Interconnect with droppables
if($.ui.ddmanager) $.ui.ddmanager.drag(this, e);
this.propagate("sort", e); //Call plugins and callbacks
this.helper.css({ left: this.position.current.left+'px', top: this.position.current.top+'px' }); // Stick the helper to the cursor
return false;
},
rearrange: function(e, i, a) {
a ? a.append(this.currentItem) : i.item[this.direction == 'down' ? 'before' : 'after'](this.currentItem);
this.refreshPositions(true); //Precompute after each DOM insertion, NOT on mousemove
if(this.placeholderElement) this.placeholder.css(this.placeholderElement.offset());
if(this.placeholderElement && this.placeholderElement.is(":visible")) this.placeholder.css({ width: this.placeholderElement.outerWidth(), height: this.placeholderElement.outerHeight() });
}
});
$.extend($.ui.sortable, {
getter: "serialize toArray",
defaults: {
items: '> *',
zIndex: 1000
}
});
/*
* Sortable Extensions
*/
$.ui.plugin.add("sortable", "cursor", {
start: function(e, ui) {
var t = $('body');
if (t.css("cursor")) ui.options._cursor = t.css("cursor");
t.css("cursor", ui.options.cursor);
},
stop: function(e, ui) {
if (ui.options._cursor) $('body').css("cursor", ui.options._cursor);
}
});
$.ui.plugin.add("sortable", "zIndex", {
start: function(e, ui) {
var t = ui.helper;
if(t.css("zIndex")) ui.options._zIndex = t.css("zIndex");
t.css('zIndex', ui.options.zIndex);
},
stop: function(e, ui) {
if(ui.options._zIndex) $(ui.helper).css('zIndex', ui.options._zIndex);
}
});
$.ui.plugin.add("sortable", "opacity", {
start: function(e, ui) {
var t = ui.helper;
if(t.css("opacity")) ui.options._opacity = t.css("opacity");
t.css('opacity', ui.options.opacity);
},
stop: function(e, ui) {
if(ui.options._opacity) $(ui.helper).css('opacity', ui.options._opacity);
}
});
$.ui.plugin.add("sortable", "revert", {
stop: function(e, ui) {
var self = ui.instance;
self.cancelHelperRemoval = true;
var cur = self.currentItem.offset();
var op = self.helper.offsetParent().offset();
if(ui.instance.options.zIndex) ui.helper.css('zIndex', ui.instance.options.zIndex); //Do the zIndex again because it already was resetted by the plugin above on stop
//Also animate the placeholder if we have one
if(ui.instance.placeholder) ui.instance.placeholder.animate({ opacity: 'hide' }, parseInt(ui.options.revert, 10) || 500);
ui.helper.animate({
left: cur.left - op.left - self.margins.left,
top: cur.top - op.top - self.margins.top
}, parseInt(ui.options.revert, 10) || 500, function() {
self.currentItem.css('visibility', 'visible');
window.setTimeout(function() {
if(self.placeholder) self.placeholder.remove();
self.helper.remove();
if(ui.options._zIndex) ui.helper.css('zIndex', ui.options._zIndex);
}, 50);
});
}
});
$.ui.plugin.add("sortable", "containment", {
start: function(e, ui) {
var o = ui.options;
if((o.containment.left != undefined || o.containment.constructor == Array) && !o._containment) return;
if(!o._containment) o._containment = o.containment;
if(o._containment == 'parent') o._containment = this[0].parentNode;
if(o._containment == 'sortable') o._containment = this[0];
if(o._containment == 'document') {
o.containment = [
0,
0,
$(document).width(),
($(document).height() || document.body.parentNode.scrollHeight)
];
} else { //I'm a node, so compute top/left/right/bottom
var ce = $(o._containment);
var co = ce.offset();
o.containment = [
co.left,
co.top,
co.left+(ce.outerWidth() || ce[0].scrollWidth),
co.top+(ce.outerHeight() || ce[0].scrollHeight)
];
}
},
sort: function(e, ui) {
var o = ui.options;
var h = ui.helper;
var c = o.containment;
var self = ui.instance;
var borderLeft = (parseInt(self.offsetParent.css("borderLeftWidth"), 10) || 0);
var borderRight = (parseInt(self.offsetParent.css("borderRightWidth"), 10) || 0);
var borderTop = (parseInt(self.offsetParent.css("borderTopWidth"), 10) || 0);
var borderBottom = (parseInt(self.offsetParent.css("borderBottomWidth"), 10) || 0);
if(c.constructor == Array) {
if((self.position.absolute.left < c[0])) self.position.current.left = c[0] - self.offsets.parent.left - self.margins.left;
if((self.position.absolute.top < c[1])) self.position.current.top = c[1] - self.offsets.parent.top - self.margins.top;
if(self.position.absolute.left - c[2] + self.helperProportions.width >= 0) self.position.current.left = c[2] - self.offsets.parent.left - self.helperProportions.width - self.margins.left - borderLeft - borderRight;
if(self.position.absolute.top - c[3] + self.helperProportions.height >= 0) self.position.current.top = c[3] - self.offsets.parent.top - self.helperProportions.height - self.margins.top - borderTop - borderBottom;
} else {
if((ui.position.left < c.left)) self.position.current.left = c.left;
if((ui.position.top < c.top)) self.position.current.top = c.top;
if(ui.position.left - self.offsetParent.innerWidth() + self.helperProportions.width + c.right + borderLeft + borderRight >= 0) self.position.current.left = self.offsetParent.innerWidth() - self.helperProportions.width - c.right - borderLeft - borderRight;
if(ui.position.top - self.offsetParent.innerHeight() + self.helperProportions.height + c.bottom + borderTop + borderBottom >= 0) self.position.current.top = self.offsetParent.innerHeight() - self.helperProportions.height - c.bottom - borderTop - borderBottom;
}
}
});
$.ui.plugin.add("sortable", "axis", {
sort: function(e, ui) {
var o = ui.options;
if(o.constraint) o.axis = o.constraint; //Legacy check
o.axis == 'x' ? ui.instance.position.current.top = ui.instance.originalPosition.top : ui.instance.position.current.left = ui.instance.originalPosition.left;
}
});
$.ui.plugin.add("sortable", "scroll", {
start: function(e, ui) {
var o = ui.options;
o.scrollSensitivity = o.scrollSensitivity || 20;
o.scrollSpeed = o.scrollSpeed || 20;
ui.instance.overflowY = function(el) {
do { if((/auto|scroll/).test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-y'))) return el; el = el.parent(); } while (el[0].parentNode);
return $(document);
}(this);
ui.instance.overflowX = function(el) {
do { if((/auto|scroll/).test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-x'))) return el; el = el.parent(); } while (el[0].parentNode);
return $(document);
}(this);
if(ui.instance.overflowY[0] != document && ui.instance.overflowY[0].tagName != 'HTML') ui.instance.overflowYstart = ui.instance.overflowY[0].scrollTop;
if(ui.instance.overflowX[0] != document && ui.instance.overflowX[0].tagName != 'HTML') ui.instance.overflowXstart = ui.instance.overflowX[0].scrollLeft;
},
sort: function(e, ui) {
var o = ui.options;
var i = ui.instance;
if(i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') {
if(i.overflowY[0].offsetHeight - (ui.position.top - i.overflowY[0].scrollTop + i.clickOffset.top) < o.scrollSensitivity)
i.overflowY[0].scrollTop = i.overflowY[0].scrollTop + o.scrollSpeed;
if((ui.position.top - i.overflowY[0].scrollTop + i.clickOffset.top) < o.scrollSensitivity)
i.overflowY[0].scrollTop = i.overflowY[0].scrollTop - o.scrollSpeed;
} else {
//$(document.body).append('<p>'+(e.pageY - $(document).scrollTop())+'</p>');
if(e.pageY - $(document).scrollTop() < o.scrollSensitivity)
$(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
if($(window).height() - (e.pageY - $(document).scrollTop()) < o.scrollSensitivity)
$(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
}
if(i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') {
if(i.overflowX[0].offsetWidth - (ui.position.left - i.overflowX[0].scrollLeft + i.clickOffset.left) < o.scrollSensitivity)
i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft + o.scrollSpeed;
if((ui.position.top - i.overflowX[0].scrollLeft + i.clickOffset.left) < o.scrollSensitivity)
i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft - o.scrollSpeed;
} else {
if(e.pageX - $(document).scrollLeft() < o.scrollSensitivity)
$(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
if($(window).width() - (e.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
$(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
}
//ui.instance.recallOffset(e);
i.offset = {
left: i.mouse.start.left - i.originalPosition.left + (i.overflowXstart !== undefined ? i.overflowXstart - i.overflowX[0].scrollLeft : 0),
top: i.mouse.start.top - i.originalPosition.top + (i.overflowYstart !== undefined ? i.overflowYstart - i.overflowX[0].scrollTop : 0)
};
}
});
})(jQuery);
/*
* jQuery UI Accordion
*
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* http://docs.jquery.com/UI/Accordion
*
* Depends:
* ui.core.js
*
* Revision: $Id: ui.accordion.js 5433 2008-05-04 20:07:17Z joern.zaefferer $
*/
;(function($) {
$.widget("ui.accordion", {
init: function() {
var options = this.options;
if ( options.navigation ) {
var current = this.element.find("a").filter(options.navigationFilter);
if ( current.length ) {
if ( current.filter(options.header).length ) {
options.active = current;
} else {
options.active = current.parent().parent().prev();
current.addClass("current");
}
}
}
// calculate active if not specified, using the first header
options.headers = this.element.find(options.header);
options.active = findActive(options.headers, options.active);
if (!this.element.hasClass("ui-accordion")) {
this.element.addClass("ui-accordion");
$("<span class='ui-accordion-left'/>").insertBefore(options.headers);
$("<span class='ui-accordion-right'/>").appendTo(options.headers);
options.headers.addClass("ui-accordion-header").attr("tabindex", "0");
}
var maxHeight;
if ( options.fillSpace ) {
maxHeight = this.element.parent().height();
options.headers.each(function() {
maxHeight -= $(this).outerHeight();
});
var maxPadding = 0;
options.headers.next().each(function() {
maxPadding = Math.max(maxPadding, $(this).innerHeight() - $(this).height());
}).height(maxHeight - maxPadding);
} else if ( options.autoHeight ) {
maxHeight = 0;
options.headers.next().each(function() {
maxHeight = Math.max(maxHeight, $(this).outerHeight());
}).height(maxHeight);
}
options.headers
.not(options.active || "")
.next()
.hide();
options.active.parent().andSelf().addClass(options.selectedClass);
if (options.event) {
this.element.bind((options.event) + ".accordion", clickHandler);
}
},
activate: function(index) {
// call clickHandler with custom event
clickHandler.call(this.element[0], {
target: findActive( this.options.headers, index )[0]
});
},
destroy: function() {
this.options.headers.next().css("display", "");
if ( this.options.fillSpace || this.options.autoHeight ) {
this.options.headers.next().css("height", "");
}
$.removeData(this.element[0], "accordion");
this.element.removeClass("ui-accordion").unbind(".accordion");
}
});
function scopeCallback(callback, scope) {
return function() {
return callback.apply(scope, arguments);
};
};
function completed(cancel) {
// if removed while animated data can be empty
if (!$.data(this, "accordion")) {
return;
}
var instance = $.data(this, "accordion");
var options = instance.options;
options.running = cancel ? 0 : --options.running;
if ( options.running ) {
return;
}
if ( options.clearStyle ) {
options.toShow.add(options.toHide).css({
height: "",
overflow: ""
});
}
$(this).triggerHandler("accordionchange", [options.data], options.change);
}
function toggle(toShow, toHide, data, clickedActive, down) {
var options = $.data(this, "accordion").options;
options.toShow = toShow;
options.toHide = toHide;
options.data = data;
var complete = scopeCallback(completed, this);
// count elements to animate
options.running = toHide.size() === 0 ? toShow.size() : toHide.size();
if ( options.animated ) {
if ( !options.alwaysOpen && clickedActive ) {
$.ui.accordion.animations[options.animated]({
toShow: jQuery([]),
toHide: toHide,
complete: complete,
down: down,
autoHeight: options.autoHeight
});
} else {
$.ui.accordion.animations[options.animated]({
toShow: toShow,
toHide: toHide,
complete: complete,
down: down,
autoHeight: options.autoHeight
});
}
} else {
if ( !options.alwaysOpen && clickedActive ) {
toShow.toggle();
} else {
toHide.hide();
toShow.show();
}
complete(true);
}
}
function clickHandler(event) {
var options = $.data(this, "accordion").options;
if (options.disabled) {
return false;
}
// called only when using activate(false) to close all parts programmatically
if ( !event.target && !options.alwaysOpen ) {
options.active.parent().andSelf().toggleClass(options.selectedClass);
var toHide = options.active.next(),
data = {
instance: this,
options: options,
newHeader: jQuery([]),
oldHeader: options.active,
newContent: jQuery([]),
oldContent: toHide
},
toShow = (options.active = $([]));
toggle.call(this, toShow, toHide, data );
return false;
}
// get the click target
var clicked = $(event.target);
// due to the event delegation model, we have to check if one
// of the parent elements is our actual header, and find that
if ( clicked.parents(options.header).length ) {
while ( !clicked.is(options.header) ) {
clicked = clicked.parent();
}
}
var clickedActive = clicked[0] == options.active[0];
// if animations are still active, or the active header is the target, ignore click
if (options.running || (options.alwaysOpen && clickedActive)) {
return false;
}
if (!clicked.is(options.header)) {
return;
}
// switch classes
options.active.parent().andSelf().toggleClass(options.selectedClass);
if ( !clickedActive ) {
clicked.parent().andSelf().addClass(options.selectedClass);
}
// find elements to show and hide
var toShow = clicked.next(),
toHide = options.active.next(),
//data = [clicked, options.active, toShow, toHide],
data = {
instance: this,
options: options,
newHeader: clicked,
oldHeader: options.active,
newContent: toShow,
oldContent: toHide
},
down = options.headers.index( options.active[0] ) > options.headers.index( clicked[0] );
options.active = clickedActive ? $([]) : clicked;
toggle.call(this, toShow, toHide, data, clickedActive, down );
return false;
};
function findActive(headers, selector) {
return selector != undefined
? typeof selector == "number"
? headers.filter(":eq(" + selector + ")")
: headers.not(headers.not(selector))
: selector === false
? $([])
: headers.filter(":eq(0)");
}
$.extend($.ui.accordion, {
defaults: {
selectedClass: "selected",
alwaysOpen: true,
animated: 'slide',
event: "click",
header: "a",
autoHeight: true,
running: 0,
navigationFilter: function() {
return this.href.toLowerCase() == location.href.toLowerCase();
}
},
animations: {
slide: function(options, additions) {
options = $.extend({
easing: "swing",
duration: 300
}, options, additions);
if ( !options.toHide.size() ) {
options.toShow.animate({height: "show"}, options);
return;
}
var hideHeight = options.toHide.height(),
showHeight = options.toShow.height(),
difference = showHeight / hideHeight;
options.toShow.css({ height: 0, overflow: 'hidden' }).show();
options.toHide.filter(":hidden").each(options.complete).end().filter(":visible").animate({height:"hide"},{
step: function(now) {
var current = (hideHeight - now) * difference;
if ($.browser.msie || $.browser.opera) {
current = Math.ceil(current);
}
options.toShow.height( current );
},
duration: options.duration,
easing: options.easing,
complete: function() {
if ( !options.autoHeight ) {
options.toShow.css("height", "auto");
}
options.complete();
}
});
},
bounceslide: function(options) {
this.slide(options, {
easing: options.down ? "bounceout" : "swing",
duration: options.down ? 1000 : 200
});
},
easeslide: function(options) {
this.slide(options, {
easing: "easeinout",
duration: 700
});
}
}
});
// deprecated, use accordion("activate", index) instead
$.fn.activate = function(index) {
return this.accordion("activate", index);
};
})(jQuery);
/*
* jQuery UI Dialog
*
* 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
*
* Revision: $Id: ui.dialog.js 5433 2008-05-04 20:07:17Z joern.zaefferer $
*/
;(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() {
var self = this;
var options = this.options;
var uiDialogContent = $(this.element).addClass('ui-dialog-content');
if (!uiDialogContent.parent().length) {
uiDialogContent.appendTo('body');
}
uiDialogContent
.wrap(document.createElement('div'))
.wrap(document.createElement('div'));
var uiDialogContainer = uiDialogContent.parent().addClass('ui-dialog-container').css({position: 'relative'});
var uiDialog = this.uiDialog = uiDialogContainer.parent().hide()
.addClass('ui-dialog')
.css({position: 'absolute', width: options.width, height: options.height, overflow: 'hidden'});
var classNames = uiDialogContent.attr('className').split(' ');
// Add content classes to dialog, to inherit theme at top level of element
$.each(classNames, function(i, className) {
if (className != 'ui-dialog-content')
uiDialog.addClass(className);
});
if ($.fn.resizable) {
uiDialog.append('<div class="ui-resizable-n ui-resizable-handle"></div>')
.append('<div class="ui-resizable-s ui-resizable-handle"></div>')
.append('<div class="ui-resizable-e ui-resizable-handle"></div>')
.append('<div class="ui-resizable-w ui-resizable-handle"></div>')
.append('<div class="ui-resizable-ne ui-resizable-handle"></div>')
.append('<div class="ui-resizable-se ui-resizable-handle"></div>')
.append('<div class="ui-resizable-sw ui-resizable-handle"></div>')
.append('<div class="ui-resizable-nw ui-resizable-handle"></div>');
uiDialog.resizable({
maxWidth: options.maxWidth,
maxHeight: options.maxHeight,
minWidth: options.minWidth,
minHeight: options.minHeight,
start: options.resizeStart,
resize: options.resize,
stop: function(e, ui) {
options.resizeStop && options.resizeStop.apply(this, arguments);
$.ui.dialog.overlay.resize();
}
});
if (!options.resizable)
uiDialog.resizable('disable');
}
uiDialogContainer.prepend('<div class="ui-dialog-titlebar"></div>');
var uiDialogTitlebar = $('.ui-dialog-titlebar', uiDialogContainer);
this.uiDialogTitlebar = uiDialogTitlebar;
var title = (options.title) ? options.title : (uiDialogContent.attr('title')) ? uiDialogContent.attr('title') : '';
uiDialogTitlebar.append('<span class="ui-dialog-title">' + title + '</span>');
uiDialogTitlebar.append('<a href="#" class="ui-dialog-titlebar-close"><span>X</span></a>');
this.uiDialogTitlebarClose = $('.ui-dialog-titlebar-close', uiDialogTitlebar)
.hover(function() { $(this).addClass('ui-dialog-titlebar-close-hover'); },
function() { $(this).removeClass('ui-dialog-titlebar-close-hover'); }
)
.mousedown(function(ev) {
ev.stopPropagation();
})
.click(function() {
self.close();
return false;
});
// setting tabindex makes the div focusable
// setting outline to 0 prevents a border on focus in Mozilla
uiDialog.attr('tabindex', -1).css('outline', 0).keydown(function(ev) {
if (options.closeOnEscape) {
var ESC = 27;
ev.keyCode && ev.keyCode == ESC && self.close();
}
});
var hasButtons = false;
$.each(options.buttons, function() { return !(hasButtons = true); });
if (hasButtons) {
var uiDialogButtonPane = $('<div class="ui-dialog-buttonpane"/>')
.appendTo(uiDialog);
$.each(options.buttons, function(name, fn) {
$(document.createElement('button'))
.text(name)
.click(function() { fn.apply(self.element, arguments) })
.appendTo(uiDialogButtonPane);
});
}
if ($.fn.draggable) {
uiDialog.draggable({
handle: '.ui-dialog-titlebar',
start: function(e, ui) {
self.activate();
options.dragStart && options.dragStart.apply(this, arguments);
},
drag: options.drag,
stop: function(e, ui) {
options.dragStop && options.dragStop.apply(this, arguments);
$.ui.dialog.overlay.resize();
}
});
if (!options.draggable)
uiDialog.draggable('disable')
}
uiDialog.mousedown(function() {
self.activate();
});
uiDialogTitlebar.click(function() {
self.activate();
});
options.bgiframe && $.fn.bgiframe && uiDialog.bgiframe();
if (options.autoOpen) {
this.open();
};
},
setData: function(event, key, value){
setDataSwitch[key] && this.uiDialog.data(setDataSwitch[key], value);
switch (key) {
case "draggable":
this.uiDialog.draggable(value ? 'enable' : 'disable');
break;
case "height":
this.uiDialog.height(value);
break;
case "position":
this.position(value);
break;
case "resizable":
this.uiDialog.resizable(value ? 'enable' : 'disable');
break;
case "title":
$(".ui-dialog-title", this.uiDialogTitlebar).text(value);
break;
case "width":
this.uiDialog.width(value);
break;
}
this.options[key] = value;
},
position: function(pos) {
var wnd = $(window), doc = $(document), minTop = top = doc.scrollTop(), left = doc.scrollLeft();
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) {
left += pos[0];
} else {
switch (pos[0]) {
case 'left':
left += 0;
break;
case 'right':
left += (wnd.width()) - (this.uiDialog.width());
break;
case 'center':
default:
left += (wnd.width() / 2) - (this.uiDialog.width() / 2);
}
}
if (pos[1].constructor == Number) {
top += pos[1];
} else {
switch (pos[1]) {
case 'top':
top += 0;
break;
case 'bottom':
top += (wnd.height()) - (this.uiDialog.height());
break;
case 'middle':
default:
top += (wnd.height() / 2) - (this.uiDialog.height() / 2);
}
}
top = top < minTop ? minTop : top;
this.uiDialog.css({top: top, left: left});
},
open: function() {
this.overlay = this.options.modal ? new $.ui.dialog.overlay(self) : null;
this.uiDialog.appendTo('body');
this.position(this.options.position);
this.uiDialog.show();
this.moveToTop();
this.activate();
// CALLBACK: open
var openEV = null;
var openUI = {
options: this.options
};
this.uiDialogTitlebarClose.focus();
$(this.element).triggerHandler("dialogopen", [openEV, openUI], this.options.open);
},
activate: function() {
// Move modeless dialogs to the top when they're activated. Even
// if there is a modal dialog in the window, the modeless dialog
// should be on top because it must have been opened after the modal
// dialog. Modal dialogs don't get moved to the top because that
// would make any modeless dialogs that it spawned unusable until
// the modal dialog is closed.
!this.options.modal && this.moveToTop();
},
moveToTop: function() {
var maxZ = this.options.zIndex, options = this.options;
$('.ui-dialog:visible').each(function() {
maxZ = Math.max(maxZ, parseInt($(this).css('z-index'), 10) || options.zIndex);
});
this.overlay && this.overlay.$el.css('z-index', ++maxZ);
this.uiDialog.css('z-index', ++maxZ);
},
close: function() {
this.overlay && this.overlay.destroy();
this.uiDialog.hide();
// CALLBACK: close
var closeEV = null;
var closeUI = {
options: this.options
};
$(this.element).triggerHandler("dialogclose", [closeEV, closeUI], this.options.close);
$.ui.dialog.overlay.resize();
},
destroy: function() {
this.overlay && this.overlay.destroy();
this.uiDialog.hide();
$(this.element).unbind('.dialog').removeClass('ui-dialog-content').hide().appendTo('body');
this.uiDialog.remove();
$.removeData(this.element, "dialog");
}
});
$.extend($.ui.dialog, {
defaults: {
autoOpen: true,
bgiframe: false,
buttons: {},
closeOnEscape: true,
draggable: true,
height: 200,
minHeight: 100,
minWidth: 150,
modal: false,
overlay: {},
position: 'center',
resizable: true,
width: 300,
zIndex: 1000
},
overlay: function(dialog) {
this.$el = $.ui.dialog.overlay.create(dialog);
}
});
$.extend($.ui.dialog.overlay, {
instances: [],
events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
function(e) { return e + '.dialog-overlay'; }).join(' '),
create: function(dialog) {
if (this.instances.length === 0) {
// prevent use of anchors and inputs
$('a, :input').bind(this.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;
});
// allow closing by pressing the escape key
$(document).bind('keydown.dialog-overlay', function(e) {
var ESC = 27;
e.keyCode && e.keyCode == ESC && dialog.close();
});
// handle window resize
$(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
}
var $el = $('<div/>').appendTo(document.body)
.addClass('ui-dialog-overlay').css($.extend({
borderWidth: 0, margin: 0, padding: 0,
position: 'absolute', top: 0, left: 0,
width: this.width(),
height: this.height()
}, dialog.options.overlay));
dialog.options.bgiframe && $.fn.bgiframe && $el.bgiframe();
this.instances.push($el);
return $el;
},
destroy: function($el) {
this.instances.splice($.inArray(this.instances, $el), 1);
if (this.instances.length === 0) {
$('a, :input').add([document, window]).unbind('.dialog-overlay');
}
$el.remove();
},
height: function() {
if ($.browser.msie && $.browser.version < 7) {
var scrollHeight = Math.max(
document.documentElement.scrollHeight,
document.body.scrollHeight
);
var offsetHeight = Math.max(
document.documentElement.offsetHeight,
document.body.offsetHeight
);
if (scrollHeight < offsetHeight) {
return $(window).height() + 'px';
} else {
return scrollHeight + 'px';
}
} else {
return $(document).height() + 'px';
}
},
width: function() {
if ($.browser.msie && $.browser.version < 7) {
var scrollWidth = Math.max(
document.documentElement.scrollWidth,
document.body.scrollWidth
);
var offsetWidth = Math.max(
document.documentElement.offsetWidth,
document.body.offsetWidth
);
if (scrollWidth < offsetWidth) {
return $(window).width() + 'px';
} else {
return scrollWidth + 'px';
}
} else {
return $(document).width() + 'px';
}
},
resize: function() {
/* If the dialog is draggable and the user drags it past the
* right edge of the window, the document becomes wider so we
* need to stretch the overlay. If the user then drags the
* dialog back to the left, the document will become narrower,
* so we need to shrink the overlay to the appropriate size.
* This is handled by shrinking the overlay before setting it
* to the full document size.
*/
var $overlays = $([]);
$.each($.ui.dialog.overlay.instances, function() {
$overlays = $overlays.add(this);
});
$overlays.css({
width: 0,
height: 0
}).css({
width: $.ui.dialog.overlay.width(),
height: $.ui.dialog.overlay.height()
});
}
});
$.extend($.ui.dialog.overlay.prototype, {
destroy: function() {
$.ui.dialog.overlay.destroy(this.$el);
}
});
})(jQuery);
/*
* jQuery UI Slider
*
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* http://docs.jquery.com/UI/Slider
*
* Depends:
* ui.core.js
*
* Revision: $Id: ui.slider.js 5437 2008-05-04 20:25:49Z joern.zaefferer $
*/
;(function($) {
$.widget("ui.slider", {
init: function() {
var self = this;
this.element.addClass("ui-slider");
this.initBoundaries();
// Initialize mouse and key events for interaction
this.handle = $(this.options.handle, this.element);
if (!this.handle.length) {
self.handle = self.generated = $(self.options.handles || [0]).map(function() {
var handle = $("<div/>").addClass("ui-slider-handle").appendTo(self.element);
if (this.id)
handle.attr("id", this.id);
return handle[0];
});
}
$(this.handle)
.mouse({
executor: this,
delay: this.options.delay,
distance: this.options.distance,
dragPrevention: this.options.prevention ? this.options.prevention.toLowerCase().split(',') : ['input','textarea','button','select','option'],
start: this.start,
stop: this.stop,
drag: this.drag,
condition: function(e, handle) {
if(!this.disabled) {
if(this.currentHandle) this.blur(this.currentHandle);
this.focus(handle,1);
return !this.disabled;
}
}
})
.wrap('<a href="javascript:void(0)" style="cursor:default;"></a>')
.parent()
.bind('focus', function(e) { self.focus(this.firstChild); })
.bind('blur', function(e) { self.blur(this.firstChild); })
.bind('keydown', function(e) {
if(/(37|38|39|40)/.test(e.keyCode)) {
self.moveTo({
x: /(37|39)/.test(e.keyCode) ? (e.keyCode == 37 ? '-' : '+') + '=' + self.oneStep(1) : null,
y: /(38|40)/.test(e.keyCode) ? (e.keyCode == 38 ? '-' : '+') + '=' + self.oneStep(2) : null
}, this.firstChild);
}
})
;
// Prepare dynamic properties for later use
this.actualSize = { width: this.element.outerWidth() , height: this.element.outerHeight() };
// Bind the click to the slider itself
this.element.bind('mousedown.slider', function(e) {
self.click.apply(self, [e]);
self.currentHandle.data("mouse").trigger(e);
self.firstValue = self.firstValue + 1; //This is for always triggering the change event
});
// Move the first handle to the startValue
$.each(this.options.handles || [], function(index, handle) {
self.moveTo(handle.start, index, true);
});
if (!isNaN(this.options.startValue))
this.moveTo(this.options.startValue, 0, true);
this.previousHandle = $(this.handle[0]); //set the previous handle to the first to allow clicking before selecting the handle
if(this.handle.length == 2 && this.options.range) this.createRange();
},
setData: function(event, key, value) {
this.options[key] = value;
if (/min|max|steps/.test(key)) {
this.initBoundaries();
}
},
initBoundaries: function() {
var element = this.element[0];
var o = this.options;
$.extend(o, {
axis: o.axis || (element.offsetWidth < element.offsetHeight ? 'vertical' : 'horizontal'),
max: !isNaN(parseInt(o.max,10)) ? { x: parseInt(o.max, 10), y: parseInt(o.max, 10) } : ({ x: o.max && o.max.x || 100, y: o.max && o.max.y || 100 }),
min: !isNaN(parseInt(o.min,10)) ? { x: parseInt(o.min, 10), y: parseInt(o.min, 10) } : ({ x: o.min && o.min.x || 0, y: o.min && o.min.y || 0 })
});
//Prepare the real maxValue
o.realMax = {
x: o.max.x - o.min.x,
y: o.max.y - o.min.y
};
//Calculate stepping based on steps
o.stepping = {
x: o.stepping && o.stepping.x || parseInt(o.stepping, 10) || (o.steps ? o.realMax.x/(o.steps.x || parseInt(o.steps, 10) || o.realMax.x) : 0),
y: o.stepping && o.stepping.y || parseInt(o.stepping, 10) || (o.steps ? o.realMax.y/(o.steps.y || parseInt(o.steps, 10) || o.realMax.y) : 0)
};
},
plugins: {},
createRange: function() {
this.rangeElement = $('<div></div>')
.addClass('ui-slider-range')
.css({ position: 'absolute' })
.appendTo(this.element);
this.updateRange();
},
updateRange: function() {
var prop = this.options.axis == "vertical" ? "top" : "left";
var size = this.options.axis == "vertical" ? "height" : "width";
this.rangeElement.css(prop, parseInt($(this.handle[0]).css(prop),10) + this.handleSize(0, this.options.axis == "vertical" ? 2 : 1)/2);
this.rangeElement.css(size, parseInt($(this.handle[1]).css(prop),10) - parseInt($(this.handle[0]).css(prop),10));
},
getRange: function() {
return this.rangeElement ? this.convertValue(parseInt(this.rangeElement.css(this.options.axis == "vertical" ? "height" : "width"),10)) : null;
},
ui: function(e) {
return {
instance: this,
options: this.options,
handle: this.currentHandle,
value: this.options.axis != "both" || !this.options.axis ? Math.round(this.value(null,this.options.axis == "vertical" ? 2 : 1)) : {
x: Math.round(this.value(null,1)),
y: Math.round(this.value(null,2))
},
range: this.getRange()
};
},
propagate: function(n,e) {
$.ui.plugin.call(this, n, [e, this.ui()]);
this.element.triggerHandler(n == "slide" ? n : "slide"+n, [e, this.ui()], this.options[n]);
},
destroy: function() {
this.element
.removeClass("ui-slider ui-slider-disabled")
.removeData("slider")
.unbind(".slider");
this.handle.mouse("destroy");
this.generated && this.generated.remove();
},
enable: function() {
this.element.removeClass("ui-slider-disabled");
this.disabled = false;
},
disable: function() {
this.element.addClass("ui-slider-disabled");
this.disabled = true;
},
focus: function(handle,hard) {
this.currentHandle = $(handle).addClass('ui-slider-handle-active');
if (hard)
this.currentHandle.parent()[0].focus();
},
blur: function(handle) {
$(handle).removeClass('ui-slider-handle-active');
if(this.currentHandle && this.currentHandle[0] == handle) { this.previousHandle = this.currentHandle; this.currentHandle = null; };
},
value: function(handle, axis) {
if(this.handle.length == 1) this.currentHandle = this.handle;
if(!axis) axis = this.options.axis == "vertical" ? 2 : 1;
var value = ((parseInt($(handle != undefined && handle !== null ? this.handle[handle] || handle : this.currentHandle).css(axis == 1 ? "left" : "top"),10) / (this.actualSize[axis == 1 ? "width" : "height"] - this.handleSize(handle,axis))) * this.options.realMax[axis == 1 ? "x" : "y"]) + this.options.min[axis == 1 ? "x" : "y"];
var o = this.options;
if (o.stepping[axis == 1 ? "x" : "y"]) {
value = Math.round(value / o.stepping[axis == 1 ? "x" : "y"]) * o.stepping[axis == 1 ? "x" : "y"];
}
return value;
},
convertValue: function(value,axis) {
if(!axis) axis = this.options.axis == "vertical" ? 2 : 1;
return this.options.min[axis == 1 ? "x" : "y"] + (value / (this.actualSize[axis == 1 ? "width" : "height"] - this.handleSize(null,axis))) * this.options.realMax[axis == 1 ? "x" : "y"];
},
translateValue: function(value,axis) {
if(!axis) axis = this.options.axis == "vertical" ? 2 : 1;
return ((value - this.options.min[axis == 1 ? "x" : "y"]) / this.options.realMax[axis == 1 ? "x" : "y"]) * (this.actualSize[axis == 1 ? "width" : "height"] - this.handleSize(null,axis));
},
handleSize: function(handle,axis) {
if(!axis) axis = this.options.axis == "vertical" ? 2 : 1;
return $(handle != undefined && handle !== null ? this.handle[handle] : this.currentHandle)[0][axis == 1 ? "offsetWidth" : "offsetHeight"];
},
click: function(e) {
// This method is only used if:
// - The user didn't click a handle
// - The Slider is not disabled
// - There is a current, or previous selected handle (otherwise we wouldn't know which one to move)
var pointer = [e.pageX,e.pageY];
var clickedHandle = false;
this.handle.each(function() {
if(this == e.target)
clickedHandle = true;
});
if (clickedHandle || this.disabled || !(this.currentHandle || this.previousHandle))
return;
// If a previous handle was focussed, focus it again
if (!this.currentHandle && this.previousHandle)
this.focus(this.previousHandle, true);
// Move focussed handle to the clicked position
this.offset = this.element.offset();
// propagate only for distance > 0, otherwise propagation is done my drag
this.moveTo({
y: this.convertValue(e.pageY - this.offset.top - this.currentHandle.outerHeight()/2),
x: this.convertValue(e.pageX - this.offset.left - this.currentHandle.outerWidth()/2)
}, null, !this.options.distance);
},
start: function(e, handle) {
var o = this.options;
// This is a especially ugly fix for strange blur events happening on mousemove events
if (!this.currentHandle)
this.focus(this.previousHandle, true);
this.offset = this.element.offset();
this.handleOffset = this.currentHandle.offset();
this.clickOffset = { top: e.pageY - this.handleOffset.top, left: e.pageX - this.handleOffset.left };
this.firstValue = this.value();
this.propagate('start', e);
return false;
},
stop: function(e) {
this.propagate('stop', e);
if (this.firstValue != this.value())
this.propagate('change', e);
this.focus(this.currentHandle, true); //This is a especially ugly fix for strange blur events happening on mousemove events
return false;
},
oneStep: function(axis) {
if(!axis) axis = this.options.axis == "vertical" ? 2 : 1;
return this.options.stepping[axis == 1 ? "x" : "y"] ? this.options.stepping[axis == 1 ? "x" : "y"] : (this.options.realMax[axis == 1 ? "x" : "y"] / this.actualSize[axis == 1 ? "width" : "height"]) * 5;
},
translateRange: function(value,axis) {
if (this.rangeElement) {
if (this.currentHandle[0] == this.handle[0] && value >= this.translateValue(this.value(1),axis))
value = this.translateValue(this.value(1,axis) - this.oneStep(axis), axis);
if (this.currentHandle[0] == this.handle[1] && value <= this.translateValue(this.value(0),axis))
value = this.translateValue(this.value(0,axis) + this.oneStep(axis));
}
if (this.options.handles) {
var handle = this.options.handles[this.handleIndex()];
if (value < this.translateValue(handle.min,axis)) {
value = this.translateValue(handle.min,axis);
} else if (value > this.translateValue(handle.max,axis)) {
value = this.translateValue(handle.max,axis);
}
}
return value;
},
handleIndex: function() {
return this.handle.index(this.currentHandle[0])
},
translateLimits: function(value,axis) {
if(!axis) axis = this.options.axis == "vertical" ? 2 : 1;
if (value >= this.actualSize[axis == 1 ? "width" : "height"] - this.handleSize(null,axis))
value = this.actualSize[axis == 1 ? "width" : "height"] - this.handleSize(null,axis);
if (value <= 0)
value = 0;
return value;
},
drag: function(e, handle) {
var o = this.options;
var position = { top: e.pageY - this.offset.top - this.clickOffset.top, left: e.pageX - this.offset.left - this.clickOffset.left};
if(!this.currentHandle) this.focus(this.previousHandle, true); //This is a especially ugly fix for strange blur events happening on mousemove events
position.left = this.translateLimits(position.left,1);
position.top = this.translateLimits(position.top,2);
if (o.stepping.x) {
var value = this.convertValue(position.left,1);
value = Math.round(value / o.stepping.x) * o.stepping.x;
position.left = this.translateValue(value, 1);
}
if (o.stepping.y) {
var value = this.convertValue(position.top,2);
value = Math.round(value / o.stepping.y) * o.stepping.y;
position.top = this.translateValue(value, 2);
}
position.left = this.translateRange(position.left, 1);
position.top = this.translateRange(position.top, 2);
if(o.axis != "vertical") this.currentHandle.css({ left: position.left });
if(o.axis != "horizontal") this.currentHandle.css({ top: position.top });
if (this.rangeElement)
this.updateRange();
this.propagate('slide', e);
return false;
},
moveTo: function(value, handle, noPropagation) {
var o = this.options;
if (handle == undefined && !this.currentHandle && this.handle.length != 1)
return false; //If no handle has been passed, no current handle is available and we have multiple handles, return false
if (handle == undefined && !this.currentHandle)
handle = 0; //If only one handle is available, use it
if (handle != undefined)
this.currentHandle = this.previousHandle = $(this.handle[handle] || handle);
if(value.x !== undefined && value.y !== undefined) {
var x = value.x;
var y = value.y;
} else {
var x = value, y = value;
}
if(x && x.constructor != Number) {
var me = /^-=/.test(x), pe = /^+=/.test(x);
if (me) {
x = this.value(null,1) - parseInt(x.replace('-=', ''), 10);
} else if (pe) {
x = this.value(null,1) + parseInt(x.replace('+=', ''), 10);
}
}
if(y && y.constructor != Number) {
var me = /^-=/.test(y), pe = /^+=/.test(y);
if (me) {
y = this.value(null,2) - parseInt(y.replace('-=', ''), 10);
} else if (pe) {
y = this.value(null,2) + parseInt(y.replace('+=', ''), 10);
}
}
if(o.axis != "vertical" && x) {
if(o.stepping.x) x = Math.round(x / o.stepping.x) * o.stepping.x;
x = this.translateValue(x, 1);
x = this.translateLimits(x, 1);
x = this.translateRange(x, 1);
this.currentHandle.css({ left: x });
}
if(o.axis != "horizontal" && y) {
if(o.stepping.y) y = Math.round(y / o.stepping.y) * o.stepping.y;
y = this.translateValue(y, 2);
y = this.translateLimits(y, 2);
y = this.translateRange(y, 2);
this.currentHandle.css({ top: y });
}
if (this.rangeElement)
this.updateRange();
if (!noPropagation) {
this.propagate('start', null);
this.propagate('stop', null);
this.propagate('change', null);
this.propagate("slide", null);
}
}
});
$.ui.slider.getter = "value";
$.ui.slider.defaults = {
handle: ".ui-slider-handle",
distance: 1
};
})(jQuery);
/*
* jQuery UI Tabs
*
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* http://docs.jquery.com/UI/Tabs
*
* Depends:
* ui.core.js
*
* Revision: $Id: ui.tabs.js 5439 2008-05-04 23:46:46Z klaus.hartl $
*/
;(function($) {
$.widget("ui.tabs", {
init: function() {
var self = this;
this.options.event += '.tabs'; // namespace event
$(this.element).bind('setData.tabs', function(event, key, value) {
if ((/^selected/).test(key))
self.select(value);
else {
self.options[key] = value;
self.tabify();
}
}).bind('getData.tabs', function(event, key) {
return self.options[key];
});
// create tabs
this.tabify(true);
},
length: function() {
return this.$tabs.length;
},
tabId: function(a) {
return a.title && a.title.replace(/s/g, '_').replace(/[^A-Za-z0-9-_:.]/g, '')
|| this.options.idPrefix + $.data(a);
},
ui: function(tab, panel) {
return {
instance: this,
options: this.options,
tab: tab,
panel: panel
};
},
tabify: function(init) {
this.$lis = $('li:has(a[href])', this.element);
this.$tabs = this.$lis.map(function() { return $('a', this)[0]; });
this.$panels = $([]);
var self = this, o = this.options;
this.$tabs.each(function(i, a) {
// inline tab
if (a.hash && a.hash.replace('#', '')) // Safari 2 reports '#' for an empty hash
self.$panels = self.$panels.add(a.hash);
// remote tab
else if ($(a).attr('href') != '#') { // prevent loading the page itself if href is just "#"
$.data(a, 'href.tabs', a.href); // required for restore on destroy
$.data(a, 'load.tabs', a.href); // mutable
var id = self.tabId(a);
a.href = '#' + id;
var $panel = $('#' + id);
if (!$panel.length) {
$panel = $(o.panelTemplate).attr('id', id).addClass(o.panelClass)
.insertAfter( self.$panels[i - 1] || self.element );
$panel.data('destroy.tabs', true);
}
self.$panels = self.$panels.add( $panel );
}
// invalid tab href
else
o.disabled.push(i + 1);
});
if (init) {
// attach necessary classes for styling if not present
$(this.element).hasClass(o.navClass) || $(this.element).addClass(o.navClass);
this.$panels.each(function() {
var $this = $(this);
$this.hasClass(o.panelClass) || $this.addClass(o.panelClass);
});
// Try to retrieve selected tab:
// 1. from fragment identifier in url if present
// 2. from cookie
// 3. from selected class attribute on <li>
// 4. otherwise use given "selected" option
// 5. check if tab is disabled
this.$tabs.each(function(i, a) {
if (location.hash) {
if (a.hash == location.hash) {
o.selected = i;
// prevent page scroll to fragment
//if (($.browser.msie || $.browser.opera) && !o.remote) {
if ($.browser.msie || $.browser.opera) {
var $toShow = $(location.hash), toShowId = $toShow.attr('id');
$toShow.attr('id', '');
setTimeout(function() {
$toShow.attr('id', toShowId); // restore id
}, 500);
}
scrollTo(0, 0);
return false; // break
}
} else if (o.cookie) {
var index = parseInt($.cookie('ui-tabs' + $.data(self.element)),10);
if (index && self.$tabs[index]) {
o.selected = index;
return false; // break
}
} else if ( self.$lis.eq(i).hasClass(o.selectedClass) ) {
o.selected = i;
return false; // break
}
});
// highlight selected tab
this.$panels.addClass(o.hideClass);
this.$lis.removeClass(o.selectedClass);
if (o.selected !== null) {
this.$panels.eq(o.selected).show().removeClass(o.hideClass); // use show and remove class to show in any case no matter how it has been hidden before
this.$lis.eq(o.selected).addClass(o.selectedClass);
// seems to be expected behavior that the show callback is fired
var onShow = function() {
$(self.element).triggerHandler('tabsshow',
[self.ui(self.$tabs[o.selected], self.$panels[o.selected])], o.show);
};
// load if remote tab
if ($.data(this.$tabs[o.selected], 'load.tabs'))
this.load(o.selected, onShow);
// just trigger show event
else
onShow();
}
// Take disabling tabs via class attribute from HTML
// into account and update option properly...
o.disabled = $.unique(o.disabled.concat(
$.map(this.$lis.filter('.' + o.disabledClass),
function(n, i) { return self.$lis.index(n); } )
)).sort();
// clean up to avoid memory leaks in certain versions of IE 6
$(window).bind('unload', function() {
self.$tabs.unbind('.tabs');
self.$lis = self.$tabs = self.$panels = null;
});
}
// disable tabs
for (var i = 0, li; li = this.$lis[i]; i++)
$(li)[$.inArray(i, o.disabled) != -1 && !$(li).hasClass(o.selectedClass) ? 'addClass' : 'removeClass'](o.disabledClass);
// reset cache if switching from cached to not cached
if (o.cache === false)
this.$tabs.removeData('cache.tabs');
// set up animations
var hideFx, showFx, baseFx = { 'min-width': 0, duration: 1 }, baseDuration = 'normal';
if (o.fx && o.fx.constructor == Array)
hideFx = o.fx[0] || baseFx, showFx = o.fx[1] || baseFx;
else
hideFx = showFx = o.fx || baseFx;
// reset some styles to maintain print style sheets etc.
var resetCSS = { display: '', overflow: '', height: '' };
if (!$.browser.msie) // not in IE to prevent ClearType font issue
resetCSS.opacity = '';
// Hide a tab, animation prevents browser scrolling to fragment,
// $show is optional.
function hideTab(clicked, $hide, $show) {
$hide.animate(hideFx, hideFx.duration || baseDuration, function() { //
$hide.addClass(o.hideClass).css(resetCSS); // maintain flexible height and accessibility in print etc.
if ($.browser.msie && hideFx.opacity)
$hide[0].style.filter = '';
if ($show)
showTab(clicked, $show, $hide);
});
}
// Show a tab, animation prevents browser scrolling to fragment,
// $hide is optional.
function showTab(clicked, $show, $hide) {
if (showFx === baseFx)
$show.css('display', 'block'); // prevent occasionally occuring flicker in Firefox cause by gap between showing and hiding the tab panels
$show.animate(showFx, showFx.duration || baseDuration, function() {
$show.removeClass(o.hideClass).css(resetCSS); // maintain flexible height and accessibility in print etc.
if ($.browser.msie && showFx.opacity)
$show[0].style.filter = '';
// callback
$(self.element).triggerHandler('tabsshow',
[self.ui(clicked, $show[0])], o.show);
});
}
// switch a tab
function switchTab(clicked, $li, $hide, $show) {
/*if (o.bookmarkable && trueClick) { // add to history only if true click occured, not a triggered click
$.ajaxHistory.update(clicked.hash);
}*/
$li.addClass(o.selectedClass)
.siblings().removeClass(o.selectedClass);
hideTab(clicked, $hide, $show);
}
// attach tab event handler, unbind to avoid duplicates from former tabifying...
this.$tabs.unbind('.tabs').bind(o.event, function() {
//var trueClick = e.clientX; // add to history only if true click occured, not a triggered click
var $li = $(this).parents('li:eq(0)'),
$hide = self.$panels.filter(':visible'),
$show = $(this.hash);
// If tab is already selected and not unselectable or tab disabled or
// or is already loading or click callback returns false stop here.
// Check if click handler returns false last so that it is not executed
// for a disabled or loading tab!
if (($li.hasClass(o.selectedClass) && !o.unselect)
|| $li.hasClass(o.disabledClass)
|| $(this).hasClass(o.loadingClass)
|| $(self.element).triggerHandler('tabsselect', [self.ui(this, $show[0])], o.select) === false
) {
this.blur();
return false;
}
self.options.selected = self.$tabs.index(this);
// if tab may be closed
if (o.unselect) {
if ($li.hasClass(o.selectedClass)) {
self.options.selected = null;
$li.removeClass(o.selectedClass);
self.$panels.stop();
hideTab(this, $hide);
this.blur();
return false;
} else if (!$hide.length) {
self.$panels.stop();
var a = this;
self.load(self.$tabs.index(this), function() {
$li.addClass(o.selectedClass).addClass(o.unselectClass);
showTab(a, $show);
});
this.blur();
return false;
}
}
if (o.cookie)
$.cookie('ui-tabs' + $.data(self.element), self.options.selected, o.cookie);
// stop possibly running animations
self.$panels.stop();
// show new tab
if ($show.length) {
// prevent scrollbar scrolling to 0 and than back in IE7, happens only if bookmarking/history is enabled
/*if ($.browser.msie && o.bookmarkable) {
var showId = this.hash.replace('#', '');
$show.attr('id', '');
setTimeout(function() {
$show.attr('id', showId); // restore id
}, 0);
}*/
var a = this;
self.load(self.$tabs.index(this), $hide.length ?
function() {
switchTab(a, $li, $hide, $show);
} :
function() {
$li.addClass(o.selectedClass);
showTab(a, $show);
}
);
// Set scrollbar to saved position - need to use timeout with 0 to prevent browser scroll to target of hash
/*var scrollX = window.pageXOffset || document.documentElement && document.documentElement.scrollLeft || document.body.scrollLeft || 0;
var scrollY = window.pageYOffset || document.documentElement && document.documentElement.scrollTop || document.body.scrollTop || 0;
setTimeout(function() {
scrollTo(scrollX, scrollY);
}, 0);*/
} else
throw 'jQuery UI Tabs: Mismatching fragment identifier.';
// Prevent IE from keeping other link focussed when using the back button
// and remove dotted border from clicked link. This is controlled in modern
// browsers via CSS, also blur removes focus from address bar in Firefox
// which can become a usability and annoying problem with tabsRotate.
if ($.browser.msie)
this.blur();
//return o.bookmarkable && !!trueClick; // convert trueClick == undefined to Boolean required in IE
return false;
});
// disable click if event is configured to something else
if (!(/^click/).test(o.event))
this.$tabs.bind('click.tabs', function() { return false; });
},
add: function(url, label, index) {
if (index == undefined)
index = this.$tabs.length; // append by default
var o = this.options;
var $li = $(o.tabTemplate.replace(/#{href}/, url).replace(/#{label}/, label));
$li.data('destroy.tabs', true);
var id = url.indexOf('#') == 0 ? url.replace('#', '') : this.tabId( $('a:first-child', $li)[0] );
// try to find an existing element before creating a new one
var $panel = $('#' + id);
if (!$panel.length) {
$panel = $(o.panelTemplate).attr('id', id)
.addClass(o.panelClass).addClass(o.hideClass);
$panel.data('destroy.tabs', true);
}
if (index >= this.$lis.length) {
$li.appendTo(this.element);
$panel.appendTo(this.element[0].parentNode);
} else {
$li.insertBefore(this.$lis[index]);
$panel.insertBefore(this.$panels[index]);
}
o.disabled = $.map(o.disabled,
function(n, i) { return n >= index ? ++n : n });
this.tabify();
if (this.$tabs.length == 1) {
$li.addClass(o.selectedClass);
$panel.removeClass(o.hideClass);
var href = $.data(this.$tabs[0], 'load.tabs');
if (href)
this.load(index, href);
}
// callback
$(this.element).triggerHandler('tabsadd',
[this.ui(this.$tabs[index], this.$panels[index])], o.add
);
},
remove: function(index) {
var o = this.options, $li = this.$lis.eq(index).remove(),
$panel = this.$panels.eq(index).remove();
// If selected tab was removed focus tab to the right or
// in case the last tab was removed the tab to the left.
if ($li.hasClass(o.selectedClass) && this.$tabs.length > 1)
this.select(index + (index + 1 < this.$tabs.length ? 1 : -1));
o.disabled = $.map($.grep(o.disabled, function(n, i) { return n != index; }),
function(n, i) { return n >= index ? --n : n });
this.tabify();
// callback
$(this.element).triggerHandler('tabsremove',
[this.ui($li.find('a')[0], $panel[0])], o.remove
);
},
enable: function(index) {
var o = this.options;
if ($.inArray(index, o.disabled) == -1)
return;
var $li = this.$lis.eq(index).removeClass(o.disabledClass);
if ($.browser.safari) { // fix disappearing tab (that used opacity indicating disabling) after enabling in Safari 2...
$li.css('display', 'inline-block');
setTimeout(function() {
$li.css('display', 'block');
}, 0);
}
o.disabled = $.grep(o.disabled, function(n, i) { return n != index; });
// callback
$(this.element).triggerHandler('tabsenable',