";
}
});
Object.extend(Selector, {
matchElements: function(elements, expression) {
var match = Prototype.Selector.match,
results = [];
for (var i = 0, length = elements.length; i < length; i++) {
var element = elements[i];
if (match(element, expression)) {
results.push(Element.extend(element));
}
}
return results;
},
findElement: function(elements, expression, index) {
index = index || 0;
var matchIndex = 0, element;
for (var i = 0, length = elements.length; i < length; i++) {
element = elements[i];
if (Prototype.Selector.match(element, expression) && index === matchIndex++) {
return Element.extend(element);
}
}
},
findChildElements: function(element, expressions) {
var selector = expressions.toArray().join(', ');
return Prototype.Selector.select(selector, element || document);
}
});
})();
// script.aculo.us scriptaculous.js v1.8.3, Thu Oct 08 11:23:33 +0200 2009
// Copyright (c) 2005-2009 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// 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.
//
// For details, see the script.aculo.us web site: http://script.aculo.us/
var Scriptaculous = {
Version: '1.8.3',
require: function(libraryName) {
try{
// inserting via DOM fails in Safari 2.0, so brute force approach
document.write('
*
*
*
* Now whenever you trigger a mouseOver on the `trigger` element, the tooltip element will
* be shown. On o mouseOut the tooltip disappears.
*
* Example:
*
*
*
*
*
*
* Detail infos on product 1....
*
*
*
* This is product 1
*
*
*
*
* You can use my_tooltip.destroy() to remove the event observers and thereby the tooltip.
*/
var Tooltip = Class.create();
Tooltip.prototype = {
initialize: function(element, tool_tip) {
var options = Object.extend({
default_css: false,
margin: "0px",
padding: "5px",
backgroundColor: "#d6d6fc",
min_distance_x: 5,
min_distance_y: 5,
delta_x: 0,
delta_y: 0,
zindex: 1000
}, arguments[2] || {});
this.element = $(element);
this.options = options;
// use the supplied tooltip element or create our own div
if($(tool_tip)) {
this.tool_tip = $(tool_tip);
} else {
this.tool_tip = $(document.createElement("div"));
document.body.appendChild(this.tool_tip);
this.tool_tip.addClassName("tooltip");
this.tool_tip.appendChild(document.createTextNode(tool_tip));
}
// hide the tool-tip by default
this.tool_tip.hide();
this.eventMouseOver = this.showTooltip.bindAsEventListener(this);
this.eventMouseOut = this.hideTooltip.bindAsEventListener(this);
this.eventMouseMove = this.moveTooltip.bindAsEventListener(this);
this.registerEvents();
},
destroy: function() {
Event.stopObserving(this.element, "mouseover", this.eventMouseOver);
Event.stopObserving(this.element, "mouseout", this.eventMouseOut);
Event.stopObserving(this.element, "mousemove", this.eventMouseMove);
},
registerEvents: function() {
Event.observe(this.element, "mouseover", this.eventMouseOver);
Event.observe(this.element, "mouseout", this.eventMouseOut);
Event.observe(this.element, "mousemove", this.eventMouseMove);
},
moveTooltip: function(event){
Event.stop(event);
// get Mouse position
var mouse_x = Event.pointerX(event);
var mouse_y = Event.pointerY(event);
// decide if wee need to switch sides for the tooltip
var dimensions = Element.getDimensions( this.tool_tip );
var element_width = dimensions.width;
var element_height = dimensions.height;
if ( (element_width + mouse_x) >= ( this.getWindowWidth() - this.options.min_distance_x) ){ // too big for X
mouse_x = mouse_x - element_width;
// apply min_distance to make sure that the mouse is not on the tool-tip
mouse_x = mouse_x - this.options.min_distance_x;
} else {
mouse_x = mouse_x + this.options.min_distance_x;
}
if ( (element_height + mouse_y) >= ( this.getWindowHeight() - this.options.min_distance_y) ){ // too big for Y
mouse_y = mouse_y - element_height;
// apply min_distance to make sure that the mouse is not on the tool-tip
mouse_y = mouse_y - this.options.min_distance_y;
} else {
mouse_y = mouse_y + this.options.min_distance_y;
}
// now set the right styles
this.setStyles(mouse_x, mouse_y);
},
showTooltip: function(event) {
Event.stop(event);
this.moveTooltip(event);
new Element.show(this.tool_tip);
},
setStyles: function(x, y){
// set the right styles to position the tool tip
Element.setStyle(this.tool_tip, { position:'absolute',
top:y + this.options.delta_y + "px",
left:x + this.options.delta_x + "px",
zindex:this.options.zindex
});
// apply default theme if wanted
if (this.options.default_css){
Element.setStyle(this.tool_tip, { margin:this.options.margin,
padding:this.options.padding,
backgroundColor:this.options.backgroundColor,
zindex:this.options.zindex
});
}
},
hideTooltip: function(event){
new Element.hide(this.tool_tip);
},
getWindowHeight: function(){
var innerHeight;
if (navigator.appVersion.indexOf('MSIE')>0) {
innerHeight = document.body.clientHeight;
} else {
innerHeight = window.innerHeight;
}
return innerHeight;
},
getWindowWidth: function(){
var innerWidth;
if (navigator.appVersion.indexOf('MSIE')>0) {
innerWidth = document.body.clientWidth;
} else {
innerWidth = window.innerWidth;
}
return innerWidth;
}
}// script.aculo.us effects.js v1.8.3, Thu Oct 08 11:23:33 +0200 2009
// Copyright (c) 2005-2009 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
// Justin Palmer (http://encytemedia.com/)
// Mark Pilgrim (http://diveintomark.org/)
// Martin Bialasinki
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/
// converts rgb() and #xxx to #xxxxxx format,
// returns self (or first argument) if not convertable
String.prototype.parseColor = function() {
var color = '#';
if (this.slice(0,4) == 'rgb(') {
var cols = this.slice(4,this.length-1).split(',');
var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);
} else {
if (this.slice(0,1) == '#') {
if (this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();
if (this.length==7) color = this.toLowerCase();
}
}
return (color.length==7 ? color : (arguments[0] || this));
};
/*--------------------------------------------------------------------------*/
Element.collectTextNodes = function(element) {
return $A($(element).childNodes).collect( function(node) {
return (node.nodeType==3 ? node.nodeValue :
(node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
}).flatten().join('');
};
Element.collectTextNodesIgnoreClass = function(element, className) {
return $A($(element).childNodes).collect( function(node) {
return (node.nodeType==3 ? node.nodeValue :
((node.hasChildNodes() && !Element.hasClassName(node,className)) ?
Element.collectTextNodesIgnoreClass(node, className) : ''));
}).flatten().join('');
};
Element.setContentZoom = function(element, percent) {
element = $(element);
element.setStyle({fontSize: (percent/100) + 'em'});
if (Prototype.Browser.WebKit) window.scrollBy(0,0);
return element;
};
Element.getInlineOpacity = function(element){
return $(element).style.opacity || '';
};
Element.forceRerendering = function(element) {
try {
element = $(element);
var n = document.createTextNode(' ');
element.appendChild(n);
element.removeChild(n);
} catch(e) { }
};
/*--------------------------------------------------------------------------*/
var Effect = {
_elementDoesNotExistError: {
name: 'ElementDoesNotExistError',
message: 'The specified DOM element does not exist, but is required for this effect to operate'
},
Transitions: {
linear: Prototype.K,
sinoidal: function(pos) {
return (-Math.cos(pos*Math.PI)/2) + .5;
},
reverse: function(pos) {
return 1-pos;
},
flicker: function(pos) {
var pos = ((-Math.cos(pos*Math.PI)/4) + .75) + Math.random()/4;
return pos > 1 ? 1 : pos;
},
wobble: function(pos) {
return (-Math.cos(pos*Math.PI*(9*pos))/2) + .5;
},
pulse: function(pos, pulses) {
return (-Math.cos((pos*((pulses||5)-.5)*2)*Math.PI)/2) + .5;
},
spring: function(pos) {
return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6));
},
none: function(pos) {
return 0;
},
full: function(pos) {
return 1;
}
},
DefaultOptions: {
duration: 1.0, // seconds
fps: 100, // 100= assume 66fps max.
sync: false, // true for combining
from: 0.0,
to: 1.0,
delay: 0.0,
queue: 'parallel'
},
tagifyText: function(element) {
var tagifyStyle = 'position:relative';
if (Prototype.Browser.IE) tagifyStyle += ';zoom:1';
element = $(element);
$A(element.childNodes).each( function(child) {
if (child.nodeType==3) {
child.nodeValue.toArray().each( function(character) {
element.insertBefore(
new Element('span', {style: tagifyStyle}).update(
character == ' ' ? String.fromCharCode(160) : character),
child);
});
Element.remove(child);
}
});
},
multiple: function(element, effect) {
var elements;
if (((typeof element == 'object') ||
Object.isFunction(element)) &&
(element.length))
elements = element;
else
elements = $(element).childNodes;
var options = Object.extend({
speed: 0.1,
delay: 0.0
}, arguments[2] || { });
var masterDelay = options.delay;
$A(elements).each( function(element, index) {
new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
});
},
PAIRS: {
'slide': ['SlideDown','SlideUp'],
'blind': ['BlindDown','BlindUp'],
'appear': ['Appear','Fade']
},
toggle: function(element, effect, options) {
element = $(element);
effect = (effect || 'appear').toLowerCase();
return Effect[ Effect.PAIRS[ effect ][ element.visible() ? 1 : 0 ] ](element, Object.extend({
queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
}, options || {}));
}
};
Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;
/* ------------- core effects ------------- */
Effect.ScopedQueue = Class.create(Enumerable, {
initialize: function() {
this.effects = [];
this.interval = null;
},
_each: function(iterator) {
this.effects._each(iterator);
},
add: function(effect) {
var timestamp = new Date().getTime();
var position = Object.isString(effect.options.queue) ?
effect.options.queue : effect.options.queue.position;
switch(position) {
case 'front':
// move unstarted effects after this effect
this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
e.startOn += effect.finishOn;
e.finishOn += effect.finishOn;
});
break;
case 'with-last':
timestamp = this.effects.pluck('startOn').max() || timestamp;
break;
case 'end':
// start effect after last queued effect has finished
timestamp = this.effects.pluck('finishOn').max() || timestamp;
break;
}
effect.startOn += timestamp;
effect.finishOn += timestamp;
if (!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
this.effects.push(effect);
if (!this.interval)
this.interval = setInterval(this.loop.bind(this), 15);
},
remove: function(effect) {
this.effects = this.effects.reject(function(e) { return e==effect });
if (this.effects.length == 0) {
clearInterval(this.interval);
this.interval = null;
}
},
loop: function() {
var timePos = new Date().getTime();
for(var i=0, len=this.effects.length;i= this.startOn) {
if (timePos >= this.finishOn) {
this.render(1.0);
this.cancel();
this.event('beforeFinish');
if (this.finish) this.finish();
this.event('afterFinish');
return;
}
var pos = (timePos - this.startOn) / this.totalTime,
frame = (pos * this.totalFrames).round();
if (frame > this.currentFrame) {
this.render(pos);
this.currentFrame = frame;
}
}
},
cancel: function() {
if (!this.options.sync)
Effect.Queues.get(Object.isString(this.options.queue) ?
'global' : this.options.queue.scope).remove(this);
this.state = 'finished';
},
event: function(eventName) {
if (this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
if (this.options[eventName]) this.options[eventName](this);
},
inspect: function() {
var data = $H();
for(property in this)
if (!Object.isFunction(this[property])) data.set(property, this[property]);
return '#';
}
});
Effect.Parallel = Class.create(Effect.Base, {
initialize: function(effects) {
this.effects = effects || [];
this.start(arguments[1]);
},
update: function(position) {
this.effects.invoke('render', position);
},
finish: function(position) {
this.effects.each( function(effect) {
effect.render(1.0);
effect.cancel();
effect.event('beforeFinish');
if (effect.finish) effect.finish(position);
effect.event('afterFinish');
});
}
});
Effect.Tween = Class.create(Effect.Base, {
initialize: function(object, from, to) {
object = Object.isString(object) ? $(object) : object;
var args = $A(arguments), method = args.last(),
options = args.length == 5 ? args[3] : null;
this.method = Object.isFunction(method) ? method.bind(object) :
Object.isFunction(object[method]) ? object[method].bind(object) :
function(value) { object[method] = value };
this.start(Object.extend({ from: from, to: to }, options || { }));
},
update: function(position) {
this.method(position);
}
});
Effect.Event = Class.create(Effect.Base, {
initialize: function() {
this.start(Object.extend({ duration: 0 }, arguments[0] || { }));
},
update: Prototype.emptyFunction
});
Effect.Opacity = Class.create(Effect.Base, {
initialize: function(element) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
// make this work on IE on elements without 'layout'
if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
this.element.setStyle({zoom: 1});
var options = Object.extend({
from: this.element.getOpacity() || 0.0,
to: 1.0
}, arguments[1] || { });
this.start(options);
},
update: function(position) {
this.element.setOpacity(position);
}
});
Effect.Move = Class.create(Effect.Base, {
initialize: function(element) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({
x: 0,
y: 0,
mode: 'relative'
}, arguments[1] || { });
this.start(options);
},
setup: function() {
this.element.makePositioned();
this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
this.originalTop = parseFloat(this.element.getStyle('top') || '0');
if (this.options.mode == 'absolute') {
this.options.x = this.options.x - this.originalLeft;
this.options.y = this.options.y - this.originalTop;
}
},
update: function(position) {
this.element.setStyle({
left: (this.options.x * position + this.originalLeft).round() + 'px',
top: (this.options.y * position + this.originalTop).round() + 'px'
});
}
});
// for backwards compatibility
Effect.MoveBy = function(element, toTop, toLeft) {
return new Effect.Move(element,
Object.extend({ x: toLeft, y: toTop }, arguments[3] || { }));
};
Effect.Scale = Class.create(Effect.Base, {
initialize: function(element, percent) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({
scaleX: true,
scaleY: true,
scaleContent: true,
scaleFromCenter: false,
scaleMode: 'box', // 'box' or 'contents' or { } with provided values
scaleFrom: 100.0,
scaleTo: percent
}, arguments[2] || { });
this.start(options);
},
setup: function() {
this.restoreAfterFinish = this.options.restoreAfterFinish || false;
this.elementPositioning = this.element.getStyle('position');
this.originalStyle = { };
['top','left','width','height','fontSize'].each( function(k) {
this.originalStyle[k] = this.element.style[k];
}.bind(this));
this.originalTop = this.element.offsetTop;
this.originalLeft = this.element.offsetLeft;
var fontSize = this.element.getStyle('font-size') || '100%';
['em','px','%','pt'].each( function(fontSizeType) {
if (fontSize.indexOf(fontSizeType)>0) {
this.fontSize = parseFloat(fontSize);
this.fontSizeType = fontSizeType;
}
}.bind(this));
this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
this.dims = null;
if (this.options.scaleMode=='box')
this.dims = [this.element.offsetHeight, this.element.offsetWidth];
if (/^content/.test(this.options.scaleMode))
this.dims = [this.element.scrollHeight, this.element.scrollWidth];
if (!this.dims)
this.dims = [this.options.scaleMode.originalHeight,
this.options.scaleMode.originalWidth];
},
update: function(position) {
var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
if (this.options.scaleContent && this.fontSize)
this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
},
finish: function(position) {
if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
},
setDimensions: function(height, width) {
var d = { };
if (this.options.scaleX) d.width = width.round() + 'px';
if (this.options.scaleY) d.height = height.round() + 'px';
if (this.options.scaleFromCenter) {
var topd = (height - this.dims[0])/2;
var leftd = (width - this.dims[1])/2;
if (this.elementPositioning == 'absolute') {
if (this.options.scaleY) d.top = this.originalTop-topd + 'px';
if (this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
} else {
if (this.options.scaleY) d.top = -topd + 'px';
if (this.options.scaleX) d.left = -leftd + 'px';
}
}
this.element.setStyle(d);
}
});
Effect.Highlight = Class.create(Effect.Base, {
initialize: function(element) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || { });
this.start(options);
},
setup: function() {
// Prevent executing on elements not in the layout flow
if (this.element.getStyle('display')=='none') { this.cancel(); return; }
// Disable background image during the effect
this.oldStyle = { };
if (!this.options.keepBackgroundImage) {
this.oldStyle.backgroundImage = this.element.getStyle('background-image');
this.element.setStyle({backgroundImage: 'none'});
}
if (!this.options.endcolor)
this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
if (!this.options.restorecolor)
this.options.restorecolor = this.element.getStyle('background-color');
// init color calculations
this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
},
update: function(position) {
this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
return m+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
},
finish: function() {
this.element.setStyle(Object.extend(this.oldStyle, {
backgroundColor: this.options.restorecolor
}));
}
});
Effect.ScrollTo = function(element) {
var options = arguments[1] || { },
scrollOffsets = document.viewport.getScrollOffsets(),
elementOffsets = $(element).cumulativeOffset();
if (options.offset) elementOffsets[1] += options.offset;
return new Effect.Tween(null,
scrollOffsets.top,
elementOffsets[1],
options,
function(p){ scrollTo(scrollOffsets.left, p.round()); }
);
};
/* ------------- combination effects ------------- */
Effect.Fade = function(element) {
element = $(element);
var oldOpacity = element.getInlineOpacity();
var options = Object.extend({
from: element.getOpacity() || 1.0,
to: 0.0,
afterFinishInternal: function(effect) {
if (effect.options.to!=0) return;
effect.element.hide().setStyle({opacity: oldOpacity});
}
}, arguments[1] || { });
return new Effect.Opacity(element,options);
};
Effect.Appear = function(element) {
element = $(element);
var options = Object.extend({
from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
to: 1.0,
// force Safari to render floated elements properly
afterFinishInternal: function(effect) {
effect.element.forceRerendering();
},
beforeSetup: function(effect) {
effect.element.setOpacity(effect.options.from).show();
}}, arguments[1] || { });
return new Effect.Opacity(element,options);
};
Effect.Puff = function(element) {
element = $(element);
var oldStyle = {
opacity: element.getInlineOpacity(),
position: element.getStyle('position'),
top: element.style.top,
left: element.style.left,
width: element.style.width,
height: element.style.height
};
return new Effect.Parallel(
[ new Effect.Scale(element, 200,
{ sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),
new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],
Object.extend({ duration: 1.0,
beforeSetupInternal: function(effect) {
Position.absolutize(effect.effects[0].element);
},
afterFinishInternal: function(effect) {
effect.effects[0].element.hide().setStyle(oldStyle); }
}, arguments[1] || { })
);
};
Effect.BlindUp = function(element) {
element = $(element);
element.makeClipping();
return new Effect.Scale(element, 0,
Object.extend({ scaleContent: false,
scaleX: false,
restoreAfterFinish: true,
afterFinishInternal: function(effect) {
effect.element.hide().undoClipping();
}
}, arguments[1] || { })
);
};
Effect.BlindDown = function(element) {
element = $(element);
var elementDimensions = element.getDimensions();
return new Effect.Scale(element, 100, Object.extend({
scaleContent: false,
scaleX: false,
scaleFrom: 0,
scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
restoreAfterFinish: true,
afterSetup: function(effect) {
effect.element.makeClipping().setStyle({height: '0px'}).show();
},
afterFinishInternal: function(effect) {
effect.element.undoClipping();
}
}, arguments[1] || { }));
};
Effect.SwitchOff = function(element) {
element = $(element);
var oldOpacity = element.getInlineOpacity();
return new Effect.Appear(element, Object.extend({
duration: 0.4,
from: 0,
transition: Effect.Transitions.flicker,
afterFinishInternal: function(effect) {
new Effect.Scale(effect.element, 1, {
duration: 0.3, scaleFromCenter: true,
scaleX: false, scaleContent: false, restoreAfterFinish: true,
beforeSetup: function(effect) {
effect.element.makePositioned().makeClipping();
},
afterFinishInternal: function(effect) {
effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
}
});
}
}, arguments[1] || { }));
};
Effect.DropOut = function(element) {
element = $(element);
var oldStyle = {
top: element.getStyle('top'),
left: element.getStyle('left'),
opacity: element.getInlineOpacity() };
return new Effect.Parallel(
[ new Effect.Move(element, {x: 0, y: 100, sync: true }),
new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
Object.extend(
{ duration: 0.5,
beforeSetup: function(effect) {
effect.effects[0].element.makePositioned();
},
afterFinishInternal: function(effect) {
effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
}
}, arguments[1] || { }));
};
Effect.Shake = function(element) {
element = $(element);
var options = Object.extend({
distance: 20,
duration: 0.5
}, arguments[1] || {});
var distance = parseFloat(options.distance);
var split = parseFloat(options.duration) / 10.0;
var oldStyle = {
top: element.getStyle('top'),
left: element.getStyle('left') };
return new Effect.Move(element,
{ x: distance, y: 0, duration: split, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: -distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: -distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: -distance, y: 0, duration: split, afterFinishInternal: function(effect) {
effect.element.undoPositioned().setStyle(oldStyle);
}}); }}); }}); }}); }}); }});
};
Effect.SlideDown = function(element) {
element = $(element).cleanWhitespace();
// SlideDown need to have the content of the element wrapped in a container element with fixed height!
var oldInnerBottom = element.down().getStyle('bottom');
var elementDimensions = element.getDimensions();
return new Effect.Scale(element, 100, Object.extend({
scaleContent: false,
scaleX: false,
scaleFrom: window.opera ? 0 : 1,
scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
restoreAfterFinish: true,
afterSetup: function(effect) {
effect.element.makePositioned();
effect.element.down().makePositioned();
if (window.opera) effect.element.setStyle({top: ''});
effect.element.makeClipping().setStyle({height: '0px'}).show();
},
afterUpdateInternal: function(effect) {
effect.element.down().setStyle({bottom:
(effect.dims[0] - effect.element.clientHeight) + 'px' });
},
afterFinishInternal: function(effect) {
effect.element.undoClipping().undoPositioned();
effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
}, arguments[1] || { })
);
};
Effect.SlideUp = function(element) {
element = $(element).cleanWhitespace();
var oldInnerBottom = element.down().getStyle('bottom');
var elementDimensions = element.getDimensions();
return new Effect.Scale(element, window.opera ? 0 : 1,
Object.extend({ scaleContent: false,
scaleX: false,
scaleMode: 'box',
scaleFrom: 100,
scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
restoreAfterFinish: true,
afterSetup: function(effect) {
effect.element.makePositioned();
effect.element.down().makePositioned();
if (window.opera) effect.element.setStyle({top: ''});
effect.element.makeClipping().show();
},
afterUpdateInternal: function(effect) {
effect.element.down().setStyle({bottom:
(effect.dims[0] - effect.element.clientHeight) + 'px' });
},
afterFinishInternal: function(effect) {
effect.element.hide().undoClipping().undoPositioned();
effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom});
}
}, arguments[1] || { })
);
};
// Bug in opera makes the TD containing this element expand for a instance after finish
Effect.Squish = function(element) {
return new Effect.Scale(element, window.opera ? 1 : 0, {
restoreAfterFinish: true,
beforeSetup: function(effect) {
effect.element.makeClipping();
},
afterFinishInternal: function(effect) {
effect.element.hide().undoClipping();
}
});
};
Effect.Grow = function(element) {
element = $(element);
var options = Object.extend({
direction: 'center',
moveTransition: Effect.Transitions.sinoidal,
scaleTransition: Effect.Transitions.sinoidal,
opacityTransition: Effect.Transitions.full
}, arguments[1] || { });
var oldStyle = {
top: element.style.top,
left: element.style.left,
height: element.style.height,
width: element.style.width,
opacity: element.getInlineOpacity() };
var dims = element.getDimensions();
var initialMoveX, initialMoveY;
var moveX, moveY;
switch (options.direction) {
case 'top-left':
initialMoveX = initialMoveY = moveX = moveY = 0;
break;
case 'top-right':
initialMoveX = dims.width;
initialMoveY = moveY = 0;
moveX = -dims.width;
break;
case 'bottom-left':
initialMoveX = moveX = 0;
initialMoveY = dims.height;
moveY = -dims.height;
break;
case 'bottom-right':
initialMoveX = dims.width;
initialMoveY = dims.height;
moveX = -dims.width;
moveY = -dims.height;
break;
case 'center':
initialMoveX = dims.width / 2;
initialMoveY = dims.height / 2;
moveX = -dims.width / 2;
moveY = -dims.height / 2;
break;
}
return new Effect.Move(element, {
x: initialMoveX,
y: initialMoveY,
duration: 0.01,
beforeSetup: function(effect) {
effect.element.hide().makeClipping().makePositioned();
},
afterFinishInternal: function(effect) {
new Effect.Parallel(
[ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
new Effect.Scale(effect.element, 100, {
scaleMode: { originalHeight: dims.height, originalWidth: dims.width },
sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
], Object.extend({
beforeSetup: function(effect) {
effect.effects[0].element.setStyle({height: '0px'}).show();
},
afterFinishInternal: function(effect) {
effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle);
}
}, options)
);
}
});
};
Effect.Shrink = function(element) {
element = $(element);
var options = Object.extend({
direction: 'center',
moveTransition: Effect.Transitions.sinoidal,
scaleTransition: Effect.Transitions.sinoidal,
opacityTransition: Effect.Transitions.none
}, arguments[1] || { });
var oldStyle = {
top: element.style.top,
left: element.style.left,
height: element.style.height,
width: element.style.width,
opacity: element.getInlineOpacity() };
var dims = element.getDimensions();
var moveX, moveY;
switch (options.direction) {
case 'top-left':
moveX = moveY = 0;
break;
case 'top-right':
moveX = dims.width;
moveY = 0;
break;
case 'bottom-left':
moveX = 0;
moveY = dims.height;
break;
case 'bottom-right':
moveX = dims.width;
moveY = dims.height;
break;
case 'center':
moveX = dims.width / 2;
moveY = dims.height / 2;
break;
}
return new Effect.Parallel(
[ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
], Object.extend({
beforeStartInternal: function(effect) {
effect.effects[0].element.makePositioned().makeClipping();
},
afterFinishInternal: function(effect) {
effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
}, options)
);
};
Effect.Pulsate = function(element) {
element = $(element);
var options = arguments[1] || { },
oldOpacity = element.getInlineOpacity(),
transition = options.transition || Effect.Transitions.linear,
reverser = function(pos){
return 1 - transition((-Math.cos((pos*(options.pulses||5)*2)*Math.PI)/2) + .5);
};
return new Effect.Opacity(element,
Object.extend(Object.extend({ duration: 2.0, from: 0,
afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
}, options), {transition: reverser}));
};
Effect.Fold = function(element) {
element = $(element);
var oldStyle = {
top: element.style.top,
left: element.style.left,
width: element.style.width,
height: element.style.height };
element.makeClipping();
return new Effect.Scale(element, 5, Object.extend({
scaleContent: false,
scaleX: false,
afterFinishInternal: function(effect) {
new Effect.Scale(element, 1, {
scaleContent: false,
scaleY: false,
afterFinishInternal: function(effect) {
effect.element.hide().undoClipping().setStyle(oldStyle);
} });
}}, arguments[1] || { }));
};
Effect.Morph = Class.create(Effect.Base, {
initialize: function(element) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({
style: { }
}, arguments[1] || { });
if (!Object.isString(options.style)) this.style = $H(options.style);
else {
if (options.style.include(':'))
this.style = options.style.parseStyle();
else {
this.element.addClassName(options.style);
this.style = $H(this.element.getStyles());
this.element.removeClassName(options.style);
var css = this.element.getStyles();
this.style = this.style.reject(function(style) {
return style.value == css[style.key];
});
options.afterFinishInternal = function(effect) {
effect.element.addClassName(effect.options.style);
effect.transforms.each(function(transform) {
effect.element.style[transform.style] = '';
});
};
}
}
this.start(options);
},
setup: function(){
function parseColor(color){
if (!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
color = color.parseColor();
return $R(0,2).map(function(i){
return parseInt( color.slice(i*2+1,i*2+3), 16 );
});
}
this.transforms = this.style.map(function(pair){
var property = pair[0], value = pair[1], unit = null;
if (value.parseColor('#zzzzzz') != '#zzzzzz') {
value = value.parseColor();
unit = 'color';
} else if (property == 'opacity') {
value = parseFloat(value);
if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
this.element.setStyle({zoom: 1});
} else if (Element.CSS_LENGTH.test(value)) {
var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
value = parseFloat(components[1]);
unit = (components.length == 3) ? components[2] : null;
}
var originalValue = this.element.getStyle(property);
return {
style: property.camelize(),
originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0),
targetValue: unit=='color' ? parseColor(value) : value,
unit: unit
};
}.bind(this)).reject(function(transform){
return (
(transform.originalValue == transform.targetValue) ||
(
transform.unit != 'color' &&
(isNaN(transform.originalValue) || isNaN(transform.targetValue))
)
);
});
},
update: function(position) {
var style = { }, transform, i = this.transforms.length;
while(i--)
style[(transform = this.transforms[i]).style] =
transform.unit=='color' ? '#'+
(Math.round(transform.originalValue[0]+
(transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
(Math.round(transform.originalValue[1]+
(transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
(Math.round(transform.originalValue[2]+
(transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
(transform.originalValue +
(transform.targetValue - transform.originalValue) * position).toFixed(3) +
(transform.unit === null ? '' : transform.unit);
this.element.setStyle(style, true);
}
});
Effect.Transform = Class.create({
initialize: function(tracks){
this.tracks = [];
this.options = arguments[1] || { };
this.addTracks(tracks);
},
addTracks: function(tracks){
tracks.each(function(track){
track = $H(track);
var data = track.values().first();
this.tracks.push($H({
ids: track.keys().first(),
effect: Effect.Morph,
options: { style: data }
}));
}.bind(this));
return this;
},
play: function(){
return new Effect.Parallel(
this.tracks.map(function(track){
var ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
var elements = [$(ids) || $$(ids)].flatten();
return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, options)) });
}).flatten(),
this.options
);
}
});
Element.CSS_PROPERTIES = $w(
'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' +
'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
'fontSize fontWeight height left letterSpacing lineHeight ' +
'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
'right textIndent top width wordSpacing zIndex');
Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;
String.__parseStyleElement = document.createElement('div');
String.prototype.parseStyle = function(){
var style, styleRules = $H();
if (Prototype.Browser.WebKit)
style = new Element('div',{style:this}).style;
else {
String.__parseStyleElement.innerHTML = '';
style = String.__parseStyleElement.childNodes[0].style;
}
Element.CSS_PROPERTIES.each(function(property){
if (style[property]) styleRules.set(property, style[property]);
});
if (Prototype.Browser.IE && this.include('opacity'))
styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);
return styleRules;
};
if (document.defaultView && document.defaultView.getComputedStyle) {
Element.getStyles = function(element) {
var css = document.defaultView.getComputedStyle($(element), null);
return Element.CSS_PROPERTIES.inject({ }, function(styles, property) {
styles[property] = css[property];
return styles;
});
};
} else {
Element.getStyles = function(element) {
element = $(element);
var css = element.currentStyle, styles;
styles = Element.CSS_PROPERTIES.inject({ }, function(results, property) {
results[property] = css[property];
return results;
});
if (!styles.opacity) styles.opacity = element.getOpacity();
return styles;
};
}
Effect.Methods = {
morph: function(element, style) {
element = $(element);
new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || { }));
return element;
},
visualEffect: function(element, effect, options) {
element = $(element);
var s = effect.dasherize().camelize(), klass = s.charAt(0).toUpperCase() + s.substring(1);
new Effect[klass](element, options);
return element;
},
highlight: function(element, options) {
element = $(element);
new Effect.Highlight(element, options);
return element;
}
};
$w('fade appear grow shrink fold blindUp blindDown slideUp slideDown '+
'pulsate shake puff squish switchOff dropOut').each(
function(effect) {
Effect.Methods[effect] = function(element, options){
element = $(element);
Effect[effect.charAt(0).toUpperCase() + effect.substring(1)](element, options);
return element;
};
}
);
$w('getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles').each(
function(f) { Effect.Methods[f] = Element[f]; }
);
Element.addMethods(Effect.Methods);// script.aculo.us controls.js v1.8.3, Thu Oct 08 11:23:33 +0200 2009
// Copyright (c) 2005-2009 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005-2009 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
// (c) 2005-2009 Jon Tirsen (http://www.tirsen.com)
// Contributors:
// Richard Livsey
// Rahul Bhargava
// Rob Wills
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/
// Autocompleter.Base handles all the autocompletion functionality
// that's independent of the data source for autocompletion. This
// includes drawing the autocompletion menu, observing keyboard
// and mouse events, and similar.
//
// Specific autocompleters need to provide, at the very least,
// a getUpdatedChoices function that will be invoked every time
// the text inside the monitored textbox changes. This method
// should get the text for which to provide autocompletion by
// invoking this.getToken(), NOT by directly accessing
// this.element.value. This is to allow incremental tokenized
// autocompletion. Specific auto-completion logic (AJAX, etc)
// belongs in getUpdatedChoices.
//
// Tokenized incremental autocompletion is enabled automatically
// when an autocompleter is instantiated with the 'tokens' option
// in the options parameter, e.g.:
// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
// will incrementally autocomplete with a comma as the token.
// Additionally, ',' in the above example can be replaced with
// a token array, e.g. { tokens: [',', '\n'] } which
// enables autocompletion on multiple tokens. This is most
// useful when one of the tokens is \n (a newline), as it
// allows smart autocompletion after linebreaks.
if(typeof Effect == 'undefined')
throw("controls.js requires including script.aculo.us' effects.js library");
var Autocompleter = { };
Autocompleter.Base = Class.create({
baseInitialize: function(element, update, options) {
element = $(element);
this.element = element;
this.update = $(update);
this.hasFocus = false;
this.changed = false;
this.active = false;
this.index = 0;
this.entryCount = 0;
this.oldElementValue = this.element.value;
if(this.setOptions)
this.setOptions(options);
else
this.options = options || { };
this.options.paramName = this.options.paramName || this.element.name;
this.options.tokens = this.options.tokens || [];
this.options.frequency = this.options.frequency || 0.4;
this.options.minChars = this.options.minChars || 1;
this.options.onShow = this.options.onShow ||
function(element, update){
if(!update.style.position || update.style.position=='absolute') {
update.style.position = 'absolute';
Position.clone(element, update, {
setHeight: false,
offsetTop: element.offsetHeight
});
}
Effect.Appear(update,{duration:0.15});
};
this.options.onHide = this.options.onHide ||
function(element, update){ new Effect.Fade(update,{duration:0.15}) };
if(typeof(this.options.tokens) == 'string')
this.options.tokens = new Array(this.options.tokens);
// Force carriage returns as token delimiters anyway
if (!this.options.tokens.include('\n'))
this.options.tokens.push('\n');
this.observer = null;
this.element.setAttribute('autocomplete','off');
Element.hide(this.update);
Event.observe(this.element, 'blur', this.onBlur.bindAsEventListener(this));
Event.observe(this.element, 'keydown', this.onKeyPress.bindAsEventListener(this));
},
show: function() {
if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
if(!this.iefix &&
(Prototype.Browser.IE) &&
(Element.getStyle(this.update, 'position')=='absolute')) {
new Insertion.After(this.update,
'');
this.iefix = $(this.update.id+'_iefix');
}
if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
},
fixIEOverlapping: function() {
Position.clone(this.update, this.iefix, {setTop:(!this.update.style.height)});
this.iefix.style.zIndex = 1;
this.update.style.zIndex = 2;
Element.show(this.iefix);
},
hide: function() {
this.stopIndicator();
if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
if(this.iefix) Element.hide(this.iefix);
},
startIndicator: function() {
if(this.options.indicator) Element.show(this.options.indicator);
},
stopIndicator: function() {
if(this.options.indicator) Element.hide(this.options.indicator);
},
onKeyPress: function(event) {
if(this.active)
switch(event.keyCode) {
case Event.KEY_TAB:
case Event.KEY_RETURN:
this.selectEntry();
Event.stop(event);
case Event.KEY_ESC:
this.hide();
this.active = false;
Event.stop(event);
return;
case Event.KEY_LEFT:
case Event.KEY_RIGHT:
return;
case Event.KEY_UP:
this.markPrevious();
this.render();
Event.stop(event);
return;
case Event.KEY_DOWN:
this.markNext();
this.render();
Event.stop(event);
return;
}
else
if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN ||
(Prototype.Browser.WebKit > 0 && event.keyCode == 0)) return;
this.changed = true;
this.hasFocus = true;
if(this.observer) clearTimeout(this.observer);
this.observer =
setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
},
activate: function() {
this.changed = false;
this.hasFocus = true;
this.getUpdatedChoices();
},
onHover: function(event) {
var element = Event.findElement(event, 'LI');
if(this.index != element.autocompleteIndex)
{
this.index = element.autocompleteIndex;
this.render();
}
Event.stop(event);
},
onClick: function(event) {
var element = Event.findElement(event, 'LI');
this.index = element.autocompleteIndex;
this.selectEntry();
this.hide();
},
onBlur: function(event) {
// needed to make click events working
setTimeout(this.hide.bind(this), 250);
this.hasFocus = false;
this.active = false;
},
render: function() {
if(this.entryCount > 0) {
for (var i = 0; i < this.entryCount; i++)
this.index==i ?
Element.addClassName(this.getEntry(i),"selected") :
Element.removeClassName(this.getEntry(i),"selected");
if(this.hasFocus) {
this.show();
this.active = true;
}
} else {
this.active = false;
this.hide();
}
},
markPrevious: function() {
if(this.index > 0) this.index--;
else this.index = this.entryCount-1;
this.getEntry(this.index).scrollIntoView(true);
},
markNext: function() {
if(this.index < this.entryCount-1) this.index++;
else this.index = 0;
this.getEntry(this.index).scrollIntoView(false);
},
getEntry: function(index) {
return this.update.firstChild.childNodes[index];
},
getCurrentEntry: function() {
return this.getEntry(this.index);
},
selectEntry: function() {
this.active = false;
this.updateElement(this.getCurrentEntry());
},
updateElement: function(selectedElement) {
if (this.options.updateElement) {
this.options.updateElement(selectedElement);
return;
}
var value = '';
if (this.options.select) {
var nodes = $(selectedElement).select('.' + this.options.select) || [];
if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
} else
value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
var bounds = this.getTokenBounds();
if (bounds[0] != -1) {
var newValue = this.element.value.substr(0, bounds[0]);
var whitespace = this.element.value.substr(bounds[0]).match(/^\s+/);
if (whitespace)
newValue += whitespace[0];
this.element.value = newValue + value + this.element.value.substr(bounds[1]);
} else {
this.element.value = value;
}
this.oldElementValue = this.element.value;
this.element.focus();
if (this.options.afterUpdateElement)
this.options.afterUpdateElement(this.element, selectedElement);
},
updateChoices: function(choices) {
if(!this.changed && this.hasFocus) {
this.update.innerHTML = choices;
Element.cleanWhitespace(this.update);
Element.cleanWhitespace(this.update.down());
if(this.update.firstChild && this.update.down().childNodes) {
this.entryCount =
this.update.down().childNodes.length;
for (var i = 0; i < this.entryCount; i++) {
var entry = this.getEntry(i);
entry.autocompleteIndex = i;
this.addObservers(entry);
}
} else {
this.entryCount = 0;
}
this.stopIndicator();
this.index = 0;
if(this.entryCount==1 && this.options.autoSelect) {
this.selectEntry();
this.hide();
} else {
this.render();
}
}
},
addObservers: function(element) {
Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
Event.observe(element, "click", this.onClick.bindAsEventListener(this));
},
onObserverEvent: function() {
this.changed = false;
this.tokenBounds = null;
if(this.getToken().length>=this.options.minChars) {
this.getUpdatedChoices();
} else {
this.active = false;
this.hide();
}
this.oldElementValue = this.element.value;
},
getToken: function() {
var bounds = this.getTokenBounds();
return this.element.value.substring(bounds[0], bounds[1]).strip();
},
getTokenBounds: function() {
if (null != this.tokenBounds) return this.tokenBounds;
var value = this.element.value;
if (value.strip().empty()) return [-1, 0];
var diff = arguments.callee.getFirstDifferencePos(value, this.oldElementValue);
var offset = (diff == this.oldElementValue.length ? 1 : 0);
var prevTokenPos = -1, nextTokenPos = value.length;
var tp;
for (var index = 0, l = this.options.tokens.length; index < l; ++index) {
tp = value.lastIndexOf(this.options.tokens[index], diff + offset - 1);
if (tp > prevTokenPos) prevTokenPos = tp;
tp = value.indexOf(this.options.tokens[index], diff + offset);
if (-1 != tp && tp < nextTokenPos) nextTokenPos = tp;
}
return (this.tokenBounds = [prevTokenPos + 1, nextTokenPos]);
}
});
Autocompleter.Base.prototype.getTokenBounds.getFirstDifferencePos = function(newS, oldS) {
var boundary = Math.min(newS.length, oldS.length);
for (var index = 0; index < boundary; ++index)
if (newS[index] != oldS[index])
return index;
return boundary;
};
Ajax.Autocompleter = Class.create(Autocompleter.Base, {
initialize: function(element, update, url, options) {
this.baseInitialize(element, update, options);
this.options.asynchronous = true;
this.options.onComplete = this.onComplete.bind(this);
this.options.defaultParams = this.options.parameters || null;
this.url = url;
},
getUpdatedChoices: function() {
this.startIndicator();
var entry = encodeURIComponent(this.options.paramName) + '=' +
encodeURIComponent(this.getToken());
this.options.parameters = this.options.callback ?
this.options.callback(this.element, entry) : entry;
if(this.options.defaultParams)
this.options.parameters += '&' + this.options.defaultParams;
new Ajax.Request(this.url, this.options);
},
onComplete: function(request) {
this.updateChoices(request.responseText);
}
});
// The local array autocompleter. Used when you'd prefer to
// inject an array of autocompletion options into the page, rather
// than sending out Ajax queries, which can be quite slow sometimes.
//
// The constructor takes four parameters. The first two are, as usual,
// the id of the monitored textbox, and id of the autocompletion menu.
// The third is the array you want to autocomplete from, and the fourth
// is the options block.
//
// Extra local autocompletion options:
// - choices - How many autocompletion choices to offer
//
// - partialSearch - If false, the autocompleter will match entered
// text only at the beginning of strings in the
// autocomplete array. Defaults to true, which will
// match text at the beginning of any *word* in the
// strings in the autocomplete array. If you want to
// search anywhere in the string, additionally set
// the option fullSearch to true (default: off).
//
// - fullSsearch - Search anywhere in autocomplete array strings.
//
// - partialChars - How many characters to enter before triggering
// a partial match (unlike minChars, which defines
// how many characters are required to do any match
// at all). Defaults to 2.
//
// - ignoreCase - Whether to ignore case when autocompleting.
// Defaults to true.
//
// It's possible to pass in a custom function as the 'selector'
// option, if you prefer to write your own autocompletion logic.
// In that case, the other options above will not apply unless
// you support them.
Autocompleter.Local = Class.create(Autocompleter.Base, {
initialize: function(element, update, array, options) {
this.baseInitialize(element, update, options);
this.options.array = array;
},
getUpdatedChoices: function() {
this.updateChoices(this.options.selector(this));
},
setOptions: function(options) {
this.options = Object.extend({
choices: 10,
partialSearch: true,
partialChars: 2,
ignoreCase: true,
fullSearch: false,
selector: function(instance) {
var ret = []; // Beginning matches
var partial = []; // Inside matches
var entry = instance.getToken();
var count = 0;
for (var i = 0; i < instance.options.array.length &&
ret.length < instance.options.choices ; i++) {
var elem = instance.options.array[i];
var foundPos = instance.options.ignoreCase ?
elem.toLowerCase().indexOf(entry.toLowerCase()) :
elem.indexOf(entry);
while (foundPos != -1) {
if (foundPos == 0 && elem.length != entry.length) {
ret.push("" + elem.substr(0, entry.length) + "" +
elem.substr(entry.length) + "");
break;
} else if (entry.length >= instance.options.partialChars &&
instance.options.partialSearch && foundPos != -1) {
if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos-1,1))) {
partial.push("" + elem.substr(0, foundPos) + "" +
elem.substr(foundPos, entry.length) + "" + elem.substr(
foundPos + entry.length) + "");
break;
}
}
foundPos = instance.options.ignoreCase ?
elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) :
elem.indexOf(entry, foundPos + 1);
}
}
if (partial.length)
ret = ret.concat(partial.slice(0, instance.options.choices - ret.length));
return "";
}
}, options || { });
}
});
// AJAX in-place editor and collection editor
// Full rewrite by Christophe Porteneuve (April 2007).
// Use this if you notice weird scrolling problems on some browsers,
// the DOM might be a bit confused when this gets called so do this
// waits 1 ms (with setTimeout) until it does the activation
Field.scrollFreeActivate = function(field) {
setTimeout(function() {
Field.activate(field);
}, 1);
};
Ajax.InPlaceEditor = Class.create({
initialize: function(element, url, options) {
this.url = url;
this.element = element = $(element);
this.prepareOptions();
this._controls = { };
arguments.callee.dealWithDeprecatedOptions(options); // DEPRECATION LAYER!!!
Object.extend(this.options, options || { });
if (!this.options.formId && this.element.id) {
this.options.formId = this.element.id + '-inplaceeditor';
if ($(this.options.formId))
this.options.formId = '';
}
if (this.options.externalControl)
this.options.externalControl = $(this.options.externalControl);
if (!this.options.externalControl)
this.options.externalControlOnly = false;
this._originalBackground = this.element.getStyle('background-color') || 'transparent';
this.element.title = this.options.clickToEditText;
this._boundCancelHandler = this.handleFormCancellation.bind(this);
this._boundComplete = (this.options.onComplete || Prototype.emptyFunction).bind(this);
this._boundFailureHandler = this.handleAJAXFailure.bind(this);
this._boundSubmitHandler = this.handleFormSubmission.bind(this);
this._boundWrapperHandler = this.wrapUp.bind(this);
this.registerListeners();
},
checkForEscapeOrReturn: function(e) {
if (!this._editing || e.ctrlKey || e.altKey || e.shiftKey) return;
if (Event.KEY_ESC == e.keyCode)
this.handleFormCancellation(e);
else if (Event.KEY_RETURN == e.keyCode)
this.handleFormSubmission(e);
},
createControl: function(mode, handler, extraClasses) {
var control = this.options[mode + 'Control'];
var text = this.options[mode + 'Text'];
if ('button' == control) {
var btn = document.createElement('input');
btn.type = 'submit';
btn.value = text;
btn.className = 'editor_' + mode + '_button';
if ('cancel' == mode)
btn.onclick = this._boundCancelHandler;
this._form.appendChild(btn);
this._controls[mode] = btn;
} else if ('link' == control) {
var link = document.createElement('a');
link.href = '#';
link.appendChild(document.createTextNode(text));
link.onclick = 'cancel' == mode ? this._boundCancelHandler : this._boundSubmitHandler;
link.className = 'editor_' + mode + '_link';
if (extraClasses)
link.className += ' ' + extraClasses;
this._form.appendChild(link);
this._controls[mode] = link;
}
},
createEditField: function() {
var text = (this.options.loadTextURL ? this.options.loadingText : this.getText());
var fld;
if (1 >= this.options.rows && !/\r|\n/.test(this.getText())) {
fld = document.createElement('input');
fld.type = 'text';
var size = this.options.size || this.options.cols || 0;
if (0 < size) fld.size = size;
} else {
fld = document.createElement('textarea');
fld.rows = (1 >= this.options.rows ? this.options.autoRows : this.options.rows);
fld.cols = this.options.cols || 40;
}
fld.name = this.options.paramName;
fld.value = text; // No HTML breaks conversion anymore
fld.className = 'editor_field';
if (this.options.submitOnBlur)
fld.onblur = this._boundSubmitHandler;
this._controls.editor = fld;
if (this.options.loadTextURL)
this.loadExternalText();
this._form.appendChild(this._controls.editor);
},
createForm: function() {
var ipe = this;
function addText(mode, condition) {
var text = ipe.options['text' + mode + 'Controls'];
if (!text || condition === false) return;
ipe._form.appendChild(document.createTextNode(text));
};
this._form = $(document.createElement('form'));
this._form.id = this.options.formId;
this._form.addClassName(this.options.formClassName);
this._form.onsubmit = this._boundSubmitHandler;
this.createEditField();
if ('textarea' == this._controls.editor.tagName.toLowerCase())
this._form.appendChild(document.createElement('br'));
if (this.options.onFormCustomization)
this.options.onFormCustomization(this, this._form);
addText('Before', this.options.okControl || this.options.cancelControl);
this.createControl('ok', this._boundSubmitHandler);
addText('Between', this.options.okControl && this.options.cancelControl);
this.createControl('cancel', this._boundCancelHandler, 'editor_cancel');
addText('After', this.options.okControl || this.options.cancelControl);
},
destroy: function() {
if (this._oldInnerHTML)
this.element.innerHTML = this._oldInnerHTML;
this.leaveEditMode();
this.unregisterListeners();
},
enterEditMode: function(e) {
if (this._saving || this._editing) return;
this._editing = true;
this.triggerCallback('onEnterEditMode');
if (this.options.externalControl)
this.options.externalControl.hide();
this.element.hide();
this.createForm();
this.element.parentNode.insertBefore(this._form, this.element);
if (!this.options.loadTextURL)
this.postProcessEditField();
if (e) Event.stop(e);
},
enterHover: function(e) {
if (this.options.hoverClassName)
this.element.addClassName(this.options.hoverClassName);
if (this._saving) return;
this.triggerCallback('onEnterHover');
},
getText: function() {
return this.element.innerHTML.unescapeHTML();
},
handleAJAXFailure: function(transport) {
this.triggerCallback('onFailure', transport);
if (this._oldInnerHTML) {
this.element.innerHTML = this._oldInnerHTML;
this._oldInnerHTML = null;
}
},
handleFormCancellation: function(e) {
this.wrapUp();
if (e) Event.stop(e);
},
handleFormSubmission: function(e) {
var form = this._form;
var value = $F(this._controls.editor);
this.prepareSubmission();
var params = this.options.callback(form, value) || '';
if (Object.isString(params))
params = params.toQueryParams();
params.editorId = this.element.id;
if (this.options.htmlResponse) {
var options = Object.extend({ evalScripts: true }, this.options.ajaxOptions);
Object.extend(options, {
parameters: params,
onComplete: this._boundWrapperHandler,
onFailure: this._boundFailureHandler
});
new Ajax.Updater({ success: this.element }, this.url, options);
} else {
var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
Object.extend(options, {
parameters: params,
onComplete: this._boundWrapperHandler,
onFailure: this._boundFailureHandler
});
new Ajax.Request(this.url, options);
}
if (e) Event.stop(e);
},
leaveEditMode: function() {
this.element.removeClassName(this.options.savingClassName);
this.removeForm();
this.leaveHover();
this.element.style.backgroundColor = this._originalBackground;
this.element.show();
if (this.options.externalControl)
this.options.externalControl.show();
this._saving = false;
this._editing = false;
this._oldInnerHTML = null;
this.triggerCallback('onLeaveEditMode');
},
leaveHover: function(e) {
if (this.options.hoverClassName)
this.element.removeClassName(this.options.hoverClassName);
if (this._saving) return;
this.triggerCallback('onLeaveHover');
},
loadExternalText: function() {
this._form.addClassName(this.options.loadingClassName);
this._controls.editor.disabled = true;
var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
Object.extend(options, {
parameters: 'editorId=' + encodeURIComponent(this.element.id),
onComplete: Prototype.emptyFunction,
onSuccess: function(transport) {
this._form.removeClassName(this.options.loadingClassName);
var text = transport.responseText;
if (this.options.stripLoadedTextTags)
text = text.stripTags();
this._controls.editor.value = text;
this._controls.editor.disabled = false;
this.postProcessEditField();
}.bind(this),
onFailure: this._boundFailureHandler
});
new Ajax.Request(this.options.loadTextURL, options);
},
postProcessEditField: function() {
var fpc = this.options.fieldPostCreation;
if (fpc)
$(this._controls.editor)['focus' == fpc ? 'focus' : 'activate']();
},
prepareOptions: function() {
this.options = Object.clone(Ajax.InPlaceEditor.DefaultOptions);
Object.extend(this.options, Ajax.InPlaceEditor.DefaultCallbacks);
[this._extraDefaultOptions].flatten().compact().each(function(defs) {
Object.extend(this.options, defs);
}.bind(this));
},
prepareSubmission: function() {
this._saving = true;
this.removeForm();
this.leaveHover();
this.showSaving();
},
registerListeners: function() {
this._listeners = { };
var listener;
$H(Ajax.InPlaceEditor.Listeners).each(function(pair) {
listener = this[pair.value].bind(this);
this._listeners[pair.key] = listener;
if (!this.options.externalControlOnly)
this.element.observe(pair.key, listener);
if (this.options.externalControl)
this.options.externalControl.observe(pair.key, listener);
}.bind(this));
},
removeForm: function() {
if (!this._form) return;
this._form.remove();
this._form = null;
this._controls = { };
},
showSaving: function() {
this._oldInnerHTML = this.element.innerHTML;
this.element.innerHTML = this.options.savingText;
this.element.addClassName(this.options.savingClassName);
this.element.style.backgroundColor = this._originalBackground;
this.element.show();
},
triggerCallback: function(cbName, arg) {
if ('function' == typeof this.options[cbName]) {
this.options[cbName](this, arg);
}
},
unregisterListeners: function() {
$H(this._listeners).each(function(pair) {
if (!this.options.externalControlOnly)
this.element.stopObserving(pair.key, pair.value);
if (this.options.externalControl)
this.options.externalControl.stopObserving(pair.key, pair.value);
}.bind(this));
},
wrapUp: function(transport) {
this.leaveEditMode();
// Can't use triggerCallback due to backward compatibility: requires
// binding + direct element
this._boundComplete(transport, this.element);
}
});
Object.extend(Ajax.InPlaceEditor.prototype, {
dispose: Ajax.InPlaceEditor.prototype.destroy
});
Ajax.InPlaceCollectionEditor = Class.create(Ajax.InPlaceEditor, {
initialize: function($super, element, url, options) {
this._extraDefaultOptions = Ajax.InPlaceCollectionEditor.DefaultOptions;
$super(element, url, options);
},
createEditField: function() {
var list = document.createElement('select');
list.name = this.options.paramName;
list.size = 1;
this._controls.editor = list;
this._collection = this.options.collection || [];
if (this.options.loadCollectionURL)
this.loadCollection();
else
this.checkForExternalText();
this._form.appendChild(this._controls.editor);
},
loadCollection: function() {
this._form.addClassName(this.options.loadingClassName);
this.showLoadingText(this.options.loadingCollectionText);
var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
Object.extend(options, {
parameters: 'editorId=' + encodeURIComponent(this.element.id),
onComplete: Prototype.emptyFunction,
onSuccess: function(transport) {
var js = transport.responseText.strip();
if (!/^\[.*\]$/.test(js)) // TODO: improve sanity check
throw('Server returned an invalid collection representation.');
this._collection = eval(js);
this.checkForExternalText();
}.bind(this),
onFailure: this.onFailure
});
new Ajax.Request(this.options.loadCollectionURL, options);
},
showLoadingText: function(text) {
this._controls.editor.disabled = true;
var tempOption = this._controls.editor.firstChild;
if (!tempOption) {
tempOption = document.createElement('option');
tempOption.value = '';
this._controls.editor.appendChild(tempOption);
tempOption.selected = true;
}
tempOption.update((text || '').stripScripts().stripTags());
},
checkForExternalText: function() {
this._text = this.getText();
if (this.options.loadTextURL)
this.loadExternalText();
else
this.buildOptionList();
},
loadExternalText: function() {
this.showLoadingText(this.options.loadingText);
var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
Object.extend(options, {
parameters: 'editorId=' + encodeURIComponent(this.element.id),
onComplete: Prototype.emptyFunction,
onSuccess: function(transport) {
this._text = transport.responseText.strip();
this.buildOptionList();
}.bind(this),
onFailure: this.onFailure
});
new Ajax.Request(this.options.loadTextURL, options);
},
buildOptionList: function() {
this._form.removeClassName(this.options.loadingClassName);
this._collection = this._collection.map(function(entry) {
return 2 === entry.length ? entry : [entry, entry].flatten();
});
var marker = ('value' in this.options) ? this.options.value : this._text;
var textFound = this._collection.any(function(entry) {
return entry[0] == marker;
}.bind(this));
this._controls.editor.update('');
var option;
this._collection.each(function(entry, index) {
option = document.createElement('option');
option.value = entry[0];
option.selected = textFound ? entry[0] == marker : 0 == index;
option.appendChild(document.createTextNode(entry[1]));
this._controls.editor.appendChild(option);
}.bind(this));
this._controls.editor.disabled = false;
Field.scrollFreeActivate(this._controls.editor);
}
});
//**** DEPRECATION LAYER FOR InPlace[Collection]Editor! ****
//**** This only exists for a while, in order to let ****
//**** users adapt to the new API. Read up on the new ****
//**** API and convert your code to it ASAP! ****
Ajax.InPlaceEditor.prototype.initialize.dealWithDeprecatedOptions = function(options) {
if (!options) return;
function fallback(name, expr) {
if (name in options || expr === undefined) return;
options[name] = expr;
};
fallback('cancelControl', (options.cancelLink ? 'link' : (options.cancelButton ? 'button' :
options.cancelLink == options.cancelButton == false ? false : undefined)));
fallback('okControl', (options.okLink ? 'link' : (options.okButton ? 'button' :
options.okLink == options.okButton == false ? false : undefined)));
fallback('highlightColor', options.highlightcolor);
fallback('highlightEndColor', options.highlightendcolor);
};
Object.extend(Ajax.InPlaceEditor, {
DefaultOptions: {
ajaxOptions: { },
autoRows: 3, // Use when multi-line w/ rows == 1
cancelControl: 'link', // 'link'|'button'|false
cancelText: 'cancel',
clickToEditText: 'Click to edit',
externalControl: null, // id|elt
externalControlOnly: false,
fieldPostCreation: 'activate', // 'activate'|'focus'|false
formClassName: 'inplaceeditor-form',
formId: null, // id|elt
highlightColor: '#ffff99',
highlightEndColor: '#ffffff',
hoverClassName: '',
htmlResponse: true,
loadingClassName: 'inplaceeditor-loading',
loadingText: 'Loading...',
okControl: 'button', // 'link'|'button'|false
okText: 'ok',
paramName: 'value',
rows: 1, // If 1 and multi-line, uses autoRows
savingClassName: 'inplaceeditor-saving',
savingText: 'Saving...',
size: 0,
stripLoadedTextTags: false,
submitOnBlur: false,
textAfterControls: '',
textBeforeControls: '',
textBetweenControls: ''
},
DefaultCallbacks: {
callback: function(form) {
return Form.serialize(form);
},
onComplete: function(transport, element) {
// For backward compatibility, this one is bound to the IPE, and passes
// the element directly. It was too often customized, so we don't break it.
new Effect.Highlight(element, {
startcolor: this.options.highlightColor, keepBackgroundImage: true });
},
onEnterEditMode: null,
onEnterHover: function(ipe) {
ipe.element.style.backgroundColor = ipe.options.highlightColor;
if (ipe._effect)
ipe._effect.cancel();
},
onFailure: function(transport, ipe) {
alert('Error communication with the server: ' + transport.responseText.stripTags());
},
onFormCustomization: null, // Takes the IPE and its generated form, after editor, before controls.
onLeaveEditMode: null,
onLeaveHover: function(ipe) {
ipe._effect = new Effect.Highlight(ipe.element, {
startcolor: ipe.options.highlightColor, endcolor: ipe.options.highlightEndColor,
restorecolor: ipe._originalBackground, keepBackgroundImage: true
});
}
},
Listeners: {
click: 'enterEditMode',
keydown: 'checkForEscapeOrReturn',
mouseover: 'enterHover',
mouseout: 'leaveHover'
}
});
Ajax.InPlaceCollectionEditor.DefaultOptions = {
loadingCollectionText: 'Loading options...'
};
// Delayed observer, like Form.Element.Observer,
// but waits for delay after last key input
// Ideal for live-search fields
Form.Element.DelayedObserver = Class.create({
initialize: function(element, delay, callback) {
this.delay = delay || 0.5;
this.element = $(element);
this.callback = callback;
this.timer = null;
this.lastValue = $F(this.element);
Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
},
delayedListener: function(event) {
if(this.lastValue == $F(this.element)) return;
if(this.timer) clearTimeout(this.timer);
this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
this.lastValue = $F(this.element);
},
onTimerEvent: function() {
this.timer = null;
this.callback(this.element, $F(this.element));
}
}); /**
* DatePicker widget using Prototype and Scriptaculous.
* (c) 2007 Mathieu Jondet
* Eulerian Technologies
*
* DatePicker is freely distributable under the same terms as Prototype.
*
*/
/**
* DatePickerFormatter class for matching and stringifying dates.
*
* By Arturas Slajus .
*/
var DatePickerFormatter = Class.create();
DatePickerFormatter.prototype = {
/**
* Create a DatePickerFormatter.
*
* format: specify a format by passing 3 value array consisting of
* "yyyy", "mm", "dd". Default: ["yyyy", "mm", "dd"].
*
* separator: string for splitting the values. Default: "-".
*
* Use it like this:
* var df = new DatePickerFormatter(["dd", "mm", "yyyy"], "/");
* df.current_date();
* df.match("7/7/2007");
*/
initialize: function(format, separator) {
if (Object.isUndefined(format))
format = ["yyyy", "mm", "dd"];
if (Object.isUndefined(separator))
separator = "-";
this._format = format;
this.separator = separator;
this._format_year_index = format.indexOf("yyyy");
this._format_month_index= format.indexOf("mm");
this._format_day_index = format.indexOf("dd");
this._year_regexp = /^\d{4}$/;
this._month_regexp = /^0\d|1[012]|\d$/;
this._day_regexp = /^0\d|[12]\d|3[01]|\d$/;
},
/**
* Match a string against date format.
* Returns: [year, month, day]
*/
match: function(str) {
var d = str.split(this.separator);
if (d.length < 3)
return false;
var year = d[this._format_year_index].match(this._year_regexp);
if (year) { year = year[0] } else { return false }
var month = d[this._format_month_index].match(this._month_regexp);
if (month) { month = month[0] } else { return false }
var day = d[this._format_day_index].match(this._day_regexp);
if (day) { day = day[0] } else { return false }
return [year, month, day];
},
/**
* Return current date according to format.
*/
current_date: function() {
var d = new Date;
return this.date_to_string(
d.getFullYear(),
d.getMonth() + 1,
d.getDate()
);
},
/**
* Return a stringified date accordint to format.
*/
date_to_string: function(year, month, day, separator) {
if (Object.isUndefined(separator))
separator = this.separator;
var a = [0, 0, 0];
a[this._format_year_index] = year;
a[this._format_month_index] = month.toPaddedString(2);
a[this._format_day_index] = day.toPaddedString(2);
return a.join(separator);
}
};
/**
* DatePicker
*/
var DatePicker = Class.create();
DatePicker.prototype = {
Version : '0.9.4',
_relative : null,
_div : null,
_zindex : 3,
_keepFieldEmpty: true,
_daysInMonth : [31,28,31,30,31,30,31,31,30,31,30,31],
_dateFormat : [ ["dd", "mm", "yyyy"], "." ],
/* language */
_language : 'de"',
_language_month : $H({
'fr' : [ 'Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin',
'Juillet', 'Aout', 'Septembre', 'Octobre', 'Novembre', 'Décembre' ],
'en' : [ 'January', 'February', 'March', 'April', 'May',
'June', 'July', 'August', 'September', 'October', 'November', 'December' ],
'sp' : [ 'Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio',
'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre' ],
'it' : [ 'Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio', 'Giugno',
'Luglio', 'Agosto', 'Settembre', 'Ottobre', 'Novembre', 'Dicembre' ],
'de' : [ 'Januar', 'Februar', 'März', 'April', 'Mai', 'Juni',
'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember' ],
'pt' : [ 'Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho',
'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro' ],
'hu' : [ 'Január', 'Február', 'Március', 'Április',
'Május', 'Június', 'Július', 'Augusztus', 'Szeptember',
'Október', 'November', 'December' ],
'lt' : [ 'Sausis', 'Vasaris', 'Kovas', 'Balandis', 'Gegužė',
'Birželis', 'Liepa', 'Rugjūtis', 'Rusėjis', 'Spalis',
'Lapkritis', 'Gruodis' ],
'nl' : [ 'januari', 'februari', 'maart', 'april', 'mei', 'juni',
'juli', 'augustus', 'september', 'oktober', 'november', 'december' ],
'dk' : [ 'Januar', 'Februar', 'Marts', 'April', 'Maj',
'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'December' ],
'no' : [ 'Januar', 'Februar', 'Mars', 'April', 'Mai', 'Juni',
'Juli', 'August', 'September', 'Oktober', 'November', 'Desember' ],
'lv' : [ 'Janvāris', 'Februāris', 'Marts', 'Aprīlis', 'Maijs',
'Jūnijs', 'Jūlijs', 'Augusts', 'Septembris', 'Oktobris',
'Novembris', 'Decemberis' ],
'ja' : [ '1月', '2月', '3月', '4月', '5月',
'6月', '7月', '8月', '9月', '10月',
'11月', '12月' ],
'fi' : [ 'Tammikuu', 'Helmikuu', 'Maaliskuu', 'Huhtikuu', 'Toukokuu',
'Kesäkuu', 'Heinäkuu', 'Elokuu', 'Syyskuu', 'Lokakuu',
'Marraskuu', 'Joulukuu' ],
'ro' : [ 'Ianuarie', 'Februarie', 'Martie', 'Aprilie', 'Mai', 'Junie',
'Julie', 'August', 'Septembrie', 'Octombrie', 'Noiembrie', 'Decembrie' ],
'zh' : [ '1 月', '2 月', '3 月',
'4 月', '5 月', '6 月', '7 月',
'8 月', '9 月', '10月', '11月', '12月'],
'sv' : [ 'Januari', 'Februari', 'Mars', 'April', 'Maj', 'Juni',
'Juli', 'Augusti', 'September', 'Oktober', 'November', 'December' ]
}),
_language_day : $H({
'fr' : [ 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam', 'Dim' ],
'en' : [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ],
'sp' : [ 'Lun', 'Mar', 'Mie', 'Jue', 'Vie', 'Sàb', 'Dom' ],
'it' : [ 'Lun', 'Mar', 'Mer', 'Gio', 'Ven', 'Sab', 'Dom' ],
'de' : [ 'Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So' ],
'pt' : [ 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sá', 'Dom' ],
'hu' : [ 'Hé', 'Ke', 'Sze', 'Csü', 'Pé', 'Szo', 'Vas' ],
'lt' : [ 'Pir', 'Ant', 'Tre', 'Ket', 'Pen', 'Šeš', 'Sek' ],
'nl' : [ 'ma', 'di', 'wo', 'do', 'vr', 'za', 'zo' ],
'dk' : [ 'Man', 'Tir', 'Ons', 'Tor', 'Fre', 'Lør', 'Søn' ],
'no' : [ 'Man', 'Tir', 'Ons', 'Tor', 'Fre', 'Lør', 'Sun' ],
'lv' : [ 'P', 'O', 'T', 'C', 'Pk', 'S', 'Sv' ],
'ja' : [ '月', '火', '水', '木', '金',
'土', '日' ],
'fi' : [ 'Ma', 'Ti', 'Ke', 'To', 'Pe', 'La', 'Su' ],
'ro' : [ 'Lun', 'Mar', 'Mie', 'Joi', 'Vin', 'Sam', 'Dum' ],
'zh' : [ '周一', '周二', '周三',
'周四', '周五', '周六',
'周日' ],
'sv' : [ 'Mån', 'Tis', 'Ons', 'Tor', 'Fre', 'Lör',
'Sön' ]
}),
_language_close : $H({
'fr' : 'fermer',
'en' : 'close',
'sp' : 'cierre',
'it' : 'fine',
'de' : 'schliessen',
'pt' : 'fim',
'hu' : 'bezár',
'lt' : 'udaryti',
'nl' : 'sluiten',
'dk' : 'luk',
'no' : 'lukk',
'lv' : 'aizvērt',
'ja' : '閉じる',
'fi' : 'sulje',
'ro' : 'inchide',
'zh' : '关 闭',
'sv' : 'stäng'
}),
/* date manipulation */
_todayDate : new Date(),
_current_date : null,
_clickCallback : Prototype.emptyFunction,
_cellCallback : Prototype.emptyFunction,
_id_datepicker : null,
_disablePastDate : false,
_disableFutureDate : false,
_oneDayInMs : 24 * 3600 * 1000,
/* positionning */
_topOffset : 20,
_leftOffset : 0,
_isPositionned : false,
_relativePosition : true,
_setPositionTop : 0,
_setPositionLeft : 0,
_bodyAppend : false,
/* Effects Adjustment */
_showEffect : "appear",
_showDuration : 0.5,
_enableShowEffect : true,
_closeEffect : "fade",
_closeEffectDuration : 0.3,
_enableCloseEffect : true,
_closeTimer : null,
_enableCloseOnBlur : false,
/* afterClose : called when the close function is executed */
_afterClose : Prototype.emptyFunction,
/* return the name of current month in appropriate language */
getMonthLocale : function ( month ) {
return this._language_month.get(this._language)[month];
},
getLocaleClose : function () {
return this._language_close.get(this._language);
},
_initCurrentDate : function () {
/* Create the DateFormatter */
this._df = new DatePickerFormatter(this._dateFormat[0], this._dateFormat[1]);
/* check if value in field is proper, if not set to today */
this._current_date = $F(this._relative);
if (! this._df.match(this._current_date)) {
this._current_date = this._df.current_date();
/* set the field value ? */
if (!this._keepFieldEmpty)
$(this._relative).value = this._current_date;
}
var a_date = this._df.match(this._current_date);
this._current_year = Number(a_date[0]);
this._current_mon = Number(a_date[1]) - 1;
this._current_day = Number(a_date[2]);
},
/* init */
initialize : function ( h_p ) {
this._df = new DatePickerFormatter(this._dateFormat[0], this._dateFormat[1]);
/* arguments */
this._relative= h_p["relative"];
if (h_p["language"])
this._language = h_p["language"];
this._zindex = ( h_p["zindex"] ) ? parseInt(Number(h_p["zindex"])) : 1;
if (!Object.isUndefined(h_p["keepFieldEmpty"]))
this._keepFieldEmpty = h_p["keepFieldEmpty"];
if (Object.isFunction(h_p["clickCallback"]))
this._clickCallback = h_p["clickCallback"];
if (!Object.isUndefined(h_p["leftOffset"]))
this._leftOffset = parseInt(h_p["leftOffset"]);
if (!Object.isUndefined(h_p["topOffset"]))
this._topOffset = parseInt(h_p["topOffset"]);
if (!Object.isUndefined(h_p["relativePosition"]))
this._relativePosition = h_p["relativePosition"];
if (!Object.isUndefined(h_p["showEffect"]))
this._showEffect = h_p["showEffect"];
if (!Object.isUndefined(h_p["enableShowEffect"]))
this._enableShowEffect = h_p["enableShowEffect"];
if (!Object.isUndefined(h_p["showDuration"]))
this._showDuration = h_p["showDuration"];
if (!Object.isUndefined(h_p["closeEffect"]))
this._closeEffect = h_p["closeEffect"];
if (!Object.isUndefined(h_p["enableCloseEffect"]))
this._enableCloseEffect = h_p["enableCloseEffect"];
if (!Object.isUndefined(h_p["closeEffectDuration"]))
this._closeEffectDuration = h_p["closeEffectDuration"];
if (Object.isFunction(h_p["afterClose"]))
this._afterClose = h_p["afterClose"];
if (!Object.isUndefined(h_p["externalControl"]))
this._externalControl= h_p["externalControl"];
if (!Object.isUndefined(h_p["dateFormat"]))
this._dateFormat = h_p["dateFormat"];
if (Object.isFunction(h_p["cellCallback"]))
this._cellCallback = h_p["cellCallback"];
this._setPositionTop = ( h_p["setPositionTop"] ) ?
parseInt(Number(h_p["setPositionTop"])) : 0;
this._setPositionLeft = ( h_p["setPositionLeft"] ) ?
parseInt(Number(h_p["setPositionLeft"])) : 0;
if (!Object.isUndefined(h_p["enableCloseOnBlur"]) && h_p["enableCloseOnBlur"])
this._enableCloseOnBlur = true;
if (!Object.isUndefined(h_p["disablePastDate"]) && h_p["disablePastDate"])
this._disablePastDate = true;
if (!Object.isUndefined(h_p["disableFutureDate"]) &&
!h_p["disableFutureDate"])
this._disableFutureDate = false;
this._id_datepicker = 'datepicker-'+this._relative;
this._id_datepicker_prev = this._id_datepicker+'-prev';
this._id_datepicker_next = this._id_datepicker+'-next';
this._id_datepicker_hdr = this._id_datepicker+'-header';
this._id_datepicker_ftr = this._id_datepicker+'-footer';
this._id_datepicker_x = this._id_datepicker+'-x';
this._id_datepicker_today = this._id_datepicker+'-today';
/* build up calendar skel */
this._div = new Element('div', {
id : this._id_datepicker,
className : 'datepicker',
style : 'display: none; z-index:10'+this._zindex });
this._div.innerHTML = '| '+this._df.current_date()+' | X |
| < | | > |
|---|
';
/*this._div.innerHTML = '| '+this._df.current_date()+' | X |
| < | | > |
|---|
|
';
*/
/* finally declare the event listener on input field */
Event.observe(this._relative,
'click', this.click.bindAsEventListener(this), false);
/* need to append on body when doc is loaded for IE */
document.observe('dom:loaded', this.load.bindAsEventListener(this), false);
/* automatically close when blur event is triggered */
if ( this._enableCloseOnBlur ) {
Event.observe(this._relative, 'blur', function (e) {
this._closeTimer = this.close.bind(this).delay(1);
}.bindAsEventListener(this));
Event.observe(this._div, 'click', function (e) {
if (this._closeTimer) {
window.clearTimeout(this._closeTimer);
this._closeTimer = null;
}
});
}
},
/**
* load : called when document is fully-loaded to append datepicker
* to main object.
*/
load : function () {
/* if externalControl defined set the observer on it */
if (this._externalControl)
Event.observe(this._externalControl, 'click',
this.click.bindAsEventListener(this), false);
/* append to page */
if (this._relativeAppend) {
/* append to parent node */
if ($(this._relative).parentNode) {
this._div.innerHTML = this._wrap_in_iframe(this._div.innerHTML);
$(this._relative).parentNode.appendChild( this._div );
}
} else {
/* append to body */
var body = document.getElementsByTagName("body").item(0);
if (body) {
this._div.innerHTML = this._wrap_in_iframe(this._div.innerHTML);
body.appendChild(this._div);
}
if ( this._relativePosition ) {
var a_pos = Element.cumulativeOffset($(this._relative));
this.setPosition(a_pos[1], a_pos[0]);
} else {
if (this._setPositionTop || this._setPositionLeft)
this.setPosition(this._setPositionTop, this._setPositionLeft);
}
}
/* init the date in field if needed */
this._initCurrentDate();
/* declare the observers for UI control */
Event.observe($(this._id_datepicker_prev),
'click', this.prevMonth.bindAsEventListener(this), false);
Event.observe($(this._id_datepicker_next),
'click', this.nextMonth.bindAsEventListener(this), false);
/* set the close locale content */
/*
$(this._id_datepicker_ftr).innerHTML = this.getLocaleClose();
Event.observe($(this._id_datepicker_ftr),
'click', this.close.bindAsEventListener(this), false);
*/
Event.observe($(this._id_datepicker_x),
'click', this.close.bindAsEventListener(this), false);
Event.observe($(this._id_datepicker_today),
'click', this.chooseToday.bindAsEventListener(this), false)
},
/* hack for buggy form elements layering in IE */
_wrap_in_iframe : function ( content ) {
return ( Prototype.Browser.IE ) ?
"" : content;
},
/**
* visible : return the visibility status of the datepicker.
*/
visible : function () {
return $(this._id_datepicker).visible();
},
/**
* click : called when input element is clicked
*/
click : function () {
/* init the datepicker if it doesn't exists */
if ( $(this._id_datepicker) == null ) this.load();
if (!this._isPositionned && this._relativePosition) {
/* position the datepicker relatively to element */
var a_lt = Element.positionedOffset($(this._relative));
$(this._id_datepicker).setStyle({
'left' : Number(a_lt[0]+this._leftOffset)+'px',
'top' : Number(a_lt[1]+this._topOffset)+'px'
});
this._isPositionned = true;
}
if (!this.visible()) {
this._initCurrentDate();
this._redrawCalendar();
}
/* eval the clickCallback function */
eval(this._clickCallback());
/* Effect toggle to fade-in / fade-out the datepicker */
if ( this._enableShowEffect ) {
new Effect.toggle(this._id_datepicker,
this._showEffect, { duration: this._showDuration });
} else {
$(this._id_datepicker).show();
}
},
/**
* close : called when the datepicker is closed
*/
close : function () {
if ( this._enableCloseEffect ) {
switch(this._closeEffect) {
case 'puff':
new Effect.Puff(this._id_datepicker, {
duration : this._closeEffectDuration });
break;
case 'blindUp':
new Effect.BlindUp(this._id_datepicker, {
duration : this._closeEffectDuration });
break;
case 'dropOut':
new Effect.DropOut(this._id_datepicker, {
duration : this._closeEffectDuration });
break;
case 'switchOff':
new Effect.SwitchOff(this._id_datepicker, {
duration : this._closeEffectDuration });
break;
case 'squish':
new Effect.Squish(this._id_datepicker, {
duration : this._closeEffectDuration });
break;
case 'fold':
new Effect.Fold(this._id_datepicker, {
duration : this._closeEffectDuration });
break;
case 'shrink':
new Effect.Shrink(this._id_datepicker, {
duration : this._closeEffectDuration });
break;
default:
new Effect.Fade(this._id_datepicker, {
duration : this._closeEffectDuration });
break;
};
} else {
$(this._id_datepicker).hide();
}
$(this._relative).focus();
eval(this._afterClose());
},
/**
* setDateFormat
*/
setDateFormat : function ( format, separator ) {
if (Object.isUndefined(format))
format = this._dateFormat[0];
if (Object.isUndefined(separator))
separator = this._dateFormat[1];
this._dateFormat = [ format, separator ];
},
/**
* setPosition : set the position of the datepicker.
* param : t=top | l=left
*/
setPosition : function ( t, l ) {
var h_pos = { 'top' : '0px', 'left' : '0px' };
if (!Object.isUndefined(t))
h_pos['top'] = Number(t)+this._topOffset+'px';
if (!Object.isUndefined(l))
h_pos['left']= Number(l)+this._leftOffset+'px';
$(this._id_datepicker).setStyle(h_pos);
this._isPositionned = true;
},
/**
* _getMonthDays : given the year and month find the number of days.
*/
_getMonthDays : function ( year, month ) {
if (((0 == (year%4)) &&
( (0 != (year%100)) || (0 == (year%400)))) && (month == 1))
return 29;
return this._daysInMonth[month];
},
/**
* _buildCalendar : draw the days array for current date
*/
_buildCalendar : function () {
var _self = this;
var tbody = $(this._id_datepicker+'-tbody');
try {
while ( tbody.hasChildNodes() )
tbody.removeChild(tbody.childNodes[0]);
} catch ( e ) {};
/* generate day headers */
var trDay = new Element('tr');
this._language_day.get(this._language).each( function ( item ) {
var td = new Element('td');
td.innerHTML = item;
td.className = 'wday';
trDay.appendChild( td );
});
tbody.appendChild( trDay );
/* generate the content of days */
/* build-up days matrix */
var a_d = [ [ 0, 0, 0, 0, 0, 0, 0 ] ,[ 0, 0, 0, 0, 0, 0, 0 ]
,[ 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0 ]
,[ 0, 0, 0, 0, 0, 0, 0 ]
];
/* set date at beginning of month to display */
var d = new Date(this._current_year, this._current_mon, 1, 12);
/* start the day list on monday */
var startIndex = ( !d.getDay() ) ? 6 : d.getDay() - 1;
var nbDaysInMonth = this._getMonthDays(
this._current_year, this._current_mon);
var daysIndex = 1;
for ( var j = startIndex; j < 7; j++ ) {
a_d[0][j] = {
d : daysIndex
,m : this._current_mon
,y : this._current_year
};
daysIndex++;
}
var a_prevMY = this._prevMonthYear();
var nbDaysInMonthPrev = this._getMonthDays(a_prevMY[1], a_prevMY[0]);
for ( var j = 0; j < startIndex; j++ ) {
a_d[0][j] = {
d : Number(nbDaysInMonthPrev - startIndex + j + 1)
,m : Number(a_prevMY[0])
,y : a_prevMY[1]
,c : 'outbound'
};
}
var switchNextMonth = false;
var currentMonth = this._current_mon;
var currentYear = this._current_year;
for ( var i = 1; i < 6; i++ ) {
for ( var j = 0; j < 7; j++ ) {
a_d[i][j] = {
d : daysIndex
,m : currentMonth
,y : currentYear
,c : ( switchNextMonth ) ? 'outbound' : (
((daysIndex == this._todayDate.getDate()) &&
(this._current_mon == this._todayDate.getMonth()) &&
(this._current_year == this._todayDate.getFullYear())) ? 'today' : null)
};
daysIndex++;
/* if at the end of the month : reset counter */
if (daysIndex > nbDaysInMonth ) {
daysIndex = 1;
switchNextMonth = true;
if (this._current_mon + 1 > 11 ) {
currentMonth = 0;
currentYear += 1;
} else {
currentMonth += 1;
}
}
}
}
/* generate days for current date */
for ( var i = 0; i < 6; i++ ) {
var tr = new Element('tr');
for ( var j = 0; j < 7; j++ ) {
var h_ij = a_d[i][j];
var td = new Element('td');
/* id is : datepicker-day-mon-year or depending on language other way */
/* don't forget to add 1 on month for proper formmatting */
var id = $A([
this._relative,
this._df.date_to_string(h_ij["y"], h_ij["m"]+1, h_ij["d"], '-')
]).join('-');
/* set id and classname for cell if exists */
td.setAttribute('id', id);
if (h_ij["c"])
td.className = h_ij["c"];
/* on onclick : rebuild date value from id of current cell */
var _curDate = new Date();
_curDate.setFullYear(h_ij["y"], h_ij["m"], h_ij["d"]);
if ( this._disablePastDate || this._disableFutureDate ) {
if ( this._disablePastDate ) {
var _res = ( _curDate >= this._todayDate ) ? true : false;
this._bindCellOnClick( td, true, _res, h_ij["c"] );
}
if ( this._disableFutureDate ) {
var _res = ( this._todayDate.getTime() + this._oneDayInMs > _curDate.getTime() ) ? true : false;
this._bindCellOnClick( td, true, _res, h_ij["c"] );
}
} else {
this._bindCellOnClick( td, false );
}
td.innerHTML= h_ij["d"];
tr.appendChild( td );
}
tbody.appendChild( tr );
}
return tbody;
},
/**
* _bindCellOnClick : bind the cell onclick depending on status.
*/
_bindCellOnClick : function ( td, wcompare, compareresult, h_ij_c ) {
var doBind = false;
if ( wcompare ) {
if ( compareresult ) {
doBind = true;
} else {
td.className= ( h_ij_c ) ? 'nclick_outbound' : 'nclick';
}
} else {
doBind = true;
}
if ( doBind ) {
var _self = this;
td.onclick = function () {
$(_self._relative).value = String($(this).readAttribute('id')
).replace(_self._relative+'-','').replace(/-/g, _self._df.separator);
/* if we have a cellCallback defined call it and pass it the cell */
if (_self._cellCallback)
_self._cellCallback(this);
_self.close();
};
}
},
/**
* nextMonth : redraw the calendar content for next month.
*/
_nextMonthYear : function () {
var c_mon = this._current_mon;
var c_year = this._current_year;
if (c_mon + 1 > 11) {
c_mon = 0;
c_year += 1;
} else {
c_mon += 1;
}
return [ c_mon, c_year ];
},
nextMonth : function () {
var a_next = this._nextMonthYear();
var _nextMon = a_next[0];
var _nextYear = a_next[1];
var _curDate = new Date(); _curDate.setFullYear(_nextYear, _nextMon, 1);
var _res = ( this._todayDate.getTime() + this._oneDayInMs > _curDate.getTime() ) ? true : false;
if ( this._disableFutureDate && !_res )
return;
this._current_mon = _nextMon;
this._current_year = _nextYear;
this._redrawCalendar();
},
/**
* chooseToday
*/
chooseToday : function () {
this._current_mon = this._todayDate.getMonth();
this._current_year = this._todayDate.getFullYear();
this._current_day = this._todayDate.getDate();
this._redrawCalendar();
},
/**
* prevMonth : redraw the calendar content for previous month.
*/
_prevMonthYear : function () {
var c_mon = this._current_mon;
var c_year = this._current_year;
if (c_mon - 1 < 0) {
c_mon = 11;
c_year -= 1;
} else {
c_mon -= 1;
}
return [ c_mon, c_year ];
},
prevMonth : function () {
var a_prev = this._prevMonthYear();
var _prevMon = a_prev[0];
var _prevYear = a_prev[1];
var _curDate = new Date(); _curDate.setFullYear(_prevYear, _prevMon, 1);
var _res = ( _curDate >= this._todayDate ) ? true : false;
if ( this._disablePastDate && !_res )
return;
this._current_mon = _prevMon;
this._current_year = _prevYear;
this._redrawCalendar();
},
_redrawCalendar : function () {
this._setLocaleHdr(); this._buildCalendar();
},
_setLocaleHdr : function () {
/* next link */
var a_next = this._nextMonthYear();
$(this._id_datepicker_next).setAttribute('title',
this.getMonthLocale(a_next[0])+' '+a_next[1]);
/* prev link */
var a_prev = this._prevMonthYear();
$(this._id_datepicker_prev).setAttribute('title',
this.getMonthLocale(a_prev[0])+' '+a_prev[1]);
/* header */
$(this._id_datepicker_hdr).update(' '+this.getMonthLocale(this._current_mon)+' '+this._current_year+' ');
}
};
var datepickers = $H();
var lastdp;
function initDatepickers() {
$$("*").findAll(function(node) {
return Element.hasClassName(node,'datepicker');
}).each(function(node) {
datepickers[node.id] = new DatePicker({
relative : node.id,
language : 'de',
keepFieldEmpty : true
});
lastdp = datepickers[node.id];
});
}
Event.observe(window, 'load', initDatepickers, false);
function hover_zoom_in(dom_id) {
fxitem = document.getElementById(dom_id);
fxitem.style.zIndex = 200;
fxitem.zIndex = 200;
new Effect.Scale(fxitem , 105.2, {scaleFromCenter:true, scaleFrom:100, scaleContent:true,
duration: .15, queue:{ position: 'end', scope: fxitem.id }});
}
function hover_zoom_out(dom_id) {
fxitem = document.getElementById(dom_id);
fxitem.style.zIndex = 100;
fxitem.zIndex = 200;
new Effect.Scale(fxitem , 95, {scaleFromCenter:true, scaleFrom:100, scaleContent:true,
duration: .15, queue:{ position: 'end', scope: fxitem.id }});
// new Effect.Move(fxitem, { x: 0, y: 0, mode: 'absolute',queue:{ position: 'end', scope: fxitem.id }});
}
function queue_slide_toggle(dom_id)
{
fxitem = document.getElementById(dom_id);
if (fxitem) {
new Effect.toggle(fxitem, 'slide', { duration: 0.3, queue:{ position: 'end', scope: fxitem.id } })
}
}
function queue_slide_down(dom_id)
{
fxitem = document.getElementById(dom_id);
if (fxitem && fxitem.style.display == 'none') {
new Effect.SlideDown(fxitem, { duration: 0.3, queue:{ position: 'end', scope: 'slide' } })
}
}
function queue_slide_up(dom_id)
{
fxitem = document.getElementById(dom_id);
if (fxitem && fxitem.style.display != 'none') {
new Effect.SlideUp(fxitem, { duration: 0.3, queue:{ position: 'end', scope: 'slide' } })
}
}
var slide_down_timer = new Array();
var slide_up_timer = new Array();
function delayed_slide_down(dom_id, delay)
{
clearTimeout(slide_down_timer[dom_id]);
clearTimeout(slide_up_timer[dom_id]);
slide_down_timer[dom_id] = setTimeout('queue_slide_down("'+dom_id+'");', delay);
}
function delayed_slide_up(dom_id, delay)
{
clearTimeout(slide_down_timer[dom_id]);
clearTimeout(slide_up_timer[dom_id]);
slide_down_timer[dom_id] = setTimeout('queue_slide_up("'+dom_id+'");', delay);
}
var cmstab_resize_subtractor = new Array();
function cmstab_resize(instance_id)
{
var tab = $(instance_id+'_outer');
var vp_height = document.viewport.getHeight();
if (typeof(cmstab_resize_subtractor[instance_id]) == "undefined") {
tab.style.height = vp_height+'px'
var tab_height = tab.getHeight();
window.scroll(0,5000);
var overflow_height = document.viewport.getScrollOffsets()[1];
if (overflow_height > 0) {
tab_height = tab_height - overflow_height - 20;
if (tab_height < 80) tab_height = 80;
tab.style.height = tab_height+'px';
}
cmstab_resize_subtractor[instance_id] = vp_height - tab_height;
} else {
tab.style.height = (vp_height - cmstab_resize_subtractor[instance_id]) + 'px';
}
$(instance_id+'_table').style.height = tab.style.height;
}
/**
* Blend Slideshow Class
*
* Blend a series of images or other elements
*/
function blend_slideshow()
{
/**
* Indicates the current active slide
*/
this.currentSlideNr = 0;
/**
* The array containing the slide elements
*/
this.slideArray = new Array();
/**
* The amount of slides
*/
this.slideCount = -1;
/**
* The interval for showing the next slides in milliseconds
*/
this.interval_ms = 5000;
this.play_interval = 0;
}
/**
* Browse dom tree for class name and add matching elements
* as slides
*/
blend_slideshow.prototype.initByClassName = function(classname)
{
var elems = getElementsByClassName(classname);
this.initByArray(elems);
}
/**
* Add slides by provided array. The array can contain either dom IDs
* or the elements themselves
*/
blend_slideshow.prototype.initByArray = function(elems_or_dom_ids)
{
for (var i = 0; i < elems_or_dom_ids.length; i++) {
this.addSlide(elems_or_dom_ids[i]);
}
}
/**
* Add a single element as slide
*/
blend_slideshow.prototype.addSlide = function(elem_or_dom_id)
{
if (elem_or_dom_id && elem_or_dom_id != null) {
var elem = $(elem_or_dom_id);
if (elem) {
this.slideCount++;
this.slideArray[this.slideCount] = elem;
}
}
}
/**
* Set the blending interval in seconds. Minimum is 2 seconds
*/
blend_slideshow.prototype.setIntervalSeconds = function(seconds)
{
if (seconds < 2) {
seconds = 2;
}
this.interval_ms = seconds * 1000;
}
/**
* Start slide show interval
*/
blend_slideshow.prototype.startSlideShow = function()
{
var selfobject = this;
this.play_interval = setInterval(function() { selfobject.play(); }, this.interval_ms);
}
/**
* Jump to slide Nr
*/
blend_slideshow.prototype.showSlideNr = function(nextSlideNr)
{
if (nextSlideNr > this.slideCount) {
nextSlideNr = 0;
} else if (nextSlideNr < 0) {
nextSlideNr = this.slideCount;
}
this.slideArray[nextSlideNr].style.zIndex = 100;
this.slideArray[this.currentSlideNr].style.zIndex = 1;
var lastSlide = this.slideArray[this.currentSlideNr];
this.slideArray[nextSlideNr].appear({
duration: 1.5,
queue:{ position: 'end', scope: 'global' },
afterFinish: function() { lastSlide.style.display = 'none'; }
});
//this.slideArray[this.currentSlideNr].fade({duration: 0.5, queue:{ position: 'end', scope: 'global' }});
this.currentSlideNr = nextSlideNr;
}
/**
* Go to next slide nr (by interval)
*/
blend_slideshow.prototype.play = function()
{
this.showSlideNr(this.currentSlideNr + 1);
}
/**
* Stop the interval slide show
*/
blend_slideshow.prototype.stop = function()
{
clearInterval(this.play_interval);
}
/**
* Go to next slide (manually)
*/
blend_slideshow.prototype.showNext = function()
{
this.stop();
this.showSlideNr(this.currentSlideNr + 1);
}
/**
* Go to previous slide (manually)
*/
blend_slideshow.prototype.showPrevious = function()
{
this.stop();
this.showSlideNr(this.currentSlideNr - 1);
}