if (navigator.userAgent.indexOf('Opera') != -1) isOpera = true; else isOpera = false;

var tf, tb = false;

function featureSlide() {
	if (tb == true) return;
	
	ci = $$('#j-fader-control li').indexOf($('j-fader-control').down('.active'));
	ic = $$('#j-fader-control li').size();
	
	ci = (ci == ic - 1) ? 0 : ci + 1;
	
	fl.invoke('removeClassName', 'active');
	$$('#j-fader-control li')[ci].addClassName('active');
	if (!isOpera) sf.scrollTo(ci * 2);
	else {
		ft.invoke('hide');
		ft[ci * 2].show();
		ft[(ci * 2) + 1].show();
	}
}

function featureInit() {
	if ($$('#j-fader-content').size()) {
		fl = $$('#j-fader-control li');
		ft = $$('#j-fader-content .content li');
		if (!isOpera) sf = new UI.Carousel('j-fader-content');

		tf = setInterval('featureSlide()', 10000);

		fl.each(function(el){
			el.observe('click', function(ev){
				el = ev.element();
				fl.invoke('removeClassName', 'active');
				el.addClassName('active');
				if (!isOpera) sf.scrollTo(fl.indexOf(el) * 2);
				else {
					ft.invoke('hide');
					ft[fl.indexOf(el) * 2].show();
					ft[(fl.indexOf(el) * 2) + 1].show();
				}
				clearInterval(tf);
				tf = setInterval('featureSlide()', 10000);
			});
		});

	$('j-fader-content').observe('mouseenter', function() { tb = true; });
	$('j-fader-content').observe('mouseleave', function() { tb = false; });
	}
}

var tf2;

function featureInit2() {
	if ($$('#j-fader-content2').size()) {
		fl2 = $$('#j-fader-control2 li');
		ft2 = $$('#j-fader-content2 .content li');
		if (!isOpera) sf2 = new UI.Carousel('j-fader-content2');


		fl2.each(function(el2){
			el2.observe('click', function(ev){
				el2 = ev.element();
				fl2.invoke('removeClassName', 'active');
				el2.addClassName('active');
				if (!isOpera) sf2.scrollTo(fl2.indexOf(el2));
				else {
					ft2.invoke('hide');
					ft2[fl2.indexOf(el2)].show();
				}
			});
		});
	}
}
















document.observe('dom:loaded', function() {
	featureInit();
	featureInit2();

	$$('#l-blog .blog-banner').each(function (el) {
		ph = 0, ch = 0, df = 0;
		
		if(el.down('span') != undefined) {
			el2 = el.down('span');

			ph = el.getHeight();
			ch = el2.getHeight();
			df = parseInt((ph - ch) / 2 + 0);
			
			el2.setStyle({ 'paddingTop' : df+'px'}); 
		}
	});

	$$('div.img-large, div.img-small, div.img-none').each(function(el) {
		el2 = el.down('img');
		
		
		
		w = parseInt(el2.getWidth());

	
		el.setStyle({ 'width':w+'px' });
	})

	var boxHeight = 145, currentHeight = 0, maxHeight = 0, spacerHeight = 0;

	$$("div.same-height").each(function(el) {
		currentHeight = el.getHeight();
		
		if(el == $$("div.same-height").last()) {
			if((currentHeight < maxHeight) && ((maxHeight - currentHeight) >= boxHeight)) {
				spacerHeight = (maxHeight - currentHeight) - 32;

				$("spacer").setStyle({
					height: spacerHeight + 'px'
				});
			}
		}

		else {
			if(currentHeight > maxHeight) maxHeight = currentHeight;
		}
	})

	$$('.cmore a').each(function(e) {
		e.observe('click', function(event) {
			event.element().up().up().down('p').setStyle( {
				'display':'block' 
			});
			event.element().up().up().down('.stars').setStyle( {
				'display':'block' 
			});
			event.element().up().up().down('.stars-text').setStyle( {
				'display':'block' 
			});
			event.element().up().up().down('.cless').setStyle( {
				'display':'block' 
			});
			event.element().up().up().down('.cmore').setStyle( {
				'display':'none' 
			});
			event.stop();
		});
	});

	$$('.cless a').each(function(e) {
		e.observe('click', function(event) {
			event.element().up().up().down('.stars').setStyle( {
				'display':'none' 
			});
			event.element().up().up().down('.stars-text').setStyle( {
				'display':'none' 
			});
			event.element().up().up().down('p').setStyle( {
				'display':'none' 
			});
			event.element().up().up().down('.cless').setStyle( {
				'display':'none' 
			});
			event.element().up().up().down('.cmore').setStyle( {
				'display':'block' 
			});
			event.stop();
		});
	});
});

if (typeof Prototype == 'undefined' || !Prototype.Version.match("1.6")) throw ("Prototype-UI library require Prototype library >= 1.6.0");
if (Prototype.Browser.WebKit) {
    Prototype.Browser.WebKitVersion = parseFloat(navigator.userAgent.match(/AppleWebKit\/([\d\.\+]*)/)[1]);
    Prototype.Browser.Safari2 = (Prototype.Browser.WebKitVersion < 420)
}
if (Prototype.Browser.IE) {
    Prototype.Browser.IEVersion = parseFloat(navigator.appVersion.split(';')[1].strip().split(' ')[1]);
    Prototype.Browser.IE6 = Prototype.Browser.IEVersion == 6;
    Prototype.Browser.IE7 = Prototype.Browser.IEVersion == 7
}
Prototype.falseFunction = function () {
    return false
};
Prototype.trueFunction = function () {
    return true
};
var UI = {
    Abstract: {},
    Ajax: {}
};
Object.extend(Class.Methods, {
    extend: Object.extend.methodize(),
    addMethods: Class.Methods.addMethods.wrap(function (a, b) {
        if (!b) return this;
        if (!b.hasOwnProperty('methodsAdded')) return a(b);
        var c = b.methodsAdded;
        delete b.methodsAdded;
        a(b);
        c.call(b, this);
        b.methodsAdded = c;
        return this
    }),
    addMethod: function (a, b) {
        var c = {};
        c[a] = b;
        return this.addMethods(c)
    },
    method: function (a) {
        return this.prototype[a].valueOf()
    },
    classMethod: function () {
        $A(arguments).flatten().each(function (a) {
            this[a] = (function () {
                return this[a].apply(this, arguments)
            }).bind(this.prototype)
        }, this);
        return this
    },
    undefMethod: function (a) {
        this.prototype[a] = undefined;
        return this
    },
    removeMethod: function (a) {
        delete this.prototype[a];
        return this
    },
    aliasMethod: function (a, b) {
        this.prototype[a] = this.prototype[b];
        return this
    },
    aliasMethodChain: function (a, b) {
        b = b.camelcase();
        this.aliasMethod(a + "Without" + b, a);
        this.aliasMethod(a, a + "With" + b);
        return this
    }
});
Object.extend(Number.prototype, {
    snap: function (a) {
        return parseInt(a == 1 ? this : (this / a).floor() * a)
    }
});
Object.extend(String.prototype, {
    camelcase: function () {
        var a = this.dasherize().camelize();
        return a.charAt(0).toUpperCase() + a.slice(1)
    },
    makeElement: function () {
        var a = new Element('div');
        a.innerHTML = this;
        return a.down()
    }
});
Object.extend(Array.prototype, {
    empty: function () {
        return !this.length
    },
    extractOptions: function () {
        return this.last().constructor === Object ? this.pop() : {}
    },
    removeAt: function (a) {
        var b = this[a];
        this.splice(a, 1);
        return b
    },
    remove: function (a) {
        var b;
        while ((b = this.indexOf(a)) != -1) this.removeAt(b);
        return a
    },
    insert: function (a) {
        var b = $A(arguments);
        b.shift();
        this.splice.apply(this, [a, 0].concat(b));
        return this
    }
});
Element.addMethods({
    getScrollDimensions: function (a) {
        return {
            width: a.scrollWidth,
            height: a.scrollHeight
        }
    },
    getScrollOffset: function (a) {
        return Element._returnOffset(a.scrollLeft, a.scrollTop)
    },
    setScrollOffset: function (a, b) {
        a = $(a);
        if (arguments.length == 3) b = {
            left: b,
            top: arguments[2]
        };
        a.scrollLeft = b.left;
        a.scrollTop = b.top;
        return a
    },
    getNumStyle: function (a, b) {
        var c = parseFloat($(a).getStyle(b));
        return isNaN(c) ? null : c
    },
    appendText: function (a, b) {
        a = $(a);
        b = String.interpret(b);
        a.appendChild(document.createTextNode(b));
        return a
    }
});
document.whenReady = function (a) {
    if (document.loaded) a.call(document);
    else document.observe('dom:loaded', a)
};
Object.extend(document.viewport, {
    getScrollOffset: document.viewport.getScrollOffsets,
    setScrollOffset: function (a) {
        Element.setScrollOffset(Prototype.Browser.WebKit ? document.body : document.documentElement, a)
    },
    getScrollDimensions: function () {
        return Element.getScrollDimensions(Prototype.Browser.WebKit ? document.body : document.documentElement)
    }
});
(function () {
    UI.Options = {
        methodsAdded: function (a) {
            a.classMethod($w(' setOptions allOptions optionsGetter optionsSetter optionsAccessor '))
        },
        setOptions: function (a) {
            if (!this.hasOwnProperty('options')) this.options = this.allOptions();
            this.options = Object.extend(this.options, a || {})
        },
        allOptions: function () {
            var a = this.constructor.superclass,
                ancestor = a && a.prototype;
            return (ancestor && ancestor.allOptions) ? Object.extend(ancestor.allOptions(), this.options) : Object.clone(this.options)
        },
        optionsGetter: function () {
            addOptionsAccessors(this, arguments, false)
        },
        optionsSetter: function () {
            addOptionsAccessors(this, arguments, true)
        },
        optionsAccessor: function () {
            this.optionsGetter.apply(this, arguments);
            this.optionsSetter.apply(this, arguments)
        }
    };

    function addOptionsAccessors(d, e, f) {
        e = $A(e).flatten();
        if (e.empty()) e = Object.keys(d.allOptions());
        e.each(function (b) {
            var c = (f ? 'set' : 'get') + b.camelcase();
            d[c] = d[c] || (f ?
            function (a) {
                return this.options[b] = a
            } : function () {
                return this.options[b]
            })
        })
    }
})();
UI.Carousel = Class.create(UI.Options, {
    options: {
        direction: "horizontal",
        previousButton: ".previous_button",
        nextButton: ".next_button",
        container: ".container",
        scrollInc: "auto",
        disabledButtonSuffix: '_disabled',
        overButtonSuffix: '_over'
    },
    initialize: function (c, d) {
        this.setOptions(d);
        this.element = $(c);
        this.id = this.element.id;
        this.container = this.element.down(this.options.container).firstDescendant();
        this.elements = this.container.childElements();
        this.previousButton = this.options.previousButton == false ? null : this.element.down(this.options.previousButton);
        this.nextButton = this.options.nextButton == false ? null : this.element.down(this.options.nextButton);
        this.posAttribute = (this.options.direction == "horizontal" ? "left" : "top");
        this.dimAttribute = (this.options.direction == "horizontal" ? "width" : "height");
        this.elementSize = this.computeElementSize();
        this.nbVisible = this.currentSize() / this.elementSize;
        var e = this.options.scrollInc;
        if (e == "auto") e = Math.floor(this.nbVisible);
        [this.previousButton, this.nextButton].each(function (a) {
            if (!a) return;
            var b = (a == this.nextButton ? "next_button" : "previous_button") + this.options.overButtonSuffix;
            a.clickHandler = this.scroll.bind(this, (a == this.nextButton ? -1 : 1) * e * this.elementSize);
            a.observe("click", a.clickHandler).observe("mouseover", function () {
                a.addClassName(b)
            }.bind(this)).observe("mouseout", function () {
                a.removeClassName(b)
            }.bind(this))
        }, this);
        this.updateButtons()
    },
    destroy: function ($super) {
        [this.previousButton, this.nextButton].each(function (a) {
            if (!a) return;
            a.stopObserving("click", a.clickHandler)
        }, this);
        this.element.remove();
        this.fire('destroyed')
    },
    fire: function (a, b) {
        b = b || {};
        b.carousel = this;
        return this.element.fire('carousel:' + a, b)
    },
    observe: function (a, b) {
        this.element.observe('carousel:' + a, b.bind(this));
        return this
    },
    stopObserving: function (a, b) {
        this.element.stopObserving('carousel:' + a, b);
        return this
    },
    checkScroll: function (a, b) {
        if (a > 0) a = 0;
        else {
            var c = this.elements.last().positionedOffset()[this.posAttribute] + this.elementSize;
            var d = this.currentSize();
            if (a + c < d) a += d - (a + c);
            a = Math.min(a, 0)
        }
        if (b) this.container.style[this.posAttribute] = a + "px";
        return a
    },
    scroll: function (a) {
        if (this.animating) return this;
        var b = this.currentPosition() + a;
        b = this.checkScroll(b, false);
        a = b - this.currentPosition();
        if (a != 0) {
            this.animating = true;
            this.fire("scroll:started");
            var c = this;
						this.container.morph("opacity:0.5", {
                duration: 0.2,
                afterFinish: function () {
                    c.container.morph(c.posAttribute + ": " + b + "px", {
                        duration: 0.4,
                        delay: 0.2,
                        afterFinish: function () {
                            c.container.morph("opacity:1", {
                                duration: 0.2,
                                afterFinish: function () {
                                    c.animating = false;
                                    c.updateButtons().fire("scroll:ended", {
                                        shift: a / c.currentSize()
                                    })
                                }
                            })
                        }
                    })
                }
            })
        }
        return this
    },
    scrollTo: function (a) {
        if (this.animating || a < 0 || a > this.elements.length || a == this.currentIndex() || isNaN(parseInt(a))) return this;
        return this.scroll((this.currentIndex() - a) * this.elementSize)
    },
    updateButtons: function () {
        this.updatePreviousButton();
        this.updateNextButton();
        return this
    },
    updatePreviousButton: function () {
        var a = this.currentPosition();
        var b = "previous_button" + this.options.disabledButtonSuffix;
        if (this.previousButton.hasClassName(b) && a != 0) {
            this.previousButton.removeClassName(b);
            this.fire('previousButton:enabled')
        }
        if (!this.previousButton.hasClassName(b) && a == 0) {
            this.previousButton.addClassName(b);
            this.fire('previousButton:disabled')
        }
    },
    updateNextButton: function () {
        var a = this.currentLastPosition();
        var b = this.currentSize();
        var c = "next_button" + this.options.disabledButtonSuffix;
        if (this.nextButton.hasClassName(c) && a != b) {
            this.nextButton.removeClassName(c);
            this.fire('nextButton:enabled')
        }
        if (!this.nextButton.hasClassName(c) && a <= b) {
            this.nextButton.addClassName(c);
            this.fire('nextButton:disabled')
        }
    },
    computeElementSize: function () {
        return this.elements.first().getDimensions()[this.dimAttribute]
    },
    currentIndex: function () {
        return -this.currentPosition() / this.elementSize
    },
    currentLastPosition: function () {
        if (this.container.childElements().empty()) return 0;
        return this.currentPosition() + this.elements.last().positionedOffset()[this.posAttribute] + this.elementSize
    },
    currentPosition: function () {
        return this.container.getNumStyle(this.posAttribute)
    },
    currentSize: function () {
        return this.container.parentNode.getDimensions()[this.dimAttribute]
    },
    updateSize: function () {
        this.nbVisible = this.currentSize() / this.elementSize;
        var b = this.options.scrollInc;
        if (b == "auto") b = Math.floor(this.nbVisible);
        [this.previousButton, this.nextButton].each(function (a) {
            if (!a) return;
            a.stopObserving("click", a.clickHandler);
            a.clickHandler = this.scroll.bind(this, (a == this.nextButton ? -1 : 1) * b * this.elementSize);
            a.observe("click", a.clickHandler)
        }, this);
        this.checkScroll(this.currentPosition(), true);
        this.updateButtons().fire('sizeUpdated');
        return this
    }
});
UI.Ajax.Carousel = Class.create(UI.Carousel, {
    options: {
        elementSize: -1,
        url: null
    },
    initialize: function ($super, d, e) {
        if (!e.url) throw ("url option is required for UI.Ajax.Carousel");
        if (!e.elementSize) throw ("elementSize option is required for UI.Ajax.Carousel");
        $super(d, e);
        this.endIndex = 0;
        this.hasMore = true;
        this.updateHandler = this.update.bind(this);
        this.updateAndScrollHandler = function (a, b, c) {
            this.update(b, c);
            this.scroll(a)
        }.bind(this);
        this.runRequest.bind(this).defer({
            parameters: {
                from: 0,
                to: Math.ceil(this.nbVisible) - 1
            },
            onSuccess: this.updateHandler
        })
    },
    runRequest: function (a) {
        this.requestRunning = true;
        new Ajax.Request(this.options.url, Object.extend({
            method: "GET"
        }, a));
        this.fire("request:started");
        return this
    },
    scroll: function ($super, a) {
        if (this.animating || this.requestRunning) return this;
        var b = (-a) / this.elementSize;
        if (this.hasMore && b > 0 && this.currentIndex() + this.nbVisible + b - 1 > this.endIndex) {
            var c = this.endIndex + 1;
            var d = Math.ceil(c + this.nbVisible - 1);
            this.runRequest({
                parameters: {
                    from: c,
                    to: d
                },
                onSuccess: this.updateAndScrollHandler.curry(a).bind(this)
            });
            return this
        } else $super(a)
    },
    update: function (a, b) {
        this.requestRunning = false;
        this.fire("request:ended");
        if (!b) b = a.responseJSON;
        this.hasMore = b.more;
        this.endIndex = Math.max(this.endIndex, b.to);
        this.elements = this.container.insert({
            bottom: b.html
        }).childElements();
        return this.updateButtons()
    },
    computeElementSize: function () {
        return this.options.elementSize
    },
    updateSize: function ($super) {
        var a = this.nbVisible;
        $super();
        if (Math.floor(this.nbVisible) - Math.floor(a) >= 1 && this.hasMore) {
            if (this.currentIndex() + Math.floor(this.nbVisible) >= this.endIndex) {
                var b = Math.floor(this.currentIndex() + Math.floor(this.nbVisible) - this.endIndex);
                this.runRequest({
                    parameters: {
                        from: this.endIndex + 1,
                        to: this.endIndex + b
                    },
                    onSuccess: this.updateHandler
                })
            }
        }
        return this
    },
    updateNextButton: function ($super) {
        var a = this.currentLastPosition();
        var b = this.currentSize();
        var c = "next_button" + this.options.disabledButtonSuffix;
        if (this.nextButton.hasClassName(c) && a != b) {
            this.nextButton.removeClassName(c);
            this.fire('nextButton:enabled')
        }
        if (!this.nextButton.hasClassName(c) && a == b && !this.hasMore) {
            this.nextButton.addClassName(c);
            this.fire('nextButton:disabled')
        }
    }
});