|
|
|
@ -20,6 +20,7 @@ authors: |
|
|
|
- Tim Wienk |
|
|
|
- Christoph Pojer |
|
|
|
- Aaron Newton |
|
|
|
- Jacob Thornton |
|
|
|
|
|
|
|
requires: |
|
|
|
- Core/MooTools |
|
|
|
@ -30,8 +31,8 @@ provides: [MooTools.More] |
|
|
|
*/ |
|
|
|
|
|
|
|
MooTools.More = { |
|
|
|
'version': '1.3.1.1', |
|
|
|
'build': '0292a3af1eea242b817fecf9daa127417d10d4ce' |
|
|
|
'version': '1.3.2.1', |
|
|
|
'build': 'e586bcd2496e9b22acfde32e12f84d49ce09e59d' |
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
@ -182,7 +183,7 @@ String.implement({ |
|
|
|
|
|
|
|
}); |
|
|
|
|
|
|
|
}).call(this); |
|
|
|
})(); |
|
|
|
|
|
|
|
|
|
|
|
/* |
|
|
|
@ -506,7 +507,7 @@ Events.implement(Events.Pseudos(pseudos, proto.addEvent, proto.removeEvent)); |
|
|
|
if (this[klass]) this[klass].implement(Events.prototype); |
|
|
|
}); |
|
|
|
|
|
|
|
}).call(this); |
|
|
|
})(); |
|
|
|
|
|
|
|
|
|
|
|
/* |
|
|
|
@ -544,7 +545,7 @@ Event.definePseudo = function(key, listener){ |
|
|
|
var proto = Element.prototype; |
|
|
|
[Element, Window, Document].invoke('implement', Events.Pseudos(pseudos, proto.addEvent, proto.removeEvent)); |
|
|
|
|
|
|
|
}).call(this); |
|
|
|
})(); |
|
|
|
|
|
|
|
|
|
|
|
/* |
|
|
|
@ -586,6 +587,12 @@ var check = function(split, target, event){ |
|
|
|
return Slick.match(target, split.value) && (!condition || condition.call(target, event)); |
|
|
|
}; |
|
|
|
|
|
|
|
var bubbleUp = function(split, event, fn){ |
|
|
|
for (var target = event.target; target && target != this; target = document.id(target.parentNode)){ |
|
|
|
if (target && check(split, target, event)) return fn.call(target, event, target); |
|
|
|
} |
|
|
|
}; |
|
|
|
|
|
|
|
var formObserver = function(eventName){ |
|
|
|
|
|
|
|
var $delegationKey = '$delegation:'; |
|
|
|
@ -607,16 +614,20 @@ var formObserver = function(eventName){ |
|
|
|
var event = args[0], |
|
|
|
forms = this.retrieve($delegationKey + 'forms', []), |
|
|
|
target = event.target, |
|
|
|
form = (target.get('tag') == 'form') ? target : event.target.getParent('form'), |
|
|
|
formEvents = form.retrieve($delegationKey + 'originalFn', []), |
|
|
|
formListeners = form.retrieve($delegationKey + 'listeners', []); |
|
|
|
form = (target.get('tag') == 'form') ? target : event.target.getParent('form'); |
|
|
|
|
|
|
|
if (!form) return; |
|
|
|
|
|
|
|
var formEvents = form.retrieve($delegationKey + 'originalFn', []), |
|
|
|
formListeners = form.retrieve($delegationKey + 'listeners', []), |
|
|
|
self = this; |
|
|
|
|
|
|
|
forms.include(form); |
|
|
|
this.store($delegationKey + 'forms', forms); |
|
|
|
|
|
|
|
if (!formEvents.contains(fn)){ |
|
|
|
var formListener = function(event){ |
|
|
|
if (check(split, this, event)) fn.call(this, event); |
|
|
|
bubbleUp.call(self, split, event, fn); |
|
|
|
}; |
|
|
|
form.addEvent(eventName, formListener); |
|
|
|
|
|
|
|
@ -636,9 +647,9 @@ var inputObserver = function(eventName){ |
|
|
|
listener: function(split, fn, args){ |
|
|
|
var events = {blur: function(){ |
|
|
|
this.removeEvents(events); |
|
|
|
}}; |
|
|
|
}}, self = this; |
|
|
|
events[eventName] = function(event){ |
|
|
|
if (check(split, this, event)) fn.call(this, event); |
|
|
|
bubbleUp.call(self, split, event, fn); |
|
|
|
}; |
|
|
|
args[0].target.addEvents(events); |
|
|
|
} |
|
|
|
@ -669,24 +680,14 @@ if (!eventListenerSupport) Object.append(eventOptions, { |
|
|
|
select: inputObserver('select') |
|
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
Event.definePseudo('relay', { |
|
|
|
listener: function(split, fn, args, monitor, options){ |
|
|
|
var event = args[0]; |
|
|
|
|
|
|
|
for (var target = event.target; target && target != this; target = target.parentNode){ |
|
|
|
var finalTarget = document.id(target); |
|
|
|
if (check(split, finalTarget, event)){ |
|
|
|
if (finalTarget) fn.call(finalTarget, event, finalTarget); |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
listener: function(split, fn, args){ |
|
|
|
bubbleUp.call(this, split, args[0], fn); |
|
|
|
}, |
|
|
|
options: eventOptions |
|
|
|
}); |
|
|
|
|
|
|
|
}).call(this); |
|
|
|
|
|
|
|
})(); |
|
|
|
|
|
|
|
|
|
|
|
/* |
|
|
|
@ -826,7 +827,7 @@ Fx.Slide = new Class({ |
|
|
|
|
|
|
|
this.addEvent('complete', function(){ |
|
|
|
this.open = (wrapper['offset' + this.layout.capitalize()] != 0); |
|
|
|
if (this.open && options.resetHeight) wrapper.setStyle('height', ''); |
|
|
|
if (this.open && this.options.resetHeight) wrapper.setStyle('height', ''); |
|
|
|
}, true); |
|
|
|
}, |
|
|
|
|
|
|
|
@ -1050,12 +1051,6 @@ var Drag = new Class({ |
|
|
|
var limit = options.limit; |
|
|
|
this.limit = {x: [], y: []}; |
|
|
|
|
|
|
|
var styles = this.element.getStyles('left', 'right', 'top', 'bottom'); |
|
|
|
this._invert = { |
|
|
|
x: options.modifiers.x == 'left' && styles.left == 'auto' && !isNaN(styles.right.toInt()) && (options.modifiers.x = 'right'), |
|
|
|
y: options.modifiers.y == 'top' && styles.top == 'auto' && !isNaN(styles.bottom.toInt()) && (options.modifiers.y = 'bottom') |
|
|
|
}; |
|
|
|
|
|
|
|
var z, coordinates; |
|
|
|
for (z in options.modifiers){ |
|
|
|
if (!options.modifiers[z]) continue; |
|
|
|
@ -1072,7 +1067,6 @@ var Drag = new Class({ |
|
|
|
else this.value.now[z] = this.element[options.modifiers[z]]; |
|
|
|
|
|
|
|
if (options.invert) this.value.now[z] *= -1; |
|
|
|
if (this._invert[z]) this.value.now[z] *= -1; |
|
|
|
|
|
|
|
this.mouse.pos[z] = event.page[z] - this.value.now[z]; |
|
|
|
|
|
|
|
@ -1122,7 +1116,6 @@ var Drag = new Class({ |
|
|
|
this.value.now[z] = this.mouse.now[z] - this.mouse.pos[z]; |
|
|
|
|
|
|
|
if (options.invert) this.value.now[z] *= -1; |
|
|
|
if (this._invert[z]) this.value.now[z] *= -1; |
|
|
|
|
|
|
|
if (options.limit && this.limit[z]){ |
|
|
|
if ((this.limit[z][1] || this.limit[z][1] === 0) && (this.value.now[z] > this.limit[z][1])){ |
|
|
|
@ -1236,10 +1229,9 @@ Drag.Move = new Class({ |
|
|
|
this.container = document.id(this.container.getDocument().body); |
|
|
|
|
|
|
|
if (this.options.style){ |
|
|
|
if (this.options.modifiers.x == "left" && this.options.modifiers.y == "top"){ |
|
|
|
var parentStyles, |
|
|
|
parent = element.getOffsetParent(); |
|
|
|
var styles = element.getStyles('left', 'top'); |
|
|
|
if (this.options.modifiers.x == 'left' && this.options.modifiers.y == 'top'){ |
|
|
|
var parent = element.getOffsetParent(), |
|
|
|
styles = element.getStyles('left', 'top'); |
|
|
|
if (parent && (styles.left == 'auto' || styles.top == 'auto')){ |
|
|
|
element.setPosition(element.getPosition(parent)); |
|
|
|
} |
|
|
|
@ -1640,8 +1632,7 @@ Request.JSONP = new Class({ |
|
|
|
|
|
|
|
Implements: [Chain, Events, Options], |
|
|
|
|
|
|
|
options: { |
|
|
|
/* |
|
|
|
options: {/* |
|
|
|
onRequest: function(src, scriptElement){}, |
|
|
|
onComplete: function(data){}, |
|
|
|
onSuccess: function(data){}, |
|
|
|
@ -1708,7 +1699,8 @@ Request.JSONP = new Class({ |
|
|
|
}, |
|
|
|
|
|
|
|
getScript: function(src){ |
|
|
|
if (!this.script) this.script = new Element('script[type=text/javascript]', { |
|
|
|
if (!this.script) this.script = new Element('script', { |
|
|
|
type: 'text/javascript', |
|
|
|
async: true, |
|
|
|
src: src |
|
|
|
}); |
|
|
|
@ -1716,7 +1708,7 @@ Request.JSONP = new Class({ |
|
|
|
}, |
|
|
|
|
|
|
|
success: function(args, index){ |
|
|
|
if (!this.running) return false; |
|
|
|
if (!this.running) return; |
|
|
|
this.clear() |
|
|
|
.fireEvent('complete', args).fireEvent('success', args) |
|
|
|
.callChain(); |
|
|
|
@ -1835,10 +1827,10 @@ Class.refactor = function(original, refactors){ |
|
|
|
|
|
|
|
Object.each(refactors, function(item, name){ |
|
|
|
var origin = original.prototype[name]; |
|
|
|
if (origin && origin.$origin) origin = origin.$origin; |
|
|
|
origin = (origin && origin.$origin) || origin || function(){}; |
|
|
|
original.implement(name, (typeof item == 'function') ? function(){ |
|
|
|
var old = this.previous; |
|
|
|
this.previous = origin || function(){}; |
|
|
|
this.previous = origin; |
|
|
|
var value = item.apply(this, arguments); |
|
|
|
this.previous = old; |
|
|
|
return value; |
|
|
|
@ -1875,7 +1867,7 @@ provides: [Class.Binds] |
|
|
|
|
|
|
|
Class.Mutators.Binds = function(binds){ |
|
|
|
if (!this.prototype.initialize) this.implement('initialize', function(){}); |
|
|
|
return binds; |
|
|
|
return Array.from(binds).concat(this.prototype.Binds || []); |
|
|
|
}; |
|
|
|
|
|
|
|
Class.Mutators.initialize = function(initialize){ |
|
|
|
@ -2055,7 +2047,7 @@ Element.implement({ |
|
|
|
|
|
|
|
}); |
|
|
|
|
|
|
|
}).call(this); |
|
|
|
})(); |
|
|
|
|
|
|
|
|
|
|
|
/* |
|
|
|
@ -2071,219 +2063,228 @@ license: MIT-style license |
|
|
|
|
|
|
|
authors: |
|
|
|
- Aaron Newton |
|
|
|
- Jacob Thornton |
|
|
|
|
|
|
|
requires: |
|
|
|
- Core/Options |
|
|
|
- Core/Element.Dimensions |
|
|
|
- /Element.Measure |
|
|
|
- Element.Measure |
|
|
|
|
|
|
|
provides: [Element.Position] |
|
|
|
|
|
|
|
... |
|
|
|
*/ |
|
|
|
|
|
|
|
(function(){ |
|
|
|
(function(original){ |
|
|
|
|
|
|
|
var original = Element.prototype.position; |
|
|
|
var local = Element.Position = { |
|
|
|
|
|
|
|
Element.implement({ |
|
|
|
options: {/* |
|
|
|
edge: false, |
|
|
|
returnPos: false, |
|
|
|
minimum: {x: 0, y: 0}, |
|
|
|
maximum: {x: 0, y: 0}, |
|
|
|
relFixedPosition: false, |
|
|
|
ignoreMargins: false, |
|
|
|
ignoreScroll: false, |
|
|
|
allowNegative: false,*/ |
|
|
|
relativeTo: document.body, |
|
|
|
position: { |
|
|
|
x: 'center', //left, center, right
|
|
|
|
y: 'center' //top, center, bottom
|
|
|
|
}, |
|
|
|
offset: {x: 0, y: 0} |
|
|
|
}, |
|
|
|
|
|
|
|
position: function(options){ |
|
|
|
//call original position if the options are x/y values
|
|
|
|
if (options && (options.x != null || options.y != null)){ |
|
|
|
return original ? original.apply(this, arguments) : this; |
|
|
|
} |
|
|
|
getOptions: function(element, options){ |
|
|
|
options = Object.merge({}, local.options, options); |
|
|
|
local.setPositionOption(options); |
|
|
|
local.setEdgeOption(options); |
|
|
|
local.setOffsetOption(element, options); |
|
|
|
local.setDimensionsOption(element, options); |
|
|
|
return options; |
|
|
|
}, |
|
|
|
|
|
|
|
Object.each(options || {}, function(v, k){ |
|
|
|
if (v == null) delete options[k]; |
|
|
|
}); |
|
|
|
setPositionOption: function(options){ |
|
|
|
options.position = local.getCoordinateFromValue(options.position); |
|
|
|
}, |
|
|
|
|
|
|
|
options = Object.merge({ |
|
|
|
// minimum: { x: 0, y: 0 },
|
|
|
|
// maximum: { x: 0, y: 0},
|
|
|
|
relativeTo: document.body, |
|
|
|
position: { |
|
|
|
x: 'center', //left, center, right
|
|
|
|
y: 'center' //top, center, bottom
|
|
|
|
}, |
|
|
|
offset: {x: 0, y: 0}/*, |
|
|
|
edge: false, |
|
|
|
returnPos: false, |
|
|
|
relFixedPosition: false, |
|
|
|
ignoreMargins: false, |
|
|
|
ignoreScroll: false, |
|
|
|
allowNegative: false*/ |
|
|
|
}, options); |
|
|
|
setEdgeOption: function(options){ |
|
|
|
var edgeOption = local.getCoordinateFromValue(options.edge); |
|
|
|
options.edge = edgeOption ? edgeOption : |
|
|
|
(options.position.x == 'center' && options.position.y == 'center') ? {x: 'center', y: 'center'} : |
|
|
|
{x: 'left', y: 'top'}; |
|
|
|
}, |
|
|
|
|
|
|
|
//compute the offset of the parent positioned element if this element is in one
|
|
|
|
setOffsetOption: function(element, options){ |
|
|
|
var parentOffset = {x: 0, y: 0}, |
|
|
|
parentPositioned = false; |
|
|
|
offsetParent = element.measure(function(){ |
|
|
|
return document.id(this.getOffsetParent()); |
|
|
|
}), |
|
|
|
parentScroll = offsetParent.getScroll(); |
|
|
|
|
|
|
|
if (!offsetParent || offsetParent == element.getDocument().body) return; |
|
|
|
parentOffset = offsetParent.measure(function(){ |
|
|
|
var position = this.getPosition(); |
|
|
|
if (this.getStyle('position') == 'fixed'){ |
|
|
|
var scroll = window.getScroll(); |
|
|
|
position.x += scroll.x; |
|
|
|
position.y += scroll.y; |
|
|
|
} |
|
|
|
return position; |
|
|
|
}); |
|
|
|
|
|
|
|
/* dollar around getOffsetParent should not be necessary, but as it does not return |
|
|
|
* a mootools extended element in IE, an error occurs on the call to expose. See: |
|
|
|
* http://mootools.lighthouseapp.com/projects/2706/tickets/333-element-getoffsetparent-inconsistency-between-ie-and-other-browsers */
|
|
|
|
var offsetParent = this.measure(function(){ |
|
|
|
return document.id(this.getOffsetParent()); |
|
|
|
options.offset = { |
|
|
|
parentPositioned: offsetParent != document.id(options.relativeTo), |
|
|
|
x: options.offset.x - parentOffset.x + parentScroll.x, |
|
|
|
y: options.offset.y - parentOffset.y + parentScroll.y |
|
|
|
}; |
|
|
|
}, |
|
|
|
|
|
|
|
setDimensionsOption: function(element, options){ |
|
|
|
options.dimensions = element.getDimensions({ |
|
|
|
computeSize: true, |
|
|
|
styles: ['padding', 'border', 'margin'] |
|
|
|
}); |
|
|
|
if (offsetParent && offsetParent != this.getDocument().body){ |
|
|
|
parentOffset = offsetParent.measure(function(){ |
|
|
|
return this.getPosition(); |
|
|
|
}); |
|
|
|
parentPositioned = offsetParent != document.id(options.relativeTo); |
|
|
|
options.offset.x = options.offset.x - parentOffset.x; |
|
|
|
options.offset.y = options.offset.y - parentOffset.y; |
|
|
|
} |
|
|
|
}, |
|
|
|
|
|
|
|
//upperRight, bottomRight, centerRight, upperLeft, bottomLeft, centerLeft
|
|
|
|
//topRight, topLeft, centerTop, centerBottom, center
|
|
|
|
var fixValue = function(option){ |
|
|
|
if (typeOf(option) != 'string') return option; |
|
|
|
option = option.toLowerCase(); |
|
|
|
var val = {}; |
|
|
|
|
|
|
|
if (option.test('left')){ |
|
|
|
val.x = 'left'; |
|
|
|
} else if (option.test('right')){ |
|
|
|
val.x = 'right'; |
|
|
|
} else { |
|
|
|
val.x = 'center'; |
|
|
|
} |
|
|
|
getPosition: function(element, options){ |
|
|
|
var position = {}; |
|
|
|
options = local.getOptions(element, options); |
|
|
|
var relativeTo = document.id(options.relativeTo) || document.body; |
|
|
|
|
|
|
|
if (option.test('upper') || option.test('top')){ |
|
|
|
val.y = 'top'; |
|
|
|
} else if (option.test('bottom')){ |
|
|
|
val.y = 'bottom'; |
|
|
|
} else { |
|
|
|
val.y = 'center'; |
|
|
|
} |
|
|
|
local.setPositionCoordinates(options, position, relativeTo); |
|
|
|
if (options.edge) local.toEdge(position, options); |
|
|
|
|
|
|
|
return val; |
|
|
|
}; |
|
|
|
var offset = options.offset; |
|
|
|
position.left = ((position.x >= 0 || offset.parentPositioned || options.allowNegative) ? position.x : 0).toInt(); |
|
|
|
position.top = ((position.y >= 0 || offset.parentPositioned || options.allowNegative) ? position.y : 0).toInt(); |
|
|
|
|
|
|
|
options.edge = fixValue(options.edge); |
|
|
|
options.position = fixValue(options.position); |
|
|
|
if (!options.edge){ |
|
|
|
if (options.position.x == 'center' && options.position.y == 'center') options.edge = {x:'center', y:'center'}; |
|
|
|
else options.edge = {x:'left', y:'top'}; |
|
|
|
} |
|
|
|
local.toMinMax(position, options); |
|
|
|
|
|
|
|
this.setStyle('position', 'absolute'); |
|
|
|
var rel = document.id(options.relativeTo) || document.body, |
|
|
|
calc = rel == document.body ? window.getScroll() : rel.getPosition(), |
|
|
|
top = calc.y, left = calc.x; |
|
|
|
if (options.relFixedPosition || relativeTo.getStyle('position') == 'fixed') local.toRelFixedPosition(relativeTo, position); |
|
|
|
if (options.ignoreScroll) local.toIgnoreScroll(relativeTo, position); |
|
|
|
if (options.ignoreMargins) local.toIgnoreMargins(position, options); |
|
|
|
|
|
|
|
var dim = this.getDimensions({ |
|
|
|
computeSize: true, |
|
|
|
styles:['padding', 'border','margin'] |
|
|
|
}); |
|
|
|
position.left = Math.ceil(position.left); |
|
|
|
position.top = Math.ceil(position.top); |
|
|
|
delete position.x; |
|
|
|
delete position.y; |
|
|
|
|
|
|
|
return position; |
|
|
|
}, |
|
|
|
|
|
|
|
var pos = {}, |
|
|
|
prefY = options.offset.y, |
|
|
|
prefX = options.offset.x, |
|
|
|
setPositionCoordinates: function(options, position, relativeTo){ |
|
|
|
var offsetY = options.offset.y, |
|
|
|
offsetX = options.offset.x, |
|
|
|
calc = (relativeTo == document.body) ? window.getScroll() : relativeTo.getPosition(), |
|
|
|
top = calc.y, |
|
|
|
left = calc.x, |
|
|
|
winSize = window.getSize(); |
|
|
|
|
|
|
|
switch (options.position.x){ |
|
|
|
case 'left': |
|
|
|
pos.x = left + prefX; |
|
|
|
break; |
|
|
|
case 'right': |
|
|
|
pos.x = left + prefX + rel.offsetWidth; |
|
|
|
break; |
|
|
|
default: //center
|
|
|
|
pos.x = left + ((rel == document.body ? winSize.x : rel.offsetWidth)/2) + prefX; |
|
|
|
break; |
|
|
|
switch(options.position.x){ |
|
|
|
case 'left': position.x = left + offsetX; break; |
|
|
|
case 'right': position.x = left + offsetX + relativeTo.offsetWidth; break; |
|
|
|
default: position.x = left + ((relativeTo == document.body ? winSize.x : relativeTo.offsetWidth) / 2) + offsetX; break; |
|
|
|
} |
|
|
|
|
|
|
|
switch (options.position.y){ |
|
|
|
case 'top': |
|
|
|
pos.y = top + prefY; |
|
|
|
break; |
|
|
|
case 'bottom': |
|
|
|
pos.y = top + prefY + rel.offsetHeight; |
|
|
|
break; |
|
|
|
default: //center
|
|
|
|
pos.y = top + ((rel == document.body ? winSize.y : rel.offsetHeight)/2) + prefY; |
|
|
|
break; |
|
|
|
switch(options.position.y){ |
|
|
|
case 'top': position.y = top + offsetY; break; |
|
|
|
case 'bottom': position.y = top + offsetY + relativeTo.offsetHeight; break; |
|
|
|
default: position.y = top + ((relativeTo == document.body ? winSize.y : relativeTo.offsetHeight) / 2) + offsetY; break; |
|
|
|
} |
|
|
|
}, |
|
|
|
|
|
|
|
if (options.edge){ |
|
|
|
var edgeOffset = {}; |
|
|
|
|
|
|
|
switch (options.edge.x){ |
|
|
|
case 'left': |
|
|
|
edgeOffset.x = 0; |
|
|
|
break; |
|
|
|
case 'right': |
|
|
|
edgeOffset.x = -dim.x-dim.computedRight-dim.computedLeft; |
|
|
|
break; |
|
|
|
default: //center
|
|
|
|
edgeOffset.x = -(dim.totalWidth/2); |
|
|
|
break; |
|
|
|
} |
|
|
|
toMinMax: function(position, options){ |
|
|
|
var xy = {left: 'x', top: 'y'}, value; |
|
|
|
['minimum', 'maximum'].each(function(minmax){ |
|
|
|
['left', 'top'].each(function(lr){ |
|
|
|
value = options[minmax] ? options[minmax][xy[lr]] : null; |
|
|
|
if (value != null && ((minmax == 'minimum') ? position[lr] < value : position[lr] > value)) position[lr] = value; |
|
|
|
}); |
|
|
|
}); |
|
|
|
}, |
|
|
|
|
|
|
|
switch (options.edge.y){ |
|
|
|
case 'top': |
|
|
|
edgeOffset.y = 0; |
|
|
|
break; |
|
|
|
case 'bottom': |
|
|
|
edgeOffset.y = -dim.y-dim.computedTop-dim.computedBottom; |
|
|
|
break; |
|
|
|
default: //center
|
|
|
|
edgeOffset.y = -(dim.totalHeight/2); |
|
|
|
break; |
|
|
|
} |
|
|
|
toRelFixedPosition: function(relativeTo, position){ |
|
|
|
var winScroll = window.getScroll(); |
|
|
|
position.top += winScroll.y; |
|
|
|
position.left += winScroll.x; |
|
|
|
}, |
|
|
|
|
|
|
|
pos.x += edgeOffset.x; |
|
|
|
pos.y += edgeOffset.y; |
|
|
|
} |
|
|
|
toIgnoreScroll: function(relativeTo, position){ |
|
|
|
var relScroll = relativeTo.getScroll(); |
|
|
|
position.top -= relScroll.y; |
|
|
|
position.left -= relScroll.x; |
|
|
|
}, |
|
|
|
|
|
|
|
pos = { |
|
|
|
left: ((pos.x >= 0 || parentPositioned || options.allowNegative) ? pos.x : 0).toInt(), |
|
|
|
top: ((pos.y >= 0 || parentPositioned || options.allowNegative) ? pos.y : 0).toInt() |
|
|
|
}; |
|
|
|
toIgnoreMargins: function(position, options){ |
|
|
|
position.left += options.edge.x == 'right' |
|
|
|
? options.dimensions['margin-right'] |
|
|
|
: (options.edge.x != 'center' |
|
|
|
? -options.dimensions['margin-left'] |
|
|
|
: -options.dimensions['margin-left'] + ((options.dimensions['margin-right'] + options.dimensions['margin-left']) / 2)); |
|
|
|
|
|
|
|
var xy = {left: 'x', top: 'y'}; |
|
|
|
position.top += options.edge.y == 'bottom' |
|
|
|
? options.dimensions['margin-bottom'] |
|
|
|
: (options.edge.y != 'center' |
|
|
|
? -options.dimensions['margin-top'] |
|
|
|
: -options.dimensions['margin-top'] + ((options.dimensions['margin-bottom'] + options.dimensions['margin-top']) / 2)); |
|
|
|
}, |
|
|
|
|
|
|
|
['minimum', 'maximum'].each(function(minmax){ |
|
|
|
['left', 'top'].each(function(lr){ |
|
|
|
var val = options[minmax] ? options[minmax][xy[lr]] : null; |
|
|
|
if (val != null && ((minmax == 'minimum') ? pos[lr] < val : pos[lr] > val)) pos[lr] = val; |
|
|
|
}); |
|
|
|
}); |
|
|
|
toEdge: function(position, options){ |
|
|
|
var edgeOffset = {}, |
|
|
|
dimensions = options.dimensions, |
|
|
|
edge = options.edge; |
|
|
|
|
|
|
|
if (rel.getStyle('position') == 'fixed' || options.relFixedPosition){ |
|
|
|
var winScroll = window.getScroll(); |
|
|
|
pos.top+= winScroll.y; |
|
|
|
pos.left+= winScroll.x; |
|
|
|
switch(edge.x){ |
|
|
|
case 'left': edgeOffset.x = 0; break; |
|
|
|
case 'right': edgeOffset.x = -dimensions.x - dimensions.computedRight - dimensions.computedLeft; break; |
|
|
|
// center
|
|
|
|
default: edgeOffset.x = -(Math.round(dimensions.totalWidth / 2)); break; |
|
|
|
} |
|
|
|
if (options.ignoreScroll){ |
|
|
|
var relScroll = rel.getScroll(); |
|
|
|
pos.top -= relScroll.y; |
|
|
|
pos.left -= relScroll.x; |
|
|
|
|
|
|
|
switch(edge.y){ |
|
|
|
case 'top': edgeOffset.y = 0; break; |
|
|
|
case 'bottom': edgeOffset.y = -dimensions.y - dimensions.computedTop - dimensions.computedBottom; break; |
|
|
|
// center
|
|
|
|
default: edgeOffset.y = -(Math.round(dimensions.totalHeight / 2)); break; |
|
|
|
} |
|
|
|
|
|
|
|
if (options.ignoreMargins){ |
|
|
|
pos.left += ( |
|
|
|
options.edge.x == 'right' ? dim['margin-right'] : |
|
|
|
options.edge.x == 'center' ? -dim['margin-left'] + ((dim['margin-right'] + dim['margin-left'])/2) : |
|
|
|
- dim['margin-left'] |
|
|
|
); |
|
|
|
pos.top += ( |
|
|
|
options.edge.y == 'bottom' ? dim['margin-bottom'] : |
|
|
|
options.edge.y == 'center' ? -dim['margin-top'] + ((dim['margin-bottom'] + dim['margin-top'])/2) : |
|
|
|
- dim['margin-top'] |
|
|
|
); |
|
|
|
position.x += edgeOffset.x; |
|
|
|
position.y += edgeOffset.y; |
|
|
|
}, |
|
|
|
|
|
|
|
getCoordinateFromValue: function(option){ |
|
|
|
if (typeOf(option) != 'string') return option; |
|
|
|
option = option.toLowerCase(); |
|
|
|
|
|
|
|
return { |
|
|
|
x: option.test('left') ? 'left' |
|
|
|
: (option.test('right') ? 'right' : 'center'), |
|
|
|
y: option.test(/upper|top/) ? 'top' |
|
|
|
: (option.test('bottom') ? 'bottom' : 'center') |
|
|
|
}; |
|
|
|
} |
|
|
|
|
|
|
|
}; |
|
|
|
|
|
|
|
Element.implement({ |
|
|
|
|
|
|
|
position: function(options){ |
|
|
|
if (options && (options.x != null || options.y != null)) { |
|
|
|
return (original ? original.apply(this, arguments) : this); |
|
|
|
} |
|
|
|
var position = this.setStyle('position', 'absolute').calculatePosition(options); |
|
|
|
return (options && options.returnPos) ? position : this.setStyles(position); |
|
|
|
}, |
|
|
|
|
|
|
|
pos.left = Math.ceil(pos.left); |
|
|
|
pos.top = Math.ceil(pos.top); |
|
|
|
if (options.returnPos) return pos; |
|
|
|
else this.setStyles(pos); |
|
|
|
return this; |
|
|
|
calculatePosition: function(options){ |
|
|
|
return local.getPosition(this, options); |
|
|
|
} |
|
|
|
|
|
|
|
}); |
|
|
|
|
|
|
|
}).call(this); |
|
|
|
})(Element.prototype.position); |
|
|
|
|
|
|
|
|
|
|
|
/* |
|
|
|
|
Ruud
14 years ago