/*
---------------------------------------------------------------------------------------------------

script: Tips.js

description: Class for creating nice tips that follow the mouse cursor when hovering an element.
             Based on More 1.2.4.4.
             Modified by Cinq design Office 2010/08/24

license: MIT-style license

authors:
- Valerio Proietti
- Christoph Pojer

requires:
- core:1.2.4/Options
- core:1.2.4/Events
- core:1.2.4/Element.Event
- core:1.2.4/Element.Style
- core:1.2.4/Element.Dimensions
- /MooTools.More

provides: [Tips]

...
*/

(function(){

var read = function(option, element){
	return (option) ? ($type(option) == 'function' ? option(element) : element.get(option)) : '';
};

this.Tips = new Class({

	Implements: [Events, Options],

	options: {
		/*
		onAttach: $empty(element),
		onDetach: $empty(element),
		*/
		onShow: function(){
			this.tip.setStyle('display', 'block');
		},
		onHide: function(){
			this.tip.setStyle('display', 'none');
		},
		title: 'title',
		text: function(element){
			return element.get('rel') || element.get('href');
		},
		showDelay: 100,
		hideDelay: 100,
		className: 'tip-wrap',
		offset: {x: 16, y: 16},
		windowPadding: {x:0, y:0},
		fixed: false
	},

	initialize: function(){
		var params = Array.link(arguments, {options: Object.type, elements: $defined});
		this.setOptions(params.options);
		if (params.elements) this.attach(params.elements);
		this.container = new Element('div', {'class': 'tip'});
	},

	toElement: function(){
		if (this.tip) return this.tip;

		return this.tip = new Element('div', {
			'class': this.options.className,
			styles: {
				position: 'absolute',
				top: 0,
				left: 0
			}
		}).adopt(
			new Element('div', {'class': 'tip-top'}),
			this.container,
			new Element('div', {'class': 'tip-bottom'})
		).inject(document.body);
	},

	attach: function(elements){
		$$(elements).each(function(element){
			var title = read(this.options.title, element),
				text = read(this.options.text, element);
			
			element.erase('title').store('tip:native', title).retrieve('tip:title', title);
			element.retrieve('tip:text', text);
			this.fireEvent('attach', [element]);
			
			var events = ['enter', 'leave'];
			if (!this.options.fixed) events.push('move');
			
			events.each(function(value){
				var event = element.retrieve('tip:' + value);
				if (!event) event = this['element' + value.capitalize()].bindWithEvent(this, element);
				
				element.store('tip:' + value, event).addEvent('mouse' + value, event);
			}, this);
		}, this);
		
		return this;
	},

	detach: function(elements){
		$$(elements).each(function(element){
			['enter', 'leave', 'move'].each(function(value){
				element.removeEvent('mouse' + value, element.retrieve('tip:' + value)).eliminate('tip:' + value);
			});
			
			this.fireEvent('detach', [element]);
			
			if (this.options.title == 'title'){ // This is necessary to check if we can revert the title
				var original = element.retrieve('tip:native');
				if (original) element.set('title', original);
			}
		}, this);
		
		return this;
	},

	elementEnter: function(event, element){
		this.container.empty();
		
		['title', 'text'].each(function(value){
			var content = element.retrieve('tip:' + value);
			if (content) this.fill(new Element('div', {'class': 'tip-' + value}).inject(this.container), content);
		}, this);
		
		$clear(this.timer);
		this.timer = (function(){
			this.show.run([element], this);
			this.position((this.options.fixed) ? {page: element.getPosition()} : event);
		}).delay(this.options.showDelay, this);
	},

	elementLeave: function(event, element){
		$clear(this.timer);
		this.timer = (function() { this.hide.run([element],this); }.bind(this)).delay(this.options.hideDelay);
		this.fireForParent(event, element);
	},

	fireForParent: function(event, element){
		element = element.getParent();
		if (!element || element == document.body) return;
		if (element.retrieve('tip:enter')) element.fireEvent('mouseenter', event);
		else this.fireForParent(event, element);
	},

	elementMove: function(event, element){
		this.position(event);
	},

	position: function(event){
		if (!this.tip) document.id(this);

        this.tip.removeClass('tip-overflow');
        
		var size = window.getSize(), scroll = window.getScroll(),
			tip = {x: this.tip.offsetWidth, y: this.tip.offsetHeight},
			props = {x: 'left', y: 'top'},
			obj = {};
		
		for (var z in props){
			obj[props[z]] = event.page[z] + this.options.offset[z];
			if ((obj[props[z]] + tip[z] - scroll[z]) > size[z] - this.options.windowPadding[z]) {
                obj[props[z]] = event.page[z] - this.options.offset[z] - tip[z];
                this.tip.addClass('tip-overflow');
            }
		}
		
		this.tip.setStyles(obj);
	},

	fill: function(element, contents){
		if(typeof contents == 'string') element.set('html', contents);
		else element.adopt(contents);
	},

	show: function(element){
		if (!this.tip) document.id(this);
		this.fireEvent('show', [this.tip, element]);
	},

	hide: function(element){
		if (!this.tip) document.id(this);
		this.fireEvent('hide', [this.tip, element]);
	}

});

})();
/*
---------------------------------------------------------------------------------------------------
*/



/* 
    Fade In Class Effect 1.0.1
*/
var FadeInClassEffect = new Class({
    Implements: Options,
    options: {
        duration: 400,
        transition: 'expo:out',
        fadeInClassName: 'fade-in'
    },
    initialize: function(options) {
        this.setOptions(options);
                
        $$('.' + this.options.fadeInClassName).each(function(element) {
            element.setStyle('opacity', 0);
            element.getParent().addEvents({
                mouseenter: function() {
                    element.get('tween', {
                        property: 'opacity',
                        duration: this.options.duration,
                        transition: this.options.transition,
                        link: 'cancel'
                    }).start(1);
                }.bind(this),
                
                mouseleave: function() {
                    element.get('tween', {
                        property: 'opacity',
                        duration: this.options.duration,
                        transition: this.options.transition,
                        link: 'cancel'
                    }).start(0);
                }.bind(this)
            });
        }.bind(this));
        
    }
});

/*
    Fixed Grobal Navigation 1.0.0
*/
var FixedGrobalNav = new Class({
    Implements: Options,
    resizeTimer: null,
    scrollTimer: null,
    options: {
        wrapperIdName: 'wrapper',
        baseIdName: 'global-nav',
        fixedIdName: 'fixed-global-nav',
        duration: 200,
        transition: 'sine:in:out',
        opacity: 0.9
    },
    initialize: function(options) {
        this.setOptions(options);
        
        if (Browser.Engine.trident && Browser.Engine.version < 5) {
            $(this.options.fixedIdName).setStyle('display', 'none');
            return;
        }
        
        var fixedElement = $(this.options.fixedIdName);
        if ($defined(fixedElement) == false) {
            return;
        }
        
        fixedElement.store('defaultDisplay', fixedElement.getStyle('display'));
        fixedElement.addEvents({
            mouseenter: function() {
                fixedElement.get('tween', {
                    property: 'opacity',
                    duration: this.options.duration,
                    transition: this.options.transition,
                    link: 'chain'
                }).start(1);
            }.bind(this),
            
            mouseleave: function() {
                fixedElement.get('tween', {
                    property: 'opacity',
                    duration: this.options.duration,
                    transition: this.options.transition,
                    link: 'chain'
                }).start(this.options.opacity);
            }.bind(this)
        });
        fixedElement.setStyles({
            position: 'fixed',
            display: 'none',
            top: 0,
            opacity: this.options.opacity,
            'z-index': 99999999
        });
        
        this.toggle.run([], this);
        
        window.addEvents({
            scroll: function() {
                $clear(this.scrollTimer);
                this.scrollTimer = (function() {
                    this.toggle.run([], this);
                }.bind(this)).delay(200);
            }.bind(this),
            
            resize: function() {
                $clear(this.resizeTimer);
                this.resizeTimer = (function() {
                    this.toggle.run([], this);
                }.bind(this)).delay(200);
            }.bind(this)
        });
    },
    
    toggle: function() {
        var baseBottom = $(this.options.baseIdName).getCoordinates().bottom;
        var fixedElement = $(this.options.fixedIdName);
        fixedElement.setStyle('width', $(this.options.wrapperIdName).getComputedSize().totalWidth);
        
        if (window.getScroll().y > baseBottom) {
            if (fixedElement.getStyle('display') == 'none') {
                fixedElement.setStyle('display', fixedElement.retrieve('defaultDisplay'));
            }
            fixedElement.get('tween', {
                property: 'opacity',
                duration: this.options.duration,
                transition: this.options.transition,
                link: 'chain'
            }).start(this.options.opacity);
        } else {
            fixedElement.get('tween', {
                property: 'opacity',
                duration: this.options.duration,
                transition: this.options.transition,
                link: 'chain',
                onComplete: function() {
                    fixedElement.setStyle('display', 'none');
                }
            }).start(0);
        }
    }
});

/*
    Fixed Sidebar 1.0.0
*/
var FixedSidebar = new Class({
    Implements: Options,
    resizeTimer: null,
    scrollTimer: null,
    options: {
        wrapperIdName: null,
        sidebarIdName: 'sidebar',
        offsetX: 0,
        offsetY: 0,
        duration: 800,
        transition: 'expo:in:out'
    },
    initialize: function(options) {
        this.setOptions(options);
        
        var sidebar = $(this.options.sidebarIdName);
        if ($defined(sidebar) == false) {
            return;
        }
        
        sidebar.store('defaultTop', sidebar.getCoordinates().top);
        sidebar.store('defaultMarginTop', sidebar.getStyle('margin-top').toInt());
        
        this.adjust.run([], this);
        
        window.addEvents({
            scroll: function() {
                $clear(this.scrollTimer);
                this.scrollTimer = (function() {
                    this.adjust.run([], this);
                }.bind(this)).delay(600);
            }.bind(this),
            
            resize: function() {
                $clear(this.resizeTimer);
                this.resizeTimer = (function() {
                    this.adjust.run([], this);
                }.bind(this)).delay(200);
            }.bind(this)
        });
    },
    
    adjust: function() {
        var sidebar = $(this.options.sidebarIdName);
        var sidebarTop = sidebar.getCoordinates().top;
        var sidebarBottom = sidebar.getCoordinates().bottom;
        var top = window.getScrollTop();
        var bottom = top + window.getHeight();
        
        if (top - sidebarTop < 0 || top > sidebarBottom) {
            var posTop = top - sidebar.retrieve('defaultTop');
            if (posTop < 0) { 
                posTop = sidebar.retrieve('defaultMarginTop');
            } else {
                posTop += this.options.offsetX;
            }
            sidebar.get('tween', {
                property: 'margin-top',
                duration: this.options.duration,
                transition: this.options.transition,
                link: 'chain'
            }).start(posTop);
        }
    }
});

/*
    Slide Show 1.2.1
*/
var SlideShow = new Class({
	Implements: [Options,Events],
    slideElements: null,
    loadCount: 0,
    animationType: {
        fade: 0,
        slide: 1,
        hSlide: 2
    },
    options: {
        slideClassName: 'slide',
        slideAutoRotateClassName: 'slide-auto-rotate',
        slideAnimationType: 0,
        periodical: 5000,
        slideDuration: 500,
        slideTransition: 'expo:out',
        imgDuration: 500,
        imgTransition: 'expo:out',
        withThumbnail: true,
        imgDelay: 100,
        thumbDelay: 100,
		onComplete: $empty,
		onImgSizeChange: $empty
    },
    initialize: function(options) {
        this.setOptions(options);
    },
    
    run: function() {
        this.slideElements = $$('.' + this.options.slideClassName);

        if ($defined(this.slideElements)) {
            if (this.slideElements.length > 0) {
                this.slideElements.each(function(slide) {
                    var slideWrapper = new Element('div', { 'class': this.options.slideClassName + '-wrapper' });
                    slideWrapper.addClass('slide-wrapper');
                    slideWrapper.wraps(slide);
                    slide.store('slideWrapper', slideWrapper);
                    this.load.run([slide], this);
                }.bind(this));
            } else {
                this.fireEvent('complete');
            }
        }
    },
    
    load: function(self) {
        var slideWrapper = self.retrieve('slideWrapper');
        var imgs = self.getElements('img');
        
        if (imgs.length == 0) {
            this.checkLoadComplete.run([], this);
            return;
        } else {
            self.store('curImage', imgs[0])
        }
        
        if (imgs.length > 1 && self.hasClass(this.options.slideAutoRotateClassName)) {
            self.addEvents({
                mouseenter: function() {
                    this.stopRotate.run([self], this);
                }.bind(this),
                mouseleave: function() {
                    this.startRotate.run([self], this);
                }.bind(this)
            });
        }
        
        slideWrapper.setStyles({
            position: 'relative',
            overflow: 'hidden'
        });
        self.setStyles({
            position: 'relative',
            overflow: 'hidden',
            left: 0
        });
        
        this.setSlideSize(self, imgs);
                
        var thumbArea = null;
        if (imgs.length > 1) {
            thumbArea = new Element('div', { 'class': this.options.slideClassName + '-thumb-area' });
            thumbArea.addClass('slide-thumb-area');
            thumbArea.inject(slideWrapper, 'after');
        }
        
        var thumbItems = new Array();
        var srcs = new Array();
        imgs.each(function(img, imgIndex) {
            
            img.setStyle('opacity', 0);
        
            var thumbItem = null;
            if (imgs.length > 1) {
                thumbItem = new Element('span', {
                    'class': this.options.slideClassName + '-thumb-item',
                    styles: { opacity: 0 },
                    events: {
                        click: function() { 
                            this.rotate.run([self, img], this);
                        }.bind(this)
                    }
                });
                thumbItem.addClass('slide-thumb-item');
                if (imgIndex == 0) {
                    thumbItem.addClass('slide-thumb-item-focused');
                }
                
                if (self.hasClass(this.options.slideAutoRotateClassName)) {
                    thumbItem.addEvents({
                        mouseenter: function() {
                            this.stopRotate.run([self], this);
                        }.bind(this),
                        mouseleave: function() {
                            this.startRotate.run([self], this);
                        }.bind(this)
                    });
                }
                if (this.options.withThumbnail) {
                    var thumbImage = img.clone();
                    thumbImage.setStyle('opacity', 1)
                    thumbItem.grab(thumbImage);
                } else {
                    var thumbNo = new Element('span', { 
                        'class': this.options.slideClassName + '-thumb-no',
                        text: imgIndex + 1 
                    });
                    thumbNo.addClass('slide-thumb-no');
                    thumbItem.grab(thumbNo);
                }
                thumbItem.inject(thumbArea, 'bottom');
                thumbItems.push(thumbItem);
            }
            
            srcs.push(img.getProperty('src'));            
        }.bind(this));
        
        var myImages = new Asset.images(srcs, {
            onProgress: function(counter, index) {
                if (imgs.length > 1) {
                    (function() { thumbItems[index].tween('opacity', 1); }).delay(this.options.thumbDelay * index);
                    
                    var img = imgs[index];
                    imgWidth = img.getSize().x;
                    imgHeight = img.getSize().y;            
                
                    var nextLink = new Element('span', {
                        'class': this.options.slideClassName + '-next',
                        styles: { 
                            position: 'absolute',
                            'z-index': imgs.length,
                            width: imgWidth / 2,
                            height: imgHeight,
                            right: 0
                        },
                        events: {
                            click: function() {
                                this.next.run([self, img], this);
                            }.bind(this)
                        }
                    });
                    nextLink.addClass('slide-next');
                    var prevLink = new Element('span', {
                        'class': this.options.slideClassName + '-prev',
                        styles: { 
                            position: 'absolute',
                            'z-index': imgs.length,
                            width: imgWidth / 2,
                            height: imgHeight,
                            left: 0
                        },
                        events: {
                            click: function() {
                                this.prev.run([self, img], this);
                            }.bind(this)
                        }
                    });
                    prevLink.addClass('slide-prev');
                    var imgWrapper = new Element('span', { 
                        'class': 'img-wrapper',
                        styles: { 
                            position: 'relative',
                            float: 'left',
                            'z-index': index
                        }
                    });
                    imgWrapper.wraps(img);
                    imgWrapper.adopt(prevLink);
                    imgWrapper.adopt(nextLink);
                    img.store('imgWrapper', imgWrapper);
                }
                
                (function() {
                    imgs[index].get('tween', {
                        property: 'opacity',
                        duration: this.options.imgDuration,
                        transition: this.options.imgTransition,
                        link: 'cancel'
                    }).start(1);
                }.bind(this)).delay(this.options.imgDelay * index);
            }.bind(this),
            onComplete: function(){
                if ($defined(thumbArea)) {
                    if (this.options.slideAnimationType == this.animationType.hSlide) {
                        thumbArea.setStyle('width', '100%');
                    } else {
                        thumbArea.setStyle('width', slideWrapper.getSize().x);
                    }
                }
                if (imgs.length > 1) {
                    if (self.hasClass(this.options.slideAutoRotateClassName)) {
                        this.startRotate.run([self], this);
                    }
                    this.setSlideSize(self, imgs);
                } else {
                    self.setStyles({
                        width: imgs[0].getSize().x,
                        height: imgs[0].getSize().y
                    });
                    imgs[0].setStyle('opacity', 1);
                    this.checkLoadComplete.run([], this);
                }
            }.bind(this)
        });
        
        if (imgs.length > 1) {
            self.store('thumbItems', thumbItems);
            self.store('thumbArea', thumbArea);
        }
    },
    
    rotate: function(self, target) {
        var imgs = self.getElements('img');
        var curImage = self.retrieve('curImage');
        var fireImgSizeChangeEvent = false;

        if (imgs.length > 1) {
            
            if ($defined(target)) {
                if (target == curImage) {
                    return;
                }
            } else {
                target = curImage;
            }

            var targetIndex = 0;
            for (var i = 0; i < imgs.length; i++) {
                if (imgs[i] == target) {
                    self.retrieve('thumbItems')[i].addClass('slide-thumb-item-focused');
                } else if (imgs[i] == curImage) {
                    self.retrieve('thumbItems')[i].removeClass('slide-thumb-item-focused');
                }
            }
            
            var imgWidth = target.getSize().x;
            var imgHeight = target.getSize().y;
            if (
                imgWidth != curImage.getSize().x || 
                imgHeight != curImage.getSize().y
            ) {
                fireImgSizeChangeEvent = true;
            }

            if (this.options.slideAnimationType == this.animationType.fade) {
                target.setStyle('opacity', 0);
                self.setStyles({
                    width: imgWidth,
                    height: imgHeight
                });
                var zIndex = target.retrieve('imgWrapper').getStyle('z-index').toInt();
                var curZIndex = curImage.retrieve('imgWrapper').getStyle('z-index').toInt();
                if (zIndex < curZIndex) {
                    target.retrieve('imgWrapper').setStyle('z-index', curZIndex + 1);
                }
                target.retrieve('imgWrapper').setStyles({
                    position: 'absolute',
                    top: curImage.getCoordinates(self).top,
                    left: curImage.getCoordinates(self).left
                });
                target.get('tween', {
                    property: 'opacity',
                    duration: this.options.imgDuration,
                    transition: this.options.imgTransition,
                    link: 'cancel'
                }).start(1);
                
            } else if (
                this.options.slideAnimationType == this.animationType.slide ||
                this.options.slideAnimationType == this.animationType.hSlide
            ) {
                self.get('tween', {
                    property: 'left',
                    duration: this.options.slideDuration,
                    transition: this.options.slideTransition,
                    link: 'cancel'
                }).start(- target.getCoordinates(self).left);
            }
            
            var slideDuration = this.options.slideDuration;
            var slideWrapper = self.retrieve('slideWrapper');
            if (imgWidth == slideWrapper.getSize().x && imgHeight == slideWrapper.getSize().y) {
                slideDuration = 0;
            }
            
            if (
                this.options.slideAnimationType == this.animationType.fade ||
                this.options.slideAnimationType == this.animationType.slide
            ) {
                self.retrieve('thumbArea').get('tween', {
                    property: 'width',
                    duration: slideDuration,
                    transition: this.options.slideTransition,
                    link: 'chain'
                }).start(slideWrapper.getSize().x);
                slideWrapper.get('morph', {
                    duration: slideDuration,
                    transition: this.options.slideTransition,
                    link: 'chain',
                    onComplete: function() {
                        if (fireImgSizeChangeEvent) {
                            this.fireEvent('imgSizeChange');
                        }
                    }.bind(this)
                }).start({
                    width: imgWidth,
                    height: imgHeight
                });
            } else if (this.options.slideAnimationType == this.animationType.hSlide) {
                if (fireImgSizeChangeEvent) {
                    this.fireEvent('imgSizeChange');
                }
            }
            self.store('curImage', target);
        }    
    },
    
    next: function(self, img) {
        var imgs = self.getElements('img');
        var curImage = img || self.retrieve('curImage');
        var target = imgs[0];
        if ($defined(img) == false || img == self.retrieve('curImage')) {
            for (var i = 0; i < imgs.length; i++) {
                if (imgs[i] == curImage) {
                    if (imgs.length == i + 1) {
                        target = imgs[0];
                    } else {
                        target = imgs[i + 1];
                    }
                    break;
                }
            }
        } else {
            target = img;
        
        }
        this.rotate.run([self, target], this);
    },
    
    prev: function(self, img) {
        var imgs = self.getElements('img');
        var curImage = img || self.retrieve('curImage');
        var target = imgs[0];
        if ($defined(img) == false || img == self.retrieve('curImage')) {
            for (var i = 0; i < imgs.length; i++) {
                if (imgs[i] == curImage) {
                    if (i == 0) {
                        target = imgs.getLast();
                    } else {
                        target = imgs[i - 1];
                    }
                    break;
                }
            }
        } else {
            target = img;
        
        }
        this.rotate.run([self, target], this);
    },
    
    startRotate: function(self) {
        if ($defined(self.retrieve('timer')) == false) {
            var timer = (function() {
                this.next.run([self], this);
            }.bind(this)).periodical(this.options.periodical);
            self.store('timer', timer);
        }
    },
    
    stopRotate: function(self) {
        if ($defined(self.retrieve('timer'))) {
            $clear(self.retrieve('timer'));
            self.store('timer', null)
        }
    },
    
    checkLoadComplete: function() {
        this.loadCount++;
        if (this.loadCount == this.slideElements.length) {
            this.fireEvent('complete');
        }
    },
    
    setSlideSize: function(self, imgs) {
        var slideWrapper = self.retrieve('slideWrapper');
        var totalWidth = 0;
        var minHeight = 0;
        var maxHeight = 0;
        imgs.each(function(img, index) {
            totalWidth += img.getProperty('width').toInt() || img.getSize().x;
            maxHeight = Math.max(maxHeight, img.getProperty('height').toInt() || img.getSize().y);
            if (minHeight == 0) {
                minHeight = img.getProperty('height').toInt();
            } else {
                minHeight = Math.min(minHeight, img.getProperty('height').toInt() || img.getSize().y);
            }
        }.bind(this));
        
        if (this.options.slideAnimationType == this.animationType.fade) {
            self.setStyles({
                width: imgs[0].getProperty('width').toInt() || imgs[0].getSize().x,
                height: imgs[0].getProperty('height').toInt() || imgs[0].getSize().y
            });
            slideWrapper.setStyles({
                width: self.getSize().x,
                height: self.getSize().y
            });
        } else if(this.options.slideAnimationType == this.animationType.slide) {
            self.setStyles({
                width: totalWidth,
                height: maxHeight
            });
            slideWrapper.setStyles({
                width: imgs[0].getProperty('width').toInt() || imgs[0].getSize().x,
                height: imgs[0].getProperty('height').toInt() || imgs[0].getSize().y
            });
        } else if (this.options.slideAnimationType == this.animationType.hSlide) {
            self.setStyles({
                width: totalWidth,
                height: maxHeight
            });
            slideWrapper.setStyles({
                height: maxHeight
            });
        }
    }
    
});

/*
    ToolTips 1.0.0
*/
var ToolTips = new Class({
	Implements: [Options,Events],
    options: {
        tipDuration: 250,
        tipTransition: 'expo:out',
        tipOpacity: 0.9,
        tipMinWidth: 50,
        triangleLeft: 10,
        triangleWidth: 5,
        triangleHeight: 5,
        attachTipClassNames: []
    },
    initialize: function(options) {
        this.setOptions(options);
        
        this.options.attachTipClassNames.push('attach-tip');
        
        // Clear Anchor Title
        $$('a').each(function(a) {
            var classString = a.getProperty('class');
            var clearTitle = true;
            this.options.attachTipClassNames.each(function(attachTipClassName) {
                if (classString.contains(attachTipClassName)) {
                    clearTitle = false;
                }
            }.bind(this));
            if (clearTitle) {
                a.setProperty('title', '');
            }
        }.bind(this));
        
        var attachSelectors = new Array();
        this.options.attachTipClassNames.each(function(attachTipClassName) {
            attachSelectors.push('[class*=' + attachTipClassName + ']');
        }.bind(this));
        
        var tips = new Tips(attachSelectors, {
            showDelay: 0,
            hideDelay: 0,
            offset: {x: 0, y: 0},
            fixed: true
        });
        
        tips.addEvent('show', function(tip, el){
            tip.addClass('tip-animation');
            tip.setStyle('width', 'auto');
            var marginTop = el.getStyle('padding-top').toInt() - (tip.getComputedSize().totalHeight + this.options.triangleHeight * 2);
            tip.setStyles({
                width: Math.max(tip.getSize().x, this.options.tipMinWidth),
                'margin-top': marginTop + this.options.triangleHeight,
                'margin-left': el.getStyle('padding-left').toInt() - (this.options.triangleLeft + this.options.triangleWidth * 2),
                opacity: 0,
                'z-index': 999999
            });
            tip.get('morph', {
                duration: this.options.tipDuration,
                transition: this.options.tipTransition
            }).start({
                'margin-top': marginTop,
                opacity: this.options.tipOpacity
            });
        }.bind(this));
        
        tips.addEvent('hide', function(tip, el){
            tip.removeClass('tip-animation');
        }.bind(this));
        
    }
    
});