/*
    Common Util 1.3.10
    
    Copyright (c) 2010 STRAIGHTLINE<http://www.straightline.jp/> All rights reserved.
*/

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

Cross browser 'readyState'

*/
if (!('readyState' in document)) {
    document.readyState = 'loading';
    window.addEventListener(
        'DOMContentLoaded',
        function listener() {
            document.readyState = 'interactive';
            this.removeEventListener('DOMContentLoaded', listener, false);
        },
        false
    );
    window.addEventListener(
        'load',
        function listener() {
            document.readyState = 'complete';
            this.removeEventListener('load', listener, false);
        },
        false
    );
}

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

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 STRAIGHTLINE. 2010/05/12

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]);
	}

});

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

/*
---------------------------------------------------------------------------------------------------
description: A Class that provides a cross-browser history-management functionaility, using the browser hash to store the application's state
             Based on Hash Listener.
             Modified by STRAIGHTLINE. 2010/06/27

license: MIT-style

authors:
- Arieh Glazer
- Dave De Vos
- Digitarald

requires:
- core/1.2.4: [Class,Class.Extras,Element]

provides: [HashListener]

...
*/
$extend(Element.NativeEvents, {
	hashchange: 1
});

var HashListener = new Class({
	Implements : [Options,Events],
	options : {
		start : false
	},
	currentLocation : '',
	firstLoad : true,
	handle : false,
	ignoreLocationChange : false,
	initialize : function(options){
		var $this=this;
			
		this.setOptions(options);
		
		// Disable Opera's fast back/forward navigation mode
		if (Browser.Engine.presto && window.history.navigationMode) {
			window.history.navigationMode = 'compatible';
		}
		
		 // IE8 in IE7 mode defines window.onhashchange, but never fires it...
        if (
			('onhashchange' in window) &&
            (typeof(document.documentMode) == 'undefined' || document.documentMode > 7)
		   ){
				// The HTML5 way of handling DHTML history...
				window.addEvent('hashchange' , function () {
					var hash = $this.getHash();
					if (hash == $this.currentLocation) {
						return;
					}
					$this.fireEvent('hashChanged',hash);
					$this.fireEvent('hash-changed',hash);
				});;
        }
		
		window.addEvent('unload', function(event) {
			$this.firstLoad = null;
		});
		
		if (this.options.start) this.start();
	},
	checkHash : function(){
		var hash = this.getHash(), ie_state, doc;
		if (this.ignoreLocationChange) {
			this.ignoreLocationChange = false;
			return;
		}

		if (this.currentLocation == hash) {
			return;
		}
		
		this.currentLocation = hash;
		
		this.fireEvent('hashChanged',hash);
		this.fireEvent('hash-changed',hash);
	},
	setHash : function(newHash){
		window.location.hash = this.currentLocation = newHash;
		
		if (
			('onhashchange' in window) &&
            (typeof(document.documentMode) == 'undefined' || document.documentMode > 7)
		   ) return;
		
		this.fireEvent('hashChanged',newHash);
		this.fireEvent('hash-changed',newHash);
	},
	getHash : function(){
		var m;
		if (Browser.Engine.gecko){
			m = /#(.*)$/.exec(window.location.href);
			return m && m[1] ? m[1] : '';
		}else if (Browser.Engine.webkit){
			return decodeURI(window.location.hash.substr(1));
		}else{
			return window.location.hash.substr(1);
		}
	},
	updateHash : function (newHash){
		if ($type(document.id(newHash))) {
			this.debug_msg(
				"Exception: History locations can not have the same value as _any_ IDs that might be in the document,"
				+ " due to a bug in IE; please ask the developer to choose a history location that does not match any HTML"
				+ " IDs in this document. The following ID is already taken and cannot be a location: "
				+ newLocation
			);
		}
		
		this.ignoreLocationChange = true;
		
		this.setHash(newHash);
	},
	start : function(){
		this.handle = this.checkHash.periodical(100, this);
	},
	stop : function(){
		$clear(this.handle);
	}
});
/*
---------------------------------------------------------------------------------------------------
*/

/* 
    Anchor Effect 1.0.5
*/
var AnchorEffect = new Class({
    Implements: Options,
    options: {
        ajaxLoaderSrc: 'ajax-loader.gif',
        isFadeOutJump: false,
        enterDuration: 300,
        enterTransition: 'expo:out',
        leaveDuration: 300,
        leaveTransition: 'expo:out',
        color: '#bbb',
        imgOpacity: 0.7
    },
    initialize: function(options) {
        this.setOptions(options);
        
        if (Browser.Engine.trident && Browser.Engine.version < 5) {
            return;
        }
        $$('a').each(function(a) {

            a.store('defaultColor', a.getStyle('color'));
            
            if (this.options.isFadeOutJump && a.getProperty('href').contains('#') == false) {
                a.addEvent('click', function(event) {
                    event.stop();
                    
                    if ($('ajax-loader')) {
                        $('ajax-loader').setStyle('opacity', 1);
                    }
                    var overlay = new Element('div', {
                        styles: {
                            position: 'absolute',
                            top: 0,
                            left: 0,
                            width: window.getScrollSize().x,
                            height: window.getScrollSize().y,
                            'background-color': $(document.body).getStyle('background-color'),
                            'z-index': 99999,
                            opacity: 0
                        }
                    });
                    $(document.body).adopt(overlay);
                    overlay.set('tween', {
                        duration: 'short',
                        onComplete: function() {
                            location.href = a.getProperty('href');
                        }
                    });
                    overlay.tween('opacity', 1);
                }.bind(this));
            }
            
            a.addEvents({
                mouseenter: function() {
                    a.get('tween', {
                        property: 'color',
                        duration: this.options.enterDuration,
                        transition: this.options.enterTransition,
                        link: 'cancel'
                    }).start(this.options.color);
                    if (!Browser.Engine.trident) {
                        a.getElements('img').each(function(img) {
                            img.get('tween', {
                                property: 'opacity',
                                duration: this.options.enterDuration,
                                transition: this.options.enterTransition,
                                link: 'cancel'
                            }).start(this.options.imgOpacity);
                        }.bind(this));
                    }
                }.bind(this),
                
                mouseleave: function() {
                    a.get('tween', {
                        property: 'color',
                        duration: this.options.leaveDuration,
                        transition: this.options.leaveTransition,
                        link: 'cancel'
                    }).start(a.retrieve('defaultColor'));
                    if (!Browser.Engine.trident) {
                        a.getElements('img').each(function(img) {
                            img.get('tween', {
                                property: 'opacity',
                                duration: this.options.leaveDuration,
                                transition: this.options.leaveTransition,
                                link: 'cancel'
                            }).start(1);
                        }.bind(this));
                    }
                }.bind(this)
            });
        }.bind(this));
        
        new Fx.SmoothScroll({
            links: $$('a[href^=#]:not([href=#])'),
            wheelStops: false,
            duration: 'long',
            transition: 'expo:out'
        });
        
    }
});

/* 
    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.1
*/
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;
        }
        
        var fixedWrapper = new Element('div', {
            id: 'fixed-global-nav-wrapper',
            styles: {
                position: 'fixed',
                display: 'none',
                top: 0,
                opacity: this.options.opacity,
                'z-index': 99999
            }
        });
        fixedWrapper.wraps(fixedElement);
        fixedElement.setStyle('display', 'block');
        fixedWrapper.store('defaultDisplay', fixedWrapper.getStyle('display'));
        fixedWrapper.addEvents({
            mouseenter: function() {
                fixedWrapper.get('tween', {
                    property: 'opacity',
                    duration: this.options.duration,
                    transition: this.options.transition,
                    link: 'chain'
                }).start(1);
            }.bind(this),
            
            mouseleave: function() {
                fixedWrapper.get('tween', {
                    property: 'opacity',
                    duration: this.options.duration,
                    transition: this.options.transition,
                    link: 'chain'
                }).start(this.options.opacity);
            }.bind(this)
        });
        
        
        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 fixedWrapper = $('fixed-global-nav-wrapper');
        fixedWrapper.setStyle('width', $(this.options.wrapperIdName).getComputedSize().totalWidth);
        
        if (window.getScroll().y > baseBottom) {
            if (fixedWrapper.getStyle('display') == 'none') {
                fixedWrapper.setStyle('display', 'block');
            }
            fixedWrapper.get('tween', {
                property: 'opacity',
                duration: this.options.duration,
                transition: this.options.transition,
                link: 'chain'
            }).start(this.options.opacity);
        } else {
            fixedWrapper.get('tween', {
                property: 'opacity',
                duration: this.options.duration,
                transition: this.options.transition,
                link: 'chain',
                onComplete: function() {
                    fixedWrapper.setStyle('display', 'none');
                }
            }).start(0);
        }
    }
});

/*
    Fixed Sidebar 1.0.1
*/
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);
        
        var scrollDelay = 600;
        if (this.options.duration == 0) {
            scrollDelay = 0;
        }
        window.addEvents({
            scroll: function() {
                $clear(this.scrollTimer);
                this.scrollTimer = (function() {
                    this.adjust.run([], this);
                }.bind(this)).delay(scrollDelay);
            }.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 sidebarCoordinates = sidebar.getCoordinates();
        var sidebarTop = sidebarCoordinates.top;
        var sidebarBottom = sidebarCoordinates.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 2.1.3
*/
var SlideShow = new Class({
	Implements: [Options,Events],
    loadCount: 0,
    slides: null,
    slideProgress: null,
    hashListner: null,
    fireSizeChangeEvent: false,
    animationType: {
        fade: 0,
        slide: 1,
        hSlide: 2
    },
    options: {
        slideClassName: 'slide',
        slideAutoRotateClassName: 'slide-auto-rotate',
        slideAnimationType: 0,
        slideElementClassName: 'slide-content',
        slideImgClassName: 'slide-image',
        slideNavPrefix: 'slide-nav-',
        slideNavElementClassName: 'slide-nav-item',
        slideNavSkipClassName: 'slide-nav-skip',
        slideProgressDuration: 300,
        slideProgressTransition: 'expo:out',
        slideProgressOpacity: 0.7,
        periodical: 5000,
        slideDuration: 500,
        slideTransition: 'expo:out',
        fadeDuration: 500,
        fadeTransition: 'expo:out',
        navDuration: 300,
        navTransition: 'expo:out',
        navOpacity: 0.3,
        rotateAnimation: true,
        withThumbnail: true,
        withHash: true,
        fadeDelay: 100,
        thumbDelay: 100,
		onFirstLoad: $empty,
		onComplete: $empty,
		onRotateComplete: $empty,
		onSizeChange: $empty
    },
    initialize: function(options) {
        this.setOptions(options);
        
        this.slides = $$('.' + this.options.slideClassName);
        this.slides.each(function(slide, index) {
            slide.setStyles({
                'z-index': 1,
                opacity: 0,
                left: 0
            });
        });
        if (this.slides.length > 0) {
            this.slideProgress = $('slide-progress');
            if ($defined(this.slideProgress) == false) {
                this.slideProgress = new Element('div', {
                    id: 'slide-progress',
                    styles: {
                        opacity: 0
                    }
                });
                $(document.body).adopt(this.slideProgress);
            }
        }
    },
    
    run: function() {
        if (this.options.withHash) {
            this.hashListner = new HashListener();
        }
        if (this.slides.length > 0) {
        
            this.slideProgress.store('totalCount', 0);
            this.slideProgress.store('progressCount', 0);
            
            this.slides.each(function(slide, index) {
                slide.addClass('slide');
                
                var slideWrapper = new Element('div', { 
                    'class': this.options.slideClassName + '-wrapper',
                    styles: {
                        'z-index': 1
                    }
                });
                slideWrapper.addClass('slide-wrapper');
                slideWrapper.wraps(slide);
                slide.store('slideWrapper', slideWrapper);
                
                var slideRoot = new Element('div', { 
                    'class': this.options.slideClassName + '-root',
                    styles: { 
                        'z-index': slide.getStyle('z-index').toInt()
                    },
                    events: {
                        click: function(event) { event.stopPropagation(); }
                    }
                });
                slideRoot.addClass('slide-root');
                slideRoot.addClass(this.options.slideClassName + '-' + index);
                if (Browser.Platform.ipod && this.options.slideClassName != 'zoom') {
                    slideRoot.addClass('slide-for-ipod');
                }
                slideRoot.wraps(slideWrapper);
                slide.store('slideRoot', slideRoot);
                
                slide.store('hashId', '/' + (slide.get('id') || this.options.slideClassName + '-' + index));
                slide.store('navId', slide.get('id') || this.options.slideClassName + '-' + index);
                this.load.run([slide], this);
            }.bind(this));
            this.fireEvent('firstLoad');
        } else {
            this.fireEvent('firstLoad');
            this.fireEvent('complete');
        }
    },
    
    showProgress: function() {
        if ($defined($(document.body).retrieve('slideProgressEvent')) == false) {
            var height = this.slideProgress.getComputedSize().totalHeight;
            var offsetX = this.slideProgress.getStyle('padding-left').toInt();
            var offsetY = this.slideProgress.getStyle('padding-top').toInt();
            var x = this.slideProgress.retrieve('x');
            var y = this.slideProgress.retrieve('y');
            if ($defined(x) && $defined(y)) {
                this.slideProgress.setStyles({
                    position: 'absolute',
                    top: y - height - offsetY,
                    left: x + offsetX
                });
                $(document.body).store('slideProgressEvent', function(event) {
                    this.slideProgress.setStyles({
                        top: event.page.y - height - offsetY,
                        left: event.page.x + offsetX
                    });
                }.bind(this));
                $(document.body).addEvent('mousemove', $(document.body).retrieve('slideProgressEvent'));
                this.slideProgress.get('tween', {
                    property: 'opacity',
                    duration: this.options.slideProgressDuration,
                    transition: this.options.slideProgressTransition,
                    link: 'cancel'
                }).start(this.options.slideProgressOpacity);
            } else {
                this.slideProgress.setStyles({
                    position: 'fixed'
                });
                this.slideProgress.get('tween', {
                    property: 'opacity',
                    duration: this.options.slideProgressDuration,
                    transition: this.options.slideProgressTransition,
                    link: 'cancel'
                }).start(this.options.slideProgressOpacity);
            }
        }
    },
    
    hideProgress: function() {
        if ($defined($(document.body).retrieve('slideProgressEvent'))) {
            $(document.body).removeEvent('mousemove', $(document.body).retrieve('slideProgressEvent'));
            $(document.body).eliminate('slideProgressEvent');
            
        }
        this.slideProgress.get('tween', {
            property: 'opacity',
            duration: this.options.slideProgressDuration,
            transition: this.options.slideProgressTransition,
            link: 'cancel'
        }).start(0);
        this.slideProgress.eliminate('x');
        this.slideProgress.eliminate('y');
    },
    
    addTotalCount: function(addCount) {
        this.slideProgress.store('totalCount', this.slideProgress.retrieve('totalCount') + addCount);
        this.setProgressText();
    },
    
    addProgressCount: function() {
        this.slideProgress.store('progressCount', this.slideProgress.retrieve('progressCount') + 1);
        this.setProgressText();
    
    },
    
    setProgressText: function() {
        this.slideProgress.set('text', 'Loading Images ' + this.slideProgress.retrieve('progressCount') + ' / ' + this.slideProgress.retrieve('totalCount'));
    },
    
    load: function(self) {
        var navId = this.options.slideNavPrefix + self.retrieve('navId');
        var slideRoot = self.retrieve('slideRoot');
        var slideWrapper = self.retrieve('slideWrapper');
        var slideContents = self.getElements('.' + this.options.slideElementClassName);
        if (slideContents.length == 0) {
            slideContents = self.getElements('img');
        }
        
        if (slideContents.length == 0) {
            this.checkLoadComplete.run([], this);
            self.setStyle('opacity', 1);
            return;
        } else {
            self.store('curContent', slideContents[0]);
        }
        
        this.setSize(self, slideContents, true);

        var thumbArea = null;
        var navArea = null;
        var navLeft = null;
        var navRight = null;
        if (slideContents.length > 1) {
            thumbArea = new Element('div', { 'class': this.options.slideClassName + '-thumb-area' });
            thumbArea.addClass('slide-thumb-area');
            thumbArea.inject(slideWrapper, 'after');
            
            navArea = new Element('div', { 
                'class': this.options.slideClassName + '-nav-area',
                styles: {
                    top: 0,
                    height: 0,
                    opacity: 0,
                    'z-index': self.getStyle('z-index').toInt() + 1
                }
            });
            navArea.addClass('slide-nav-area');
            navArea.inject(slideWrapper, 'after');
            self.store('navArea', navArea);
            
            navLeft = new Element('div', {
                'class': this.options.slideClassName + '-nav-left',
                text: '<',
                styles: { 
                    left: 0,
                    opacity: 1,
                    'z-index': 1 
                },
                events: {
                    click: function() { 
                        this.prev.run([self], this);
                    }.bind(this),
                    mouseenter: function() {
                        navLeft.get('morph', {
                            duration: this.options.navDuration,
                            transition: this.options.navTransition,
                            link: 'cancel'
                        }).start({ opacity: this.options.navOpacity });
                    }.bind(this),
                    mouseleave: function() {
                        navLeft.get('morph', {
                            duration: this.options.navDuration,
                            transition: this.options.navTransition,
                            link: 'cancel'
                        }).start({ opacity: 1 });
                    }.bind(this)
                }
            });
            navLeft.addClass('slide-nav-left');
            navArea.adopt(navLeft);
            self.store('navLeft', navLeft);
            
            navRight = new Element('div', {
                'class': this.options.slideClassName + '-nav-right',
                text: '>',
                styles: { 
                    right: 0,
                    opacity: 1,                    
                    'z-index': 2 
                },
                events: {
                    click: function() { 
                        this.next.run([self], this);
                    }.bind(this),
                    mouseenter: function() {
                        navRight.get('morph', {
                            duration: this.options.navDuration,
                            transition: this.options.navTransition,
                            link: 'cancel'
                        }).start({ opacity: this.options.navOpacity });
                    }.bind(this),
                    mouseleave: function() {
                        navRight.get('morph', {
                            duration: this.options.navDuration,
                            transition: this.options.navTransition,
                            link: 'cancel'
                        }).start({ opacity: 1 });
                    }.bind(this)
                }
            });
            navRight.addClass('slide-nav-right');
            navArea.adopt(navRight);
            self.store('navRight', navRight);
        }

        var thumbItems = new Array();
        var slideContentLoadCount = 0;
        var slideNavItems = new Array();
        if ($(navId)) {
            slideNavItems = $(navId).getElements('.' + this.options.slideNavElementClassName);
            if (slideNavItems.length > 0) {
                slideNavItems[0].addClass('slide-thumb-item-focused');
            }
        }
        if (slideContents.length > 1) {
            self.store('slideNavItems', slideNavItems);
            self.store('thumbArea', thumbArea);
            self.store('thumbItems', thumbItems);
        }
        
        var curSlideNavItemIndex = 0;
        slideContents.each(function(slideContent, index) {

            slideContent.addClass(this.options.slideElementClassName + '-' + index);
            slideContent.addClass('clearfix');
            slideContent.store('hashId', slideContent.get('id') ? '/' + slideContent.get('id') : slideContent.get('id') || self.retrieve('hashId') + '/' + this.options.slideElementClassName + '-' + index);
            slideContent.setStyle('opacity', 0);
            
            if ($defined(Browser.Engine.trident) == false) {
                slideContent.getElements('object').each(function(object) {
                    object.adopt(new Element('param', {
                        name: 'wmode',
                        value: 'opaque'
                    }));
                });
                slideContent.getElements('embed').each(function(embed) {
                    embed.setProperty('wmode', 'opaque');
                });
            }
            
            if (slideContents.length > 1) {                
                var thumbItem = new Element('span', {
                    'class': this.options.slideClassName + '-thumb-item',
                    styles: { opacity: 0 },
                    events: {
                        click: function() { 
                            this.rotate.run([self, slideContent], this);
                        }.bind(this)
                    }
                });
                thumbItem.addClass('slide-thumb-item');
                if (index == 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 img = null;
                    var thumbImage = null;
                    if (slideContent.get('tag') == 'img') {
                        img = slideContent;
                    } else {
                        img = slideContent.getElement('img');
                    }
                    
                    if ($defined(img)) {
                        thumbImage = img.clone();
                    } else {
                        thumbImage = new Element('span', { 
                            'class': this.options.slideClassName + '-thumb-no',
                            text: index + 1 
                        });
                        thumbImage.addClass('slide-thumb-no');
                    }
                    thumbImage.setStyle('opacity', 1)
                    thumbItem.grab(thumbImage);
                } else {
                    var thumbNo = new Element('span', { 
                        'class': this.options.slideClassName + '-thumb-no',
                        text: index + 1 
                    });
                    thumbNo.addClass('slide-thumb-no');
                    thumbItem.grab(thumbNo);
                }
                thumbItem.inject(thumbArea, 'bottom');
                thumbItems.push(thumbItem);
            }
            
            var srcs = new Array();
            if (slideContent.get('tag') == 'img') {
                srcs.push(slideContent.getProperty('src'));
            } else {
                slideContent.getElements('img').each(function(img) {
                    srcs.push(img.getProperty('src'));
                });
            }
            
            if ($defined(slideNavItems[curSlideNavItemIndex])) {
                if (slideContent.hasClass(this.options.slideNavSkipClassName) == false) {
                    slideContent.store('slideNavItem', slideNavItems[curSlideNavItemIndex]);
                    slideNavItems[curSlideNavItemIndex].addEvent('click', function(event) {
                        event.stop();
                        this.rotate.run([self, slideContent], this);
                    }.bind(this));
                    curSlideNavItemIndex++;
                } else {
                    slideContent.store('slideNavItem', slideNavItems[curSlideNavItemIndex - 1]);
                }
            }
            
            var loadComplete = function() {
                
                if (slideContents.length > 1) {
                    (function() { 
                        if (this.options.withThumbnail) {
                            thumbItems[index].tween('opacity', 1); 
                        } else {
                            thumbItems[index].setStyle('opacity', 1); 
                        }
                    }.bind(this)).delay(this.options.thumbDelay * index);

                    var slideContentWrapper = new Element('span', { 
                        'class': 'slide-content-wrapper',
                        styles: { 
                            'z-index': slideContents.length - index,
                            opacity: 0
                        }
                    });
                    slideContentWrapper.wraps(slideContent);
                    slideContent.store('slideContentWrapper', slideContentWrapper);

                    var measureElement = null;
                    if (slideContent.get('tag') == 'img') {
                        measureElement = slideContent;
                    } else if (slideContent.getElements('img').length == 1) {
                        measureElement = slideContent.getElement('img');
                        if (measureElement.hasClass(this.options.slideImgClassName) == false) {
                            measureElement = null;
                        }
                        
                    }
                    
                    if ($defined(measureElement)) {
                        var anchor = measureElement.getParent('a');
                        if ($defined(anchor)) {
                            anchor.addEvent('click', function(event) { 
                                event.stop();
                            });
                        }
                        
                        var nextLink = new Element('span', {
                            'class': this.options.slideClassName + '-next',
                            styles: { 
                                'z-index': slideContents.length,
                                top: 0,
                                right: 0
                            },
                            events: {
                                click: function(event) {
                                    event.stop();
                                    this.next.run([self, slideContent], this);
                                }.bind(this)
                            }
                        });
                        nextLink.addClass('slide-next');
                        slideContent.store('next', nextLink);
                        
                        var prevLink = new Element('span', {
                            'class': this.options.slideClassName + '-prev',
                            styles: { 
                                'z-index': slideContents.length,
                                top: 0,
                                left: 0
                            },
                            events: {
                                click: function(event) {
                                    event.stop();
                                    this.prev.run([self, slideContent], this);
                                }.bind(this)
                            }
                        });
                        prevLink.addClass('slide-prev');
                        slideContent.store('prev', prevLink);
                        
                        slideContentWrapper.adopt(prevLink);
                        slideContentWrapper.adopt(nextLink);
                    }

                    if (slideContents.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)
                        });
                    }
            
                    (function() {
                        slideContent.setStyle('opacity', 1);
                        slideContentWrapper.get('tween', {
                            property: 'opacity',
                            duration: this.options.fadeDuration,
                            transition: this.options.fadeTransition,
                            link: 'cancel'
                        }).start(1);
                    }.bind(this)).delay(this.options.fadeDelay * index);
                } else {
                    if (slideContent.get('tag') == 'img') {
                        slideContent.addEvent('click', function(event) { event.stop(); });
                    }
                    slideContent.get('tween', {
                        property: 'opacity',
                        duration: this.options.fadeDuration,
                        transition: this.options.fadeTransition,
                        link: 'cancel'
                    }).start(1);
                }
                
                slideContentLoadCount++;
                if (slideContentLoadCount == slideContents.length) {
                    if (slideContents.length > 1) {
                        if (self.hasClass(this.options.slideAutoRotateClassName)) {
                            this.startRotate.run([self], this);
                        }
                    }

                    this.setSize(self, slideContents);
                    
                    this.checkLoadComplete.run([], this);
                }
            }.bind(this);
            
            if (srcs.length == 0) {
                loadComplete();
            } else {
                this.addTotalCount(srcs.length);
                this.showProgress();
                new Asset.images(srcs, {
                    onProgress: function(counter, index) {
                        this.addProgressCount();
                    }.bind(this),
                    onComplete: function() {
                        loadComplete();
                    }
                });
            }
        }.bind(this));
        
        self.setStyle('opacity', 1);
    },
    
    rotate: function(self, target) {

        var slideContents = self.getElements('.' + this.options.slideElementClassName);        
        if (slideContents.length == 0) {
            slideContents = self.getElements('img');
        }
        var curContent = self.retrieve('curContent');
        self.store('curContent', target);        

        if (slideContents.length > 1) {
            
            if (this.options.withHash) {
    	        window.location.hash = target.retrieve('hashId');
                this.hashListner.currentLocation = target.retrieve('hashId');
            }

            if ($defined(target)) {
                if (target == curContent) {
                    this.fireEvent('onRotateComplete');
                    return;
                }
            } else {
                target = curContent;
            }
            
            var thumbItems = self.retrieve('thumbItems');
            var slideNavItems = self.retrieve('slideNavItems');
            var targetSlideNavItem = target.retrieve('slideNavItem');
            var targetIndex = 0;
            for (var i = 0; i < slideContents.length; i++) {
                if (slideContents[i] == target) {
                    thumbItems[i].addClass('slide-thumb-item-focused');
                } else if (slideContents[i] == curContent) {
                    thumbItems[i].removeClass('slide-thumb-item-focused');
                }
            }
            slideNavItems.each(function(slideNavItem) {
                slideNavItem.removeClass('slide-thumb-item-focused');
            });
            if ($defined(targetSlideNavItem)) {
                target.retrieve('slideNavItem').addClass('slide-thumb-item-focused');
            }
            
            var targetSize = target.getComputedSize();
            var curContentSize = curContent.getComputedSize();
            var curWidth = targetSize.width;
            var curHeight = targetSize.height;
            if (
                curWidth != curContentSize.width || 
                curHeight != curContentSize.height
            ) {
                this.fireSizeChangeEvent = true;
            }

            if (this.options.slideAnimationType == this.animationType.fade) {
                self.setStyles({
                    width: curWidth,
                    height: curHeight
                });
                
                var targetWrapper = target.retrieve('slideContentWrapper');
                var curContentWrapper = curContent.retrieve('slideContentWrapper');
                var zIndex = targetWrapper.getStyle('z-index').toInt();
                var curZIndex = curContentWrapper.getStyle('z-index').toInt();

                targetWrapper.setStyle('opacity', 0);
                if (zIndex < curZIndex) {
                    targetWrapper.setStyle('z-index', curZIndex + slideContents.length);
                }
                
                targetWrapper.setStyles({
                    position: 'absolute',
                    top: 0,
                    left: 0
                });
                targetWrapper.store('isFading', true);
                targetWrapper.get('tween', {
                    property: 'opacity',
                    duration: this.options.rotateAnimation ? this.options.fadeDuration : 0,
                    transition: this.options.fadeTransition,
                    link: 'cancel',
                    onComplete: function() {
                        self.getElements('.slide-content-wrapper').each(function(contentWrapper) {
                            if (targetWrapper != contentWrapper) {
                                if (
                                    $defined(contentWrapper.retrieve('isFading')) == false || 
                                    contentWrapper.retrieve('isFading') == false
                                ) {
                                    contentWrapper.setStyle('top', curHeight);
                                }
                            }
                        });
                        targetWrapper.store('isFading', false);
                    }
                }).start(1);
            } else if (
                this.options.slideAnimationType == this.animationType.slide ||
                this.options.slideAnimationType == this.animationType.hSlide
            ) {
                var left = 0;
                for (var i = 0; i < slideContents.length; i++) {
                    if (slideContents[i] == target) {
                        break;
                    } else {
                        left += slideContents[i].getComputedSize().totalWidth;
                    }
                }
                self.get('tween', {
                    property: 'left',
                    duration: this.options.rotateAnimation ? this.options.slideDuration : 0,
                    transition: this.options.slideTransition,
                    link: 'cancel'
                }).start(- left);
            }
            
            var slideRoot = self.retrieve('slideRoot');
            var slideWrapper = self.retrieve('slideWrapper');
            var slideWrapperSize = slideWrapper.getComputedSize();
            var rotateAnimation = this.options.rotateAnimation;
            if (curWidth == slideWrapperSize.width && curHeight == slideWrapperSize.height) {
                rotateAnimation = false;
            }
            
            if (
                this.options.slideAnimationType == this.animationType.fade ||
                this.options.slideAnimationType == this.animationType.slide
            ) {
                var navArea = self.retrieve('navArea');
                var navLeft = self.retrieve('navLeft');
                var navRight = self.retrieve('navRight');
                var navLeftSize = navLeft.getComputedSize();
                var navRightSize = navRight.getComputedSize();
            
                self.retrieve('thumbArea').setStyle('width', curWidth);
                navArea.setStyle('z-index', slideWrapper.getStyle('z-index') + 1);
                
                if (this.options.rotateAnimation) {
                    navLeft.get('tween', {
                        property: 'height',
                        duration: this.options.slideDuration,
                        transition: this.options.slideTransition,
                        link: 'chain'
                    }).start(curHeight);
                    navRight.get('tween', {
                        property: 'height',
                        duration: this.options.slideDuration,
                        transition: this.options.slideTransition,
                        link: 'chain'
                    }).start(curHeight);
                    navArea.get('tween', {
                        property: 'width',
                        duration: this.options.slideDuration,
                        transition: this.options.slideTransition,
                        link: 'chain'
                    }).start(curWidth + navLeftSize.totalWidth + navRightSize.totalWidth);
                    slideWrapper.get('morph', {
                        duration: this.options.slideDuration,
                        transition: this.options.slideTransition,
                        link: 'chain'
                    }).start({
                        width: curWidth,
                        height: curHeight
                    });
                    slideRoot.get('morph', {
                        duration: this.options.slideDuration,
                        transition: this.options.slideTransition,
                        link: 'chain',
                        onComplete: function() {
                            this.fireEvent('onRotateComplete');
                            if (this.fireSizeChangeEvent) {
                                this.fireEvent('sizeChange');
                                this.fireSizeChangeEvent = false;
                            }
                        }.bind(this)
                    }).start({
                        width: curWidth
                    });
                } else {
                    navLeft.setStyle('height', curHeight);
                    navRight.setStyle('height', curHeight);
                    navArea.setStyle('width', curWidth + navLeftSize.totalWidth + navRightSize.totalWidth);
                    slideWrapper.setStyles({
                        width: curWidth,
                        height: curHeight
                    });
                    slideRoot.setStyle('width', curWidth);
                    this.fireEvent('onRotateComplete');
                    if (this.fireSizeChangeEvent) {
                        this.fireEvent('sizeChange');
                        this.fireSizeChangeEvent = false;                        
                    }
                }
            } else if (this.options.slideAnimationType == this.animationType.hSlide) {
                this.fireEvent('onRotateComplete');
                if (this.fireSizeChangeEvent) {
                    this.fireEvent('sizeChange');
                    this.fireSizeChangeEvent = false;                    
                }
            }

        }
    },

    checkLoadComplete: function() {
        this.loadCount++;
        if (this.loadCount == this.slides.length) {
            (function() {
                this.hideProgress();            
                if (this.options.withHash) {
                    this.hashListner.addEvent('hashChanged',function(hash){
                        var hashs = hash.split('/');
                        if (hashs.length == 2) {
                            var slideContentId = hashs[1];
                            if ($defined(slideContentId)) {
                                var targetSlideContent = $(slideContentId);
                                if ($defined(targetSlideContent)) {
                                    var targetSlide = targetSlideContent.getParent('.' + this.options.slideClassName);
                                    if ($defined(targetSlide)) {
                                        this.rotate.run([targetSlide, targetSlideContent], this);
                                    }
                                }
                            }
                        } else if (hashs.length == 3) {
                            var slideId = hashs[1];
                            var slideContentId = hashs[2];
                            if ($defined(slideId) && $defined(slideContentId)) {
                                var targetSlide = $(slideId) || $(document.body).getElement('.' + slideId + ' .' + this.options.slideClassName);
                                if ($defined(targetSlide)) {
                                    $$('.' + this.options.slideClassName).each(function(slide) {
                                        if (slide == targetSlide) {
                                            var slideContent = $(slideContentId) || slide.getElement('.' + slideContentId);
                                            this.rotate.run([slide, slideContent], this);
                                        }
                                    }.bind(this));
                                }
                            }
                        }
                    }.bind(this));
                    
                    this.hashListner.start();
                }
                this.fireEvent('complete');
            }.bind(this)).delay(this.options.fadeDuration * this.loadCount + this.options.fadeDelay * this.loadCount);
        }
    },
    
    next: function(self, slideContent) {
        var slideContents = self.getElements('.' + this.options.slideElementClassName);        
        if (slideContents.length == 0) {
            slideContents = self.getElements('img');
        }
        var curContent = slideContent || self.retrieve('curContent');
        var target = slideContents[0];
        if ($defined(slideContent) == false || slideContent == self.retrieve('curContent')) {
            for (var i = 0; i < slideContents.length; i++) {
                if (slideContents[i] == curContent) {
                    if (slideContents.length == i + 1) {
                        target = slideContents[0];
                    } else {
                        target = slideContents[i + 1];
                    }
                    break;
                }
            }
        } else {
            target = slideContent;
        }
        this.rotate.run([self, target], this);
    },
    
    prev: function(self, slideContent) {
        var slideContents = self.getElements('.' + this.options.slideElementClassName);        
        if (slideContents.length == 0) {
            slideContents = self.getElements('img');
        }
        var curContent = slideContent || self.retrieve('curContent');
        var target = slideContents[0];
        if ($defined(slideContent) == false || slideContent == self.retrieve('curContent')) {
            for (var i = 0; i < slideContents.length; i++) {
                if (slideContents[i] == curContent) {
                    if (i == 0) {
                        target = slideContents.getLast();
                    } else {
                        target = slideContents[i - 1];
                    }
                    break;
                }
            }
        } else {
            target = slideContent;
        }
        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)
        }
    },
    
    setSize: function(self, slideContents) {
        if ($defined(self) == false) {
            this.slides.each(function(slide) {
                this.setSize.run([slide], this);
            }.bind(this));
        }
        var slideRoot = self.retrieve('slideRoot');
        var slideWrapper = self.retrieve('slideWrapper');
        var curContent = self.retrieve('curContent');
        
        var totalWidth = 0;
        var minHeight = 0;
        var maxHeight = 0;
        if ($defined(slideContents) == false) {
            slideContents = self.getElements('.' + this.options.slideElementClassName);
            if (slideContents.length == 0) {
                slideContents = self.getElements('img');
            }
        }
        slideRoot.setStyles({
            width: 'auto',
            height: 'auto'
        });
        slideWrapper.setStyles({
            width: 'auto',
            height: 'auto'
        });
        self.setStyles({
            width: 'auto',
            height: 'auto'
        });
        if (Browser.Engine.trident && Browser.Engine.version < 5 && slideContents.length == 1) {
            if (slideContents[0].get('tag') == 'img') {
                slideContents[0].setStyle('height', 'auto');
            } else {
                slideContents[0].setStyle('position', 'relative');
            }
        }
        slideContents.each(function(slideContent, index) {
            var measureElement = slideContent.getElement('img');
            if ($defined(measureElement) == false) {
                measureElement = slideContent;
            } else {
                if (measureElement.hasClass(this.options.slideImgClassName) == false) {
                    measureElement = slideContent;
                }
            }
            var measureSize = measureElement.getComputedSize({ styles: ['margin', 'padding', 'border'] });
            var curWidth = measureElement.getSize().x;
            if (curWidth > 0) {
                slideContent.setStyles({
                    width: curWidth
                });
            }
            var slideContentSize = slideContent.getComputedSize({ styles: ['margin', 'padding', 'border'] });
            var curHeight = slideContentSize.height;
            var next = slideContent.retrieve('next');
            var prev = slideContent.retrieve('prev');
            if ($defined(next)) {
                next.setStyles({
                    width: (curWidth / 2).toInt(),
                    height: curHeight
                });
            }
            if ($defined(prev)) {
                prev.setStyles({
                    width: (curWidth / 2).toInt(),
                    height: curHeight
                });
            }
            totalWidth += measureSize.totalWidth || (slideContent.get('tag') == 'img' ? slideContent.getProperty('width').toInt() : 0);
            if (
                this.options.slideAnimationType == this.animationType.slide || 
                this.options.slideAnimationType == this.animationType.hSlide
            ) {
                maxHeight = Math.max(maxHeight, slideContentSize.totalHeight || (slideContent.get('tag') == 'img' ? slideContent.getProperty('height').toInt() : 0));
                if (minHeight == 0) {
                    minHeight = curHeight || (slideContent.get('tag') == 'img' ? slideContent.getProperty('height').toInt() : 0);
                } else {
                    minHeight = Math.min(minHeight, slideContentSize.totalHeight || (slideContent.get('tag') == 'img' ? slideContent.getProperty('height').toInt() : 0));
                }
            }
        }.bind(this));
        
        if (this.options.slideAnimationType == this.animationType.fade) {
            self.setStyles({
                width: curContent.getSize().x,
                height: curContent.getSize().y 
            });
            var selfSize = self.getComputedSize();
            slideWrapper.setStyles({
                width: selfSize.totalWidth,
                height: selfSize.totalHeight
            });
            slideRoot.setStyles({
                width: slideWrapper.getComputedSize().totalWidth
            });
        } else if(this.options.slideAnimationType == this.animationType.slide) {
            self.setStyles({
                width: totalWidth,
                height: maxHeight
            });
            slideWrapper.setStyles({
                width: curContent.getSize().x,
                height: curContent.getSize().y 
            });
            slideRoot.setStyles({
                width: slideWrapper.getComputedSize().totalWidth
            });
        } else if (this.options.slideAnimationType == this.animationType.hSlide) {
            self.setStyles({
                width: totalWidth,
                height: maxHeight
            });
            slideWrapper.setStyles({
                height: maxHeight
            });
        }
        
        var wrapperSize = slideWrapper.getComputedSize();
        var thumbArea = self.retrieve('thumbArea');
        if ($defined(thumbArea)) {
            if (this.options.slideAnimationType == this.animationType.hSlide) {
                thumbArea.setStyle('width', '100%');
            } else {
                thumbArea.setStyle('width', wrapperSize.totalWidth);
            }
        }
        
        var navArea = self.retrieve('navArea');
        var navLeft = self.retrieve('navLeft');
        var navRight = self.retrieve('navRight');        
        var navLeftSize = null;
        var navRightSize = null;
        if ($defined(navLeft) && $defined(navRight)) {
            navLeft.setStyle('height', wrapperSize.totalHeight);
            navRight.setStyle('height', wrapperSize.totalHeight);
            navLeftSize = navLeft.getComputedSize();
            navRightSize = navRight.getComputedSize();
        }
        if ($defined(navArea)) {
            if (this.options.slideAnimationType == this.animationType.hSlide) {
                navArea.setStyle('width', '100%');
            } else {
                navArea.setStyles({
                    width: wrapperSize.totalWidth + (navLeftSize ? navLeftSize.totalWidth : 0) + (navRightSize ? navRightSize.totalWidth : 0),
                    left: - (navLeftSize ? navLeftSize.totalWidth : 0)
                });
            }
            if (navArea.getStyle('opacity').toInt() < 1) {
                navArea.tween('opacity', 1);
            }
        
        }
        
    }
    
});

/*
    Gallery 1.0.4
*/
var Gallery = new Class({
	Implements: [Options,Events],
    slideShow: null,
    overlay: null,
    resizeTimer: null,
    scrollTimer: null,
    isLoading: false,
    options: {
        galleryClassName: 'gallery',
        galleryElementClassName: 'gallery-content',        
        galleryDuration: 250,
        galleryTransition: 'sine:in:out',
        fadeDuration: 500,
        fadeTransition: 'sine:in:out',
        minWidth: 300,
        minHeight: 300,
        fadeDelay: 100,
        thumbDelay: 100,
        overlayOpacity: 0.98,
        navOpacity: 0.2
    },
    initialize: function(options) {
        this.setOptions(options);

        window.addEvents({
            scroll: function() {
                $clear(this.scrollTimer);
                this.scrollTimer = (function() {
                    //this.adjust.run([], this);
                }.bind(this)).delay(200);
            }.bind(this),
            
            resize: function() {
                $clear(this.resizeTimer);
                this.resizeTimer = (function() {
                    this.adjust.run([false], this);
                }.bind(this)).delay(200);
            }.bind(this)
        });
    },
    
    run: function() {
        var galleries = $$('.' + this.options.galleryClassName);

        if ($defined(galleries)) {
            galleries.each(function(gallery) {
                var galleryContents = gallery.getElements('.' + this.options.galleryElementClassName);
                if (galleryContents.length == 0) {
                    galleryContents = gallery.getElements('a');
                }
                galleryContents.each(function(galleryContent) {
                    var anchor = null;
                    if (galleryContent.get('tag') == 'a') {
                        anchor = galleryContent;
                    } else {
                        anchor = galleryContent.getElement('a');
                    }
                    if ($defined(anchor)) {
                        anchor.addClass('gallery-image');
                        anchor.addEvent('click', function(event) {
                            event.stop();
                            if (this.isLoading) {
                                return false;
                            }
                            this.isLoading = true;
                            galleryContent.addClass('zoom-base-item');
                            this.show.run([gallery, galleryContent, event], this);
                        }.bind(this));
                    }
                }.bind(this));
            }.bind(this));
            
        }
    },
    
    show: function(self, target, event) {
        this.close();
        
        var galleryContent = target;
        var body = $(document.body);
        this.overlay = new Element('div', {
            id: 'overlay-' + this.options.galleryClassName,
            styles: {
                top:0,
                left: 0,
                'z-index': 99999,
                width: window.getScrollSize().x,
                height: window.getScrollSize().y,
                opacity: 0
            }
        });
        this.overlay.addClass('zoom-overlay');
        body.adopt(this.overlay);
        
        var galleryContents = self.getElements('.' + this.options.galleryElementClassName);
        var zoomContents = new Array();
        if (galleryContents.length == 0) {
            galleryContents = self.getElements('a');
        }
        galleryContents.each(function(galleryContent) {
            var anchor = null;
            if (galleryContent.get('tag') == 'a') {
                anchor = galleryContent;
            } else {
                anchor = galleryContent.getElement('a');
            }
            
            if ($defined(anchor)) {
                var slideImage = new Element('img', {
                    src: anchor.get('href'),
                    'class': 'zoom-image'
                });
                slideImage.addClass('slide-image');
                var slideContent = new Element('div', {
                    'class': 'zoom-content'
                });
                slideContent.addClass('slide-content');
                slideContent.adopt(slideImage);
                
                var img = anchor.getElement('img');
                if ($defined(img)) {
                    var caption = img.getProperty('title');
                    var description = img.getProperty('alt');
                    if ($defined(caption) || $defined(description)) {
                    
                        var slideDetail = new Element('div', {
                            'class': 'zoom-detail'
                        });
                        slideDetail.addClass('slide-detail');
                        slideContent.adopt(slideDetail);
                    }
                    if ($defined(caption)) {
                        var slideCaption = new Element('div', {
                            'class': 'zoom-caption',
                            text: caption
                        });
                        slideCaption.addClass('slide-caption');
                        slideDetail.adopt(slideCaption);
                    }
                    if ($defined(description)) {
                        var slideDescription = new Element('div', {
                            'class': 'zoom-description',
                            html: description
                        });
                        slideDescription.addClass('slide-description');
                        slideDetail.adopt(slideDescription);
                    }
                }
                zoomContents.push(slideContent);
                
                if (galleryContent == target) {
                    target = slideContent;
                }
            }
        }.bind(this));
        
        if (zoomContents.length > 0) {
            var zoom = new Element('div', {
                'class': 'zoom'
            });
            zoom.addClass('slide');
            zoomContents.each(function(zoomContent) {
                zoom.adopt(zoomContent);
            });
            var hiddenElement = new Element('div', {
                styles: { display: 'none' }
            });
            hiddenElement.adopt(zoom);
            body.adopt(hiddenElement);
            this.overlay.store('gallery', zoom);
            
            this.slideShow = new SlideShow({
                slideClassName: 'zoom',
                slideAnimationType: 0,
                slideElementClassName: 'zoom-content',        
                slideImgClassName: 'zoom-image',        
                rotateAnimation: false,
                withThumbnail: false,
                withHash: false,
                fadeDelay: this.options.fadeDelay,
                thumbDelay: this.options.thumbDelay,
                navOpacity: this.options.navOpacity
            });
            this.slideShow.addEvents({
                complete: function() {
                    
                    galleryContent.removeClass('zoom-base-item');
                    
                    var slideRoot = zoom.retrieve('slideRoot');
                    slideRoot.setStyles({
                        'z-index': this.overlay.getStyle('z-index').toInt()
                    });
                    var navArea = zoom.retrieve('navArea');
                    if ($defined(navArea) == false) {
                        navArea = new Element('div', { 
                            'class': 'zoom-nav-area',
                            styles: {
                                top: 0,
                                height: 0,
                                opacity: 0,
                                'z-index': zoom.getStyle('z-index').toInt() + 1
                            }
                        });
                        navArea.addClass('slide-nav-area');
                        navArea.inject(zoom.retrieve('slideWrapper'), 'after');
                        zoom.store('navArea', navArea);
                    }
                    
                    this.overlay.get('tween', {
                        property: 'opacity',
                        duration: this.options.fadeDuration,
                        transition: this.options.fadeTransition,
                        link: 'cancel',
                        onComplete: function() {
                            var close = new Element('div', {
                                id: 'close-' + this.options.galleryClassName,
                                styles: {
                                    top: 0,
                                    right: 0,
                                    'z-index': navArea.getStyle('z-index').toInt() + 1
                                },
                                events: {
                                    click: function() {
                                        this.close.run([], this);
                                    }.bind(this),
                                    mouseenter: function() {
                                        close.get('tween', {
                                            property: 'opacity',
                                            duration: this.slideShow.options.fadeDuration,
                                            transition: this.slideShow.options.fadeTransition,
                                            link: 'cancel'
                                        }).start(this.options.navOpacity);
                                    }.bind(this),
                                    mouseleave: function() {
                                        close.get('tween', {
                                            property: 'opacity',                                        
                                            duration: this.slideShow.options.fadeDuration,
                                            transition: this.slideShow.options.fadeTransition,
                                            link: 'cancel'
                                        }).start(1);
                                    }.bind(this)
                                }
                            });
                            close.addClass('zoom-close');
                            navArea.adopt(close);
                            
                            hiddenElement.setStyle('display', 'block');                            
                            this.slideShow.rotate.run([zoom, target], this.slideShow);
                            
                            this.adjust.run([true], this);
                            
                            this.isLoading = false;
                            
                        }.bind(this)
                    }).start(this.options.overlayOpacity);
                    
                    /*
                    body.store('clickEvent', function(event) {
                        this.close.run([], this);
                        return false;
                    }.bind(this));
                    body.addEvent('click', body.retrieve('clickEvent'));
                    */
                
                }.bind(this),
                rotateComplete: function() {
                    this.adjust.run([true], this);
                }.bind(this)
            });
            this.slideShow.slideProgress.store('x', event.page.x);
            this.slideShow.slideProgress.store('y', event.page.y);
            this.slideShow.run();
        }
    },
    
    close: function() {
        var body = $(document.body);
        if ($defined(this.overlay)) {
            //body.removeEvent('click', body.retrieve('clickEvent'));

            var slideRoot = this.overlay.retrieve('gallery').retrieve('slideRoot');
            slideRoot.get('tween', {
                property: 'opacity',
                duration: this.options.fadeDuration,
                transition: this.options.fadeTransition,
                link: 'cancel'
            }).start(0);
            
            this.overlay.get('tween', {
                property: 'opacity',
                duration: this.options.fadeDuration,
                transition: this.options.fadeTransition,
                link: 'cancel',
                onComplete: function() {
                    slideRoot.destroy();
                    this.overlay.store('gallery', null);
                    this.overlay.destroy();
                    this.overlay = null;
                }.bind(this)
            }).start(0);
        }
    },
    
    adjust: function(loadAnimation) {

        if ($defined(this.overlay)) {
            var slide = this.overlay.retrieve('gallery');
            var slideRoot = slide.retrieve('slideRoot');
            var slideWrapper = slide.retrieve('slideWrapper');
            var curContent = slide.retrieve('curContent');
            var slideImages = slide.getElements('.zoom-image');
            var thumbArea = slide.retrieve('thumbArea');
            var navArea = slide.retrieve('navArea');
            var navLeft = slide.retrieve('navLeft');
            var navRight = slide.retrieve('navRight');
            
            if (loadAnimation == true) {
                slide.setStyle('opacity', 0);
                this.overlay.addClass('zoom-overlay-loading');
            }
            slideImages.each(function(slideImage) {
                slideImage.setStyles({
                    width: 'auto',
                    height: 'auto'
                });
            });
            this.slideShow.setSize(this.overlay.retrieve('gallery'));
            
            var w = document.body.offsetWidth;
            var h = window.getHeight();
            var slideRootSize = slideRoot.getComputedSize();
            var curImage = curContent.getElement('.zoom-image');
            var curImageSize = curImage.getComputedSize();
            var newWidth = 0;
            var newHeight = 0;
            if (slideRootSize.totalWidth > w) {
                var otherWidth =  slideRootSize.totalWidth - curImageSize.totalHeight;
                newWidth = Math.max(w - otherWidth, this.options.minWidth);
                newHeight = curImageSize.totalHeight * (newWidth / curImageSize.totalWidth);
                curImage.setStyles({
                    width: newWidth,
                    height: newHeight
                });
                this.slideShow.setSize(slide);
                slideRootSize = slideRoot.getComputedSize();
                curImageSize = curImage.getComputedSize();
            }
            if (slideRootSize.totalHeight > h) {
                var otherHeight =  slideRootSize.totalHeight - curImageSize.totalHeight;
                newHeight = Math.max(h - otherHeight, this.options.minHeight);
                newWidth = curImageSize.totalWidth * (newHeight / curImageSize.totalHeight);
                curImage.setStyles({
                    width: newWidth,
                    height: newHeight
                });
                this.slideShow.setSize(slide);
            }
            slideRootSize = slideRoot.getComputedSize();
            slideRoot.setStyles({
                top: h / 2 - slideRootSize.totalHeight / 2,
                left: w / 2 - slideRootSize.totalWidth / 2
            });
            
            if (loadAnimation == true) {
                (function() {
                    slide.get('tween', {
                        property: 'opacity',
                        duration: this.options.galleryDuration,
                        transition: this.options.galleryTransition,
                        link: 'cancel',
                        onComplete: function() {
                            this.overlay.removeClass('zoom-overlay-loading');
                        }.bind(this)
                    }).start(1);
                }.bind(this)).delay(250);
            }
            
            this.overlay.setStyles({
                width: window.getScrollSize().x,
                height: window.getScrollSize().y
            });
            navArea.setStyles({
                width: w,
                top: - slideRoot.getStyle('top').toInt(),
                left: - slideRoot.getStyle('left').toInt()
            });
            if ($defined(navLeft)) {
                navLeft.setStyle('height', Math.max(h, slideRootSize.totalHeight));
            }
            if ($defined(navRight)) {
                navRight.setStyle('height', Math.max(h, slideRootSize.totalHeight));
            }
            if ($defined(thumbArea)) {
                thumbArea.setStyles({
                    width: w,
                    'margin-left': - slideRoot.getStyle('left').toInt()
                });
            }
        }
    }
    
    
});

/*
    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){
            var tipTitle = tip.getElement('.tip-title');
            if ($defined(tipTitle) == false) {
                tip.setStyle('display', 'none');
            } else {
                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': 99999
                });
                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));
        
    }
    
});

/*
    DropDown Menu 1.0.1
*/
var DropDownMenu = new Class({
	Implements: [Options,Events],
    options: {
        duration: 250,
        transition: 'expo:out',
        delay: 500,
        opacity: 1,
        dropDownClassName: 'dropdown',
        dropDownWidth: 'auto'
    },
    initialize: function(options) {
        this.setOptions(options);
        
        $$('.' + this.options.dropDownClassName).each(function(dropdown) {
            if (this.options.dropDownWidth == 'full') {
                dropdown.setStyle('position', 'relative');
                if (Browser.Engine.trident && Browser.Engine.version < 5) {
                    dropdown.setStyle('width', '100%');
                }
            }
            dropdown.getElements('li').each(function(parent) {
            
                parent.addClass(this.options.dropDownClassName + '-parent');
                if (this.options.dropDownWidth == 'auto') {
                    parent.setStyle('position', 'relative');
                }
                
                var child = parent.getElement('ul');
                if (child) {
                    if (this.options.dropDownWidth == 'full') {
                        child.setStyle('width', dropdown.getComputedSize().totalWidth);
                    }
                    child.store('defaultHeight', child.getDimensions({computeSize: true}).totalHeight);
                    child.setStyles({
                        position: 'absolute',
                        left: 0,
                        display: 'none',
                        overflow: 'hidden',
                        height: 0,
                        opacity: 0
                    });
                    parent.addEvents({
                        mouseenter: function() {
                            $clear(parent.retrieve('backTimer'));
                            parent.eliminate('backTimer');
                        
                            if (dropdown.retrieve('activeChild')) {
                                this.hideMenu(dropdown.retrieve('activeChild'), dropdown);
                                dropdown.eliminate('activeChild');
                            }

                            dropdown.store('activeChild', child);
                            child.setStyle('display', 'block');
                            child.get('morph', {
                                duration: this.options.duration,
                                transition: this.options.transition
                            }).start({
                                opacity: this.options.opacity,
                                height: child.retrieve('defaultHeight')
                            });
                        }.bind(this),
                        
                        mouseleave: function() {
                            var timer = (function() {
                                this.hideMenu(child, dropdown);
                                dropdown.eliminate('activeChild');
                            }.bind(this)).delay(this.options.delay);
                            parent.store('backTimer', timer);
                        }.bind(this)
                    });
                }
            }.bind(this));
        }.bind(this));
    },
    
    hideMenu: function(self, root) {
        self.get('morph', {
            duration: this.options.duration * 2,
            transition: this.options.transition,
            onComplete: function() {
                self.setStyle('display', 'none');
            }
        }).start({
            opacity: 0,
            height: 0
        });
    }
    
});