ErrorAdobe Flash is either not installed or not up to date,
please visit
Adobe.com to download the free player.
');
} else {
image.setStyles({backgroundImage: "none", display: ""});
preload.inject(image);
}
} else if (mediaType == "inline") {
image.setStyles({backgroundImage: "none", display: ""});
image.set('html', preload);
} else if (mediaType == "url") {
image.setStyles({backgroundImage: "none", display: ""});
preload.inject(image);
} else {
alert('this file type is not supported\n'+URL+'\nplease visit iaian7.com/webcode/Mediabox for more information');
}
$$(image, bottom).setStyle("width", mediaWidth);
image.setStyle("height", mediaHeight);
title.set('html', (options.showCaption) ? captionSplit[0] : "");
caption.set('html', (options.showCaption && (captionSplit.length > 1)) ? captionSplit[1] : "");
number.set('html', (options.showCounter && (images.length > 1)) ? options.counterText.replace(/{x}/, activeImage + 1).replace(/{y}/, images.length) : "");
if ((prevImage >= 0) && (images[prevImage][0].match(/\.gif|\.jpg|\.png/i))) preloadPrev.src = images[prevImage][0];
if ((nextImage >= 0) && (images[nextImage][0].match(/\.gif|\.jpg|\.png/i))) preloadNext.src = images[nextImage][0];
state++;
case 3:
center.className = "";
fx.resize.start({height: image.offsetHeight, width: image.offsetWidth, marginLeft: -image.offsetWidth/2});
break;
state++;
case 4:
bottomContainer.setStyles({top: top + center.clientHeight, marginLeft: center.style.marginLeft, visibility: "hidden", display: ""});
fx.image.start(1);
break;
case 5:
if (prevImage >= 0) prevLink.style.display = "";
if (nextImage >= 0) nextLink.style.display = "";
if (options.animateCaption) {
fx.bottom.set(-bottom.offsetHeight).start(0);
}
bottomContainer.style.visibility = "";
state = 1;
}
}
function close() {
if (state) {
state = 0;
preload.onload = $empty;
image.set('html', '');
for (var f in fx) fx[f].cancel();
$$(center, bottomContainer).setStyle("display", "none");
fx.overlay.chain(setup).start(0);
}
return false;
}
})();
// AUTOLOAD CODE BLOCK
Mediabox.scanPage = function() {
var links = $$("a").filter(function(el) {
return el.rel && el.rel.test(/^lightbox/i);
});
$$(links).mediabox({/* Put custom options here */}, null, function(el) {
var rel0 = this.rel.replace(/[[]|]/gi," ");
var relsize = rel0.split(" ");
return (this == el) || ((this.rel.length > 8) && el.rel.match(relsize[1]));
});
};
Fx.Scroll = new Class({
Extends: Fx,
options: {
offset: {x: 0, y: 0},
wheelStops: true
},
initialize: function(element, options){
this.element = this.subject = $(element);
this.parent(options);
var cancel = this.cancel.bind(this, false);
if ($type(this.element) != 'element') this.element = $(this.element.getDocument().body);
var stopper = this.element;
if (this.options.wheelStops){
this.addEvent('start', function(){
stopper.addEvent('mousewheel', cancel);
}, true);
this.addEvent('complete', function(){
stopper.removeEvent('mousewheel', cancel);
}, true);
}
},
set: function(){
var now = Array.flatten(arguments);
this.element.scrollTo(now[0], now[1]);
},
compute: function(from, to, delta){
return [0, 1].map(function(i){
return Fx.compute(from[i], to[i], delta);
});
},
start: function(x, y){
if (!this.check(x, y)) return this;
var offsetSize = this.element.getSize(), scrollSize = this.element.getScrollSize();
var scroll = this.element.getScroll(), values = {x: x, y: y};
for (var z in values){
var max = scrollSize[z] - offsetSize[z];
if ($chk(values[z])) values[z] = ($type(values[z]) == 'number') ? values[z].limit(0, max) : max;
else values[z] = scroll[z];
values[z] += this.options.offset[z];
}
return this.parent([scroll.x, scroll.y], [values.x, values.y]);
},
toTop: function(){
return this.start(false, 0);
},
toLeft: function(){
return this.start(0, false);
},
toRight: function(){
return this.start('right', false);
},
toBottom: function(){
return this.start(false, 'bottom');
},
toElement: function(el){
var position = $(el).getPosition(this.element);
return this.start(position.x, position.y);
}
});
/*
Script: Fx.Slide.js
Effect to slide an element in and out of view.
License:
MIT-style license.
Authors:
Valerio Proietti
*/
Fx.Slide = new Class({
Extends: Fx,
options: {
mode: 'vertical'
},
initialize: function(element, options){
this.addEvent('complete', function(){
this.open = (this.wrapper['offset' + this.layout.capitalize()] != 0);
if (this.open && Browser.Engine.webkit419) this.element.dispose().inject(this.wrapper);
}, true);
this.element = this.subject = $(element);
this.parent(options);
var wrapper = this.element.retrieve('wrapper');
this.wrapper = wrapper || new Element('div', {
styles: $extend(this.element.getStyles('margin', 'position'), {overflow: 'hidden'})
}).wraps(this.element);
this.element.store('wrapper', this.wrapper).setStyle('margin', 0);
this.now = [];
this.open = true;
},
vertical: function(){
this.margin = 'margin-top';
this.layout = 'height';
this.offset = this.element.offsetHeight;
},
horizontal: function(){
this.margin = 'margin-left';
this.layout = 'width';
this.offset = this.element.offsetWidth;
},
set: function(now){
this.element.setStyle(this.margin, now[0]);
this.wrapper.setStyle(this.layout, now[1]);
return this;
},
compute: function(from, to, delta){
return [0, 1].map(function(i){
return Fx.compute(from[i], to[i], delta);
});
},
start: function(how, mode){
if (!this.check(how, mode)) return this;
this[mode || this.options.mode]();
var margin = this.element.getStyle(this.margin).toInt();
var layout = this.wrapper.getStyle(this.layout).toInt();
var caseIn = [[margin, layout], [0, this.offset]];
var caseOut = [[margin, layout], [-this.offset, 0]];
var start;
switch (how){
case 'in': start = caseIn; break;
case 'out': start = caseOut; break;
case 'toggle': start = (layout == 0) ? caseIn : caseOut;
}
return this.parent(start[0], start[1]);
},
slideIn: function(mode){
return this.start('in', mode);
},
slideOut: function(mode){
return this.start('out', mode);
},
hide: function(mode){
this[mode || this.options.mode]();
this.open = false;
return this.set([-this.offset, 0]);
},
show: function(mode){
this[mode || this.options.mode]();
this.open = true;
return this.set([0, this.offset]);
},
toggle: function(mode){
return this.start('toggle', mode);
}
});
Element.Properties.slide = {
set: function(options){
var slide = this.retrieve('slide');
if (slide) slide.cancel();
return this.eliminate('slide').store('slide:options', $extend({link: 'cancel'}, options));
},
get: function(options){
if (options || !this.retrieve('slide')){
if (options || !this.retrieve('slide:options')) this.set('slide', options);
this.store('slide', new Fx.Slide(this, this.retrieve('slide:options')));
}
return this.retrieve('slide');
}
};
Element.implement({
slide: function(how, mode){
how = how || 'toggle';
var slide = this.get('slide'), toggle;
switch (how){
case 'hide': slide.hide(mode); break;
case 'show': slide.show(mode); break;
case 'toggle':
var flag = this.retrieve('slide:flag', slide.open);
slide[flag ? 'slideOut' : 'slideIn'](mode);
this.store('slide:flag', !flag);
toggle = true;
break;
default: slide.start(how, mode);
}
if (!toggle) this.eliminate('slide:flag');
return this;
}
});
Element.implement({
measure: function(fn){
var vis = function(el) {
return !!(!el || el.offsetHeight || el.offsetWidth);
};
if (vis(this)) return fn.apply(this);
var parent = this.getParent(),
toMeasure = [],
restorers = [];
while (!vis(parent) && parent != document.body) {
toMeasure.push(parent.expose());
parent = parent.getParent();
}
var restore = this.expose();
var result = fn.apply(this);
restore();
toMeasure.each(function(restore){
restore();
});
return result;
},
expose: function(){
if (this.getStyle('display') != 'none') return $empty;
var before = this.getStyles('display', 'position', 'visibility');
return this.setStyles({
display: 'block',
position: 'absolute',
visibility: 'hidden'
}).setStyles.pass(before, this);
},
getDimensions: function(options){
options = $merge({computeSize: false},options);
var dim = {};
var getSize = function(el, options){
return (options.computeSize)?el.getComputedSize(options):el.getSize();
};
if (this.getStyle('display') == 'none'){
dim = this.measure(function(){
return getSize(this, options);
});
} else {
try { //safari sometimes crashes here, so catch it
dim = getSize(this, options);
}catch(e){}
}
return $chk(dim.x) ? $extend(dim, {width: dim.x, height: dim.y}) : $extend(dim, {x: dim.width, y: dim.height});
},
getComputedSize: function(options){
options = $merge({
styles: ['padding','border'],
plains: {
height: ['top','bottom'],
width: ['left','right']
},
mode: 'both'
}, options);
var size = {width: 0,height: 0};
switch (options.mode){
case 'vertical':
delete size.width;
delete options.plains.width;
break;
case 'horizontal':
delete size.height;
delete options.plains.height;
break;
}
var getStyles = [];
//this function might be useful in other places; perhaps it should be outside this function?
$each(options.plains, function(plain, key){
plain.each(function(edge){
options.styles.each(function(style){
getStyles.push((style == 'border') ? style + '-' + edge + '-' + 'width' : style + '-' + edge);
});
});
});
var styles = {};
getStyles.each(function(style){ styles[style] = this.getComputedStyle(style); }, this);
var subtracted = [];
$each(options.plains, function(plain, key){ //keys: width, height, plains: ['left', 'right'], ['top','bottom']
var capitalized = key.capitalize();
size['total' + capitalized] = 0;
size['computed' + capitalized] = 0;
plain.each(function(edge){ //top, left, right, bottom
size['computed' + edge.capitalize()] = 0;
getStyles.each(function(style, i){ //padding, border, etc.
//'padding-left'.test('left') size['totalWidth'] = size['width'] + [padding-left]
if (style.test(edge)){
styles[style] = styles[style].toInt() || 0; //styles['padding-left'] = 5;
size['total' + capitalized] = size['total' + capitalized] + styles[style];
size['computed' + edge.capitalize()] = size['computed' + edge.capitalize()] + styles[style];
}
//if width != width (so, padding-left, for instance), then subtract that from the total
if (style.test(edge) && key != style &&
(style.test('border') || style.test('padding')) && !subtracted.contains(style)){
subtracted.push(style);
size['computed' + capitalized] = size['computed' + capitalized]-styles[style];
}
});
});
});
['Width', 'Height'].each(function(value){
var lower = value.toLowerCase();
if(!$chk(size[lower])) return;
size[lower] = size[lower] + this['offset' + value] + size['computed' + value];
size['total' + value] = size[lower] + size['total' + value];
delete size['computed' + value];
}, this);
return $extend(styles, size);
}
});
/*
Script: Element.Shortcuts.js
Extends the Element native object to include some shortcut methods.
License:
MIT-style license.
Authors:
Aaron Newton
*/
Element.implement({
isDisplayed: function(){
return this.getStyle('display') != 'none';
},
toggle: function(){
return this[this.isDisplayed() ? 'hide' : 'show']();
},
hide: function(){
var d;
try {
//IE fails here if the element is not in the dom
if ('none' != this.getStyle('display')) d = this.getStyle('display');
} catch(e){}
return this.store('originalDisplay', d || 'block').setStyle('display', 'none');
},
show: function(display){
return this.setStyle('display', display || this.retrieve('originalDisplay') || 'block');
},
swapClass: function(remove, add){
return this.removeClass(remove).addClass(add);
}
});
/*
Script: Fx.Reveal.js
Defines Fx.Reveal, a class that shows and hides elements with a transition.
License:
MIT-style license.
Authors:
Aaron Newton
*/
Fx.Reveal = new Class({
Extends: Fx.Morph,
options: {/*
onShow: $empty(thisElemeng),
onHide: $empty(thisElemeng),
onComplete: $empty(thisElemeng),
heightOverride: null,
widthOverride: null, */
styles: ['padding', 'border', 'margin'],
transitionOpacity: !Browser.Engine.trident4,
mode: 'vertical',
display: 'block',
hideInputs: Browser.Engine.trident ? 'select, input, textarea, object, embed' : false
},
dissolve: function(){
try {
if (!this.hiding && !this.showing){
if (this.element.getStyle('display') != 'none'){
this.hiding = true;
this.showing = false;
this.hidden = true;
var startStyles = this.element.getComputedSize({
styles: this.options.styles,
mode: this.options.mode
});
var setToAuto = (this.element.style.height === ''||this.element.style.height == 'auto');
this.element.setStyle('display', 'block');
if (this.options.transitionOpacity) startStyles.opacity = 1;
var zero = {};
$each(startStyles, function(style, name){
zero[name] = [style, 0];
}, this);
var overflowBefore = this.element.getStyle('overflow');
this.element.setStyle('overflow', 'hidden');
var hideThese = this.options.hideInputs ? this.element.getElements(this.options.hideInputs) : null;
this.$chain.unshift(function(){
if (this.hidden){
this.hiding = false;
$each(startStyles, function(style, name){
startStyles[name] = style;
}, this);
this.element.setStyles($merge({display: 'none', overflow: overflowBefore}, startStyles));
if (setToAuto){
if (['vertical', 'both'].contains(this.options.mode)) this.element.style.height = '';
if (['width', 'both'].contains(this.options.mode)) this.element.style.width = '';
}
if (hideThese) hideThese.setStyle('visibility', 'visible');
}
this.fireEvent('hide', this.element);
this.callChain();
}.bind(this));
if (hideThese) hideThese.setStyle('visibility', 'hidden');
this.start(zero);
} else {
this.callChain.delay(10, this);
this.fireEvent('complete', this.element);
this.fireEvent('hide', this.element);
}
} else if (this.options.link == 'chain'){
this.chain(this.dissolve.bind(this));
} else if (this.options.link == 'cancel' && !this.hiding){
this.cancel();
this.dissolve();
}
} catch(e){
this.hiding = false;
this.element.setStyle('display', 'none');
this.callChain.delay(10, this);
this.fireEvent('complete', this.element);
this.fireEvent('hide', this.element);
}
return this;
},
reveal: function(){
try {
if (!this.showing && !this.hiding){
if (this.element.getStyle('display') == 'none' ||
this.element.getStyle('visiblity') == 'hidden' ||
this.element.getStyle('opacity') == 0){
this.showing = true;
this.hiding = false;
this.hidden = false;
var setToAuto, startStyles;
//toggle display, but hide it
this.element.measure(function(){
setToAuto = (this.element.style.height === '' || this.element.style.height == 'auto');
//create the styles for the opened/visible state
startStyles = this.element.getComputedSize({
styles: this.options.styles,
mode: this.options.mode
});
}.bind(this));
$each(startStyles, function(style, name){
startStyles[name] = style;
});
//if we're overridding height/width
if ($chk(this.options.heightOverride)) startStyles.height = this.options.heightOverride.toInt();
if ($chk(this.options.widthOverride)) startStyles.width = this.options.widthOverride.toInt();
if (this.options.transitionOpacity) {
this.element.setStyle('opacity', 0);
startStyles.opacity = 1;
}
//create the zero state for the beginning of the transition
var zero = {
height: 0,
display: this.options.display
};
$each(startStyles, function(style, name){ zero[name] = 0; });
var overflowBefore = this.element.getStyle('overflow');
//set to zero
this.element.setStyles($merge(zero, {overflow: 'hidden'}));
//hide inputs
var hideThese = this.options.hideInputs ? this.element.getElements(this.options.hideInputs) : null;
if (hideThese) hideThese.setStyle('visibility', 'hidden');
//start the effect
this.start(startStyles);
this.$chain.unshift(function(){
this.element.setStyle('overflow', overflowBefore);
if (!this.options.heightOverride && setToAuto){
if (['vertical', 'both'].contains(this.options.mode)) this.element.style.height = '';
if (['width', 'both'].contains(this.options.mode)) this.element.style.width = '';
}
if (!this.hidden) this.showing = false;
if (hideThese) hideThese.setStyle('visibility', 'visible');
this.callChain();
this.fireEvent('show', this.element);
}.bind(this));
} else {
this.callChain();
this.fireEvent('complete', this.element);
this.fireEvent('show', this.element);
}
} else if (this.options.link == 'chain'){
this.chain(this.reveal.bind(this));
} else if (this.options.link == 'cancel' && !this.showing){
this.cancel();
this.reveal();
}
} catch(e){
this.element.setStyles({
display: this.options.display,
visiblity: 'visible',
opacity: 1
});
this.showing = false;
this.callChain.delay(10, this);
this.fireEvent('complete', this.element);
this.fireEvent('show', this.element);
}
return this;
},
toggle: function(){
if (this.element.getStyle('display') == 'none' ||
this.element.getStyle('visiblity') == 'hidden' ||
this.element.getStyle('opacity') == 0){
this.reveal();
} else {
this.dissolve();
}
return this;
}
});
Element.Properties.reveal = {
set: function(options){
var reveal = this.retrieve('reveal');
if (reveal) reveal.cancel();
return this.eliminate('reveal').store('reveal:options', $extend({link: 'cancel'}, options));
},
get: function(options){
if (options || !this.retrieve('reveal')){
if (options || !this.retrieve('reveal:options')) this.set('reveal', options);
this.store('reveal', new Fx.Reveal(this, this.retrieve('reveal:options')));
}
return this.retrieve('reveal');
}
};
Element.Properties.dissolve = Element.Properties.reveal;
Element.implement({
reveal: function(options){
this.get('reveal', options).reveal();
return this;
},
dissolve: function(options){
this.get('reveal', options).dissolve();
return this;
},
nix: function(){
var params = Array.link(arguments, {destroy: Boolean.type, options: Object.type});
this.get('reveal', params.options).dissolve().chain(function(){
this[params.destroy ? 'destroy' : 'dispose']();
}.bind(this));
return this;
},
wink: function(){
var params = Array.link(arguments, {duration: Number.type, options: Object.type});
var reveal = this.get('reveal', params.options);
reveal.reveal().chain(function(){
(function(){
reveal.dissolve();
}).delay(params.duration || 2000);
});
}
});
var SL_Slider = new Class({
//implements
Implements: [Options],
//variables setup
numNav: new Array(), //will store number nav elements (if used)
timer: null, //periodical function variable holder
isSliding: 1, //flag for animation/click prevention
direction: 1, //flag for direction (forward/reverse)
//options
options: {
slideTimer: 8000, //Time between slides (1 second = 1000), a.k.a. the interval duration
isPaused: false, //flag for paused state
transitionTime: 800, //Transition time (1 second = 1000)
transitionType: 'cubic:out', //Transition type
container: null, //container element
items: null, //Array of elements for sliding
itemNum: 0, //Current item number
numNavActive: false, //Whether or not the number navigation will be used
numNavHolder: null, //Element that holds the number navigation
playBtn: null, //Play (and pause) button element
prevBtn: null, //Previous button element
nextBtn: null //Next button element
},
//initialization
initialize: function(options) {
var self = this;
//set options
this.setOptions(options);
//remove any scrollbar(s) on the container
self.options.container.setStyle('overflow', "hidden");
//if there is a play/pause button, set up functionality for it
if(self.options.playBtn != null) {
//self.pauseIt();
self.options.playBtn.set('text', 'pause');
self.options.playBtn.addEvents({
'click': function() {
self.pauseIt();
},
'mouseenter' : function() {
this.setStyle('cursor', 'pointer');
},
'mouseleave' : function() {
}
});
}
//if there is a prev & next button, set up functionality for them
if(self.options.prevBtn && self.options.nextBtn){
self.options.prevBtn.addEvents({
'click' : function() {
if(self.isSliding == 0){
if(self.options.isPaused == false){
$clear(self.timer);
self.timer = self.slideIt.periodical(self.options.slideTimer, self, null);
}
self.direction = 0;
self.slideIt();
}
},
'mouseenter' : function() {
this.setStyle('cursor', 'pointer');
},
'mouseleave' : function() {
}
});
this.options.nextBtn.addEvents({
'click' : function() {
if(self.isSliding == 0){
if(self.options.isPaused == false){
$clear(self.timer);
self.timer = self.slideIt.periodical(self.options.slideTimer, self, null);
}
self.direction = 1;
self.slideIt();
}
},
'mouseenter' : function() {
this.setStyle('cursor', 'pointer');
},
'mouseleave' : function() {
}
});
}
//setup items (a.k.a. slides) from list
self.options.items.each(function(el, i){
//f.y.i. el = the element, i = the index
el.setStyle('position', "absolute");
var itemH = el.getSize().y;
var itemW = el.getSize().x;
//el.setStyle('top', (-1 * itemH)); //would use this if doing vertical transition
el.setStyle('left', (-1 * itemW));
// -- Number nav setup
if(self.options.numNavActive == true){
//create numbered navigation boxes, and insert into the 'num_nav' ul)
var numItem = new Element('li', {id: 'num'+i});
var numLink = new Element('a', {
'class': 'numbtn',
'html': (i+1)
});
numItem.adopt(numLink);
self.options.numNavHolder.adopt(numItem);
self.numNav.push(numLink);
numLink.set('morph', {duration: 100, transition: Fx.Transitions.linear, link: 'ignore'});
numLink.addEvents({
'click' : function(){
self.numPress(i);
},
'mouseenter' : function() {
this.setStyle('cursor', 'pointer');
}
});
//set initial number to active state
if(i == self.options.itemNum){
var initNum = self.numNav[i];
initNum.addClass('active');
}
}
//end if num nav 'active'
});
},
//startup method
start: function() {
var self = this;
self.slideIt(self.options.itemNum); //initialize first slide
if(self.options.isPaused == false){
self.timer = self.slideIt.periodical(self.options.slideTimer, self, null);
if(self.options.playBtn) self.options.playBtn.set('text', 'pause');
}
else{
//self.pauseIt();
if(self.options.playBtn) self.options.playBtn.set('text', 'play');
}
},
slideIt: function(passedID) {
var self = this;
//get item to slide out
var curItem = self.options.items[self.options.itemNum];
if(self.options.numNavActive == true){
var curNumItem = self.numNav[self.options.itemNum];
}
//check for passedID presence
if(passedID != null) {
if(self.options.itemNum != passedID){
if(self.options.itemNum > passedID) {
self.direction = 0;
} else {
self.direction = 1;
}
self.options.itemNum = passedID;
}
}
else{
self.changeIndex();
}
//now get item to slide in using new index
var newItem = self.options.items[self.options.itemNum];
if(self.direction == 0){
var curX = self.options.container.getSize().x;
var newX = (-1 * newItem.getSize().x);
}
else{
var curX = (-1 * self.options.container.getSize().x);
var newX = newItem.getSize().x;
}
//add/remove active number's highlight
if(self.options.numNavActive == true){
var newNumItem = self.numNav[self.options.itemNum];
newNumItem.addClass('active');
}
//set up our animation stylings
var item_in = new Fx.Morph(newItem, {
duration: self.options.transitionTime,
transition: self.options.transitionType,
link: 'ignore',
onStart: function(){
self.isSliding = 1; //prevents extra clicks
},
onComplete: function(){
self.isSliding = 0; //prevents extra clicks
}
});
item_in.start({
//'opacity':[0,1],
'left' : [newX, 0]
});
if(curItem != newItem){
var item_out = new Fx.Morph(curItem, {
duration: self.options.transitionTime,
transition: self.options.transitionType,
link: 'ignore'
});
if(self.options.numNavActive == true){
curNumItem.removeClass('active');
}
item_out.start({
//'opacity':[0],
'left' : [(curX)]
});
}
},
//--------------------------------------------------------------------------------------------------------
//supplementary functions (mini-functions)
//--------------------------------------------------------------------------------------------------------
pauseIt: function () {
var self = this;
//only move if not currently moving
if(self.isSliding == 0){
if(self.options.isPaused == false){
self.options.isPaused = true;
$clear(self.timer);
self.options.playBtn.set('text', 'play');
}
else{
self.options.isPaused = false;
self.slideIt();
self.timer = self.slideIt.periodical(self.options.slideTimer, this, null);
self.options.playBtn.set('text', 'pause');
}
} //end if not sliding
},
changeIndex: function() {
var self = this;
var numItems = self.options.items.length; //get number of slider items
//change index based on value of 'direction' parameter
if(self.direction == 1){
if(self.options.itemNum < (numItems - 1)){
self.options.itemNum++;
}
else{
self.options.itemNum = 0;
}
}
else if(self.direction == 0){
if(self.options.itemNum > 0){
self.options.itemNum--;
}
else{
self.options.itemNum = (numItems - 1);
}
}
},
numPress: function (theIndex) {
var self = this;
if((self.isSliding == 0) && (self.options.itemNum != theIndex)){
if(self.options.isPaused == false){
$clear(self.timer);
self.timer = self.slideIt.periodical(self.options.slideTimer, this, null);
}
self.slideIt(theIndex);
}
}
//------------------------ end supp. functions -----------------------------------------//
});
/*
* DatePicker
* @author Rick Hopkins
* @modified by Micah Nolte and Martin Vasina
* @modified again by Arian Stolwijk (version 0.4)
* @version 0.4
* @classDescription A date picker object. Created with the help of MooTools v1.2.1
* MIT-style License.
-- start it up by doing this in your domready:
$$('input.DatePicker').each( function(el){
new DatePicker(el);
});
*/
var DatePicker = new Class({
Implements: [Options],
options: {
dayChars: 2,
dayNames: ['Zondag', 'Maandag', 'Dinsdag', 'Woensdag', 'Donderdag', 'Vrijdag', 'Zaterdag'],
daysInMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
format: 'dd-mm-yyyy',
monthNames: ['januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus', 'september', 'oktober', 'november', 'december'],
startDay: 7,
yearOrder: 'asc',
yearRange: 2,
yearStart: (new Date().getFullYear())
},
/* set and create the date picker text box */
initialize: function(dp,options){
this.setOptions(options);
// Finds the entered date, or uses the current date
if(dp.get('value') != '') {
this.then = new Date(dp.value);
this.today = new Date();
} else {
this.then = this.today = new Date();
}
// Set beginning time and today, remember the original
this.oldYear = this.year = this.then.getFullYear();
this.oldMonth = this.month = this.then.getMonth();
this.oldDay = this.then.getDate();
this.nowYear = this.today.getFullYear();
this.nowMonth = this.today.getMonth();
this.nowDay = this.today.getDate();
this.options.monthNames = (this.options.monthNames && this.options.monthNames.length == 12 ? this.options.monthNames : this.options.monthNames) || this.options.monthNames;
this.options.daysInMonth = (this.options.daysInMonth && this.options.daysInMonth.length == 12 ? this.options.daysInMonth : this.options.daysInMonth) || this.options.daysInMonth;
this.options.dayNames = (this.options.dayNames && this.options.dayNames.length == 7 ? this.options.dayNames : this.options.dayNames) || this.options.dayNames;
this.dp = dp;
this.dp.set('id',dp.get('name'));
this.container = this.calendar = this.active = false;
this.dp.addEvents({
'click': function(){this.create()}.bind(this),
'focus': function(){this.create()}.bind(this)
});
},
/* create the calendar */
create: function(fade){
if (this.calendar) return false;
fade = ($type(fade) == 'boolean') ? fade : true;
// IE does not want to fade :S
if(Browser.Engine.trident && Browser.Engine.version <= 5){
fade = false;
}
// Hide select boxes while calendar is up
if(Browser.Engine.trident && Browser.Engine.version <= 4){
$$('select').addClass('dp_hide');
}
/* create the outer container */
this.container = new Element('div', {'class':'dp_container'}).injectBefore(this.dp);
if (fade) {
this.container.fade('hide');
}
/* create the calendar */
this.calendar = new Element('div', {'class':'dp_cal'}).injectInside(this.container);
/* create the date object */
var date = new Date();
/* create the date object */
if (this.month && this.year) {
date.setFullYear(this.year, this.month, 1);
} else {
this.month = date.getMonth();
this.year = date.getFullYear();
date.setDate(1);
}
this.year % 4 == 0 ? this.options.daysInMonth[1] = 29 : this.options.daysInMonth[1] = 28;
/* set the day to first of the month */
var firstDay = (1-(7+date.getDay()-this.options.startDay)%7);
/* create the month select box */
monthSel = new Element('select', {'id':this.dp.get('id') + '_monthSelect'});
this.options.monthNames.each(function(item,index){
monthSel.options[index] = new Element('option', {value: index});
monthSel.options[index].set('text',item);
if (this.month == index) monthSel.options[index].set('selected','selected');
}.bind(this));
/* create the year select box */
yearSel = new Element('select', {'id':this.dp.get('id') + '_yearSelect'});
var years = new Array();
if (this.options.yearOrder == 'desc'){
for (var y = this.options.yearStart; y > (this.options.yearStart - this.options.yearRange - 1); y--){
years.include(y);
}
} else {
for (var y = this.options.yearStart; y < (this.options.yearStart + this.options.yearRange + 1); y++){
years.include(y);
}
}
years.each(function(y,i){
yearSel.options[i] = new Element('option',{value: y});
yearSel.options[i].set('text',y);
if (this.year == y) yearSel.options[i].set('selected','selected');
}.bind(this));
/* start creating calendar */
calTable = new Element('table');
calTableThead = new Element('thead');
calSelRow = new Element('tr');
calSelCell = new Element('th', {'colspan':'7'});
monthSel.injectInside(calSelCell);
yearSel.injectInside(calSelCell);
calSelCell.injectInside(calSelRow);
calSelRow.injectInside(calTableThead);
calTableTbody = new Element('tbody');
/* create day names */
calDayNameRow = new Element('tr');
for (var i = 0; i < this.options.dayNames.length; i++) {
calDayNameCell = new Element('th');
calDayNameCell.appendText(this.options.dayNames[(this.options.startDay+i)%7].substr(0, this.options.dayChars));
calDayNameCell.injectInside(calDayNameRow);
}
calDayNameRow.injectInside(calTableTbody);
/* create the day cells */
while (firstDay <= this.options.daysInMonth[this.month]){
calDayRow = new Element('tr');
for (i = 0; i < 7; i++){
if ((firstDay <= this.options.daysInMonth[this.month]) && (firstDay > 0)){
calDayCell = new Element('td', {'class':this.dp.get('id') + '_calDay', 'axis':this.year + '|' + (parseInt(this.month) + 1) + '|' + firstDay}).appendText(firstDay).injectInside(calDayRow);
} else {
calDayCell = new Element('td', {'class':'dp_empty'}).appendText(' ').injectInside(calDayRow);
}
// Show the previous day
if ( (firstDay == this.oldDay) && (this.month == this.oldMonth ) && (this.year == this.oldYear) ) {
calDayCell.addClass('dp_selected');
}
// Show today
if ( (firstDay == this.nowDay) && (this.month == this.nowMonth ) && (this.year == this.nowYear) ) {
calDayCell.addClass('dp_today');
}
firstDay++;
}
calDayRow.injectInside(calTableTbody);
}
/* table into the calendar div */
calTableThead.injectInside(calTable);
calTableTbody.injectInside(calTable);
calTable.injectInside(this.calendar);
if (fade) {
this.container.fade('in');
}
/* set the onmouseover events for all calendar days */
$$('td.' + this.dp.get('id') + '_calDay').each(function(el){
el.addEvents({
'mouseover': function(){
el.addClass('dp_roll');
},
'mouseout': function(){
el.removeClass('dp_roll');
},
'click': function(){
ds = el.axis.split('|');
this.dp.value = this.formatValue(ds[0], ds[1], ds[2]);
this.remove();
}.bind(this)
});
}.bind(this));
/* set the onchange event for the month & year select boxes */
[monthSel,yearSel].each(function(elmt){
elmt.addEvents({
'focus': function(){
this.active = true;
}.bind(this),
'change': function(){
this.month = monthSel.value;
this.year = yearSel.value;
this.remove(false);
this.create(false);
this.active = false;
this.dp.focus();
}.bind(this)
});
}.bind(this));
this.dp.addEvent('blur',function(){
(function(){
if (!this.active) {
this.remove();
}
}.bind(this)).delay(500);
}.bind(this))
},
/* Format the returning date value according to the selected formation */
formatValue: function(year, month, day){
/* setup the date string variable */
var dateStr = '';
/* check the length of day */
if (day < 10) day = '0' + day;
if (month < 10) month = '0' + month;
/* check the format & replace parts // thanks O'Rey */
dateStr = this.options.format.replace( /dd/i, day ).replace( /mm/i, month ).replace( /yyyy/i, year );
this.month = this.oldMonth = '' + (month - 1) + '';
this.year = this.oldYear = year;
this.oldDay = day;
/* return the date string value */
return dateStr;
},
/* Remove the calendar from the page */
remove: function(fade){
fade = ($type(fade) == 'boolean') ? fade : true;
if(Browser.Engine.trident && Browser.Engine.version <= 5){
fade = false;
}
if ($type(this.container) == 'element') {
if (fade != false) {
this.container.fade('out');
}else{
this.container.dispose();
}
}
this.active = this.container = this.calendar = false;
$$('select.dp_hide').removeClass('dp_hide');
}
});
Element.implement({
DatePicker: function (options){
new DatePicker(this,options);
return this;
}
});