Initial commit with current state + bundled

about/js/curtain.js

@@ -0,0 +1,540 @@
+/*
+* Curtain.js - Create an unique page transitioning system
+* ---
+* Version: 1.4.1
+* Copyright 2011, Victor Coulon (http://victorcoulon.fr)
+* Released under the MIT Licence
+*/
+
+(function ( $, window, document, undefined ) {
+
+    var pluginName = 'curtain',
+        defaults = {
+            scrollSpeed: 400,
+            bodyHeight: 0,
+            linksArray: [],
+            mobile: false,
+            scrollButtons: {},
+            controls: null,
+            curtainLinks: '.curtain-links',
+            enableKeys: true,
+            easing: 'swing',
+            nextSlide: null,
+            prevSlide: null
+        };
+
+    // The actual plugin constructor
+    function Plugin( element, options ) {
+        var self = this;
+
+        // Public attributes
+        this.element = element;
+        this.options = $.extend( {}, defaults, options) ;
+
+        this._defaults = defaults;
+        this._name = pluginName;
+        this._ignoreHashChange = false;
+
+        this.init();
+
+        // Public Functions
+        this.insert = function(content){
+            if(Object.prototype.toString.call(content) !== '[object Object]') {
+                throw new TypeError('Content must be an object');
+            }
+            content.goTo = (content.goTo === true) ? true : false;
+
+            // append the content to list
+            var newEl = $(document.createElement('li')).attr('id', (content.htmlId) ? content.htmlId : null)
+                                .attr('class', (content.htmlClass) ? content.htmlClass : null)
+                                .html( (content.html) ? content.html : null );
+            $(self.element).append(newEl);
+
+
+            // Append Content after an element OR at the end
+            if(content.insertAfter && $(content.insertAfter).length) {
+                $(self.element).find(content.insertAfter).after(newEl);
+            } else {
+                $(self.element).append(newEl);
+            }
+
+
+            // When the element is ready
+            self.readyElement($(newEl), function(){
+                // re(init) cache elements
+                self.$element = $(self.element);
+                self.$li = $(self.element).find('>li');
+
+                // Mobile Fix
+                if(self.options.mobile){
+                    self.$li.css({position:'relative'});
+                    self.$element.find('.fixed').css({position:'absolute'});
+                }
+                
+                self.setLinks();
+
+                // Set dimensions after loading images (or not)
+                if($(newEl).find('img').length){
+                    $(newEl).find('img').load(function(){
+                        self.setDimensions();
+                    });
+                } else {
+                    self.setDimensions();
+                }
+
+                // Scroll to the new element
+                if(content.goTo === true){
+                    var position = $(newEl).attr('data-position') || null;
+                    self.scrollEl.animate({
+                        scrollTop:position
+                    }, self.options.scrollSpeed, self.options.easing);
+                }
+            });
+
+        };
+    }
+
+    Plugin.prototype = {
+        init: function () {
+            var self = this;
+
+            // Cache element
+            this.$element = $(this.element);
+            this.$li = $(this.element).find('>li');
+
+
+            $.Android = (navigator.userAgent.match(/Android/i));
+            $.iPhone = ((navigator.userAgent.match(/iPhone/i)) || (navigator.userAgent.match(/iPod/i)));
+            $.iPad = ((navigator.userAgent.match(/iPad/i)));
+            $.iOs4 = (/OS [1-4]_[0-9_]+ like Mac OS X/i.test(navigator.userAgent));
+
+
+            if($.iPhone || $.iPad || $.Android){
+                this.options.mobile = true;
+                this.$li.css({position:'relative'});
+                this.$element.find('.fixed').css({position:'absolute'});
+            }
+            
+
+            if(this.options.mobile){
+               this.scrollEl =  this.$element;
+            } else if($.browser.mozilla || $.browser.msie) {
+                this.scrollEl = $('html');
+            } else {
+                this.scrollEl = $('body');
+            }
+
+            if(self.options.controls){
+                self.options.scrollButtons['up'] =  $(self.options.controls).find('[href="#up"]');
+                self.options.scrollButtons['down'] =  $(self.options.controls).find('[href="#down"]');
+
+                if(!$.iOs4 && ($.iPhone || $.iPad)){
+                    self.$element.css({
+                        position:'fixed',
+                        top:0,
+                        left:0,
+                        right:0,
+                        bottom:0,
+                        '-webkit-overflow-scrolling':'touch',
+                        overflow:'auto'
+                    });
+                    $(self.options.controls).css({position:'absolute'});
+                }
+            }
+
+
+
+            // We'll check if our images are loaded
+            var images = [],
+                imagesLoaded = 0,
+                loadAllImages = function loadAllImages(callback){
+                    if(images.length === 0){
+                        callback();
+                        return false;
+                    }
+                    var img = new Image();
+                    $(img).attr('src',images[imagesLoaded]).load(function(){
+                    imagesLoaded++;
+                    if(imagesLoaded == images.length)
+                        callback();
+                    else
+                        loadAllImages(callback);
+                    });
+                };
+
+            self.$element.find('img').each(function(i,el){
+                images.push(el.src);
+            });
+
+
+            // When all image is loaded
+            loadAllImages(function(){
+                self.setDimensions();
+                self.$li.eq(0).addClass('current');
+
+                // Cache
+                self.$current = self.$element.find('.current');
+                self.$fixed = self.$current.find('.fixed');
+                self.$step = self.$current.find('.step');
+                self.currentP = parseInt(self.$current.attr('data-position'), 10);
+                self.currentHeight = parseInt(self.$current.attr('data-height'), 10);
+
+                if(!self.options.mobile){
+                    if(self.$li.eq(1).length)
+                        self.$li.eq(1).nextAll().css({display:'none'});
+                }
+
+                self.setEvents();
+                self.setLinks();
+                self.isHashIsOnList(location.hash.substring(1));
+            });
+
+        },
+        // Events
+        scrollToPosition: function (direction){
+            var position = null,
+                self = this;
+
+            if($('html, body').is(':animated')){
+                return false;
+            }
+
+            if(direction === 'up' || direction == 'down'){
+
+                // Keyboard event
+                var $current = this.$element.find('.current'),
+                    $next = (direction === 'up') ? $current.prev() : $current.next();
+
+                position = $next.attr('data-position') || null;
+
+                // Step in the current panel ?
+                if($current.find('.step').length){
+                    if(!$current.find('.current-step').length)
+                        $current.find('.step').eq(0).addClass('current-step');
+                    var $nextStep = (direction === 'up') ? $current.find('.current-step').prev('.step') : $current.find('.current-step').next('.step');
+                    if($nextStep.length) {
+                        position = (this.options.mobile) ? $nextStep.position().top + parseInt($current.attr('data-position'), 10) : $nextStep.offset().top;
+                    }
+                }
+
+                if(position){
+                    self.scrollEl.animate({
+                        scrollTop:position
+                    }, this.options.scrollSpeed, this.options.easing);
+                }
+
+            } else if(direction === 'top'){
+                self.scrollEl.animate({
+                    scrollTop:0
+                }, self.options.scrollSpeed, self.options.easing);
+            } else if(direction === 'bottom'){
+                self.scrollEl.animate({
+                    scrollTop:self.options.bodyHeight
+                }, self.options.scrollSpeed, self.options.easing);
+            } else {
+                position = $("#"+direction).attr('data-position') || null;
+                if(position){
+                    self.scrollEl.animate({
+                        scrollTop:position
+                    }, this.options.scrollSpeed, this.options.easing);
+                }
+            }
+            
+        },
+        scrollEvent: function() {
+            var self = this,
+                docTop = $(document).scrollTop(),
+                windowHeight = $(window).height();
+
+
+            if(docTop < self.currentP && self.$current.index() > 0){
+                if (self.options.prevSlide) {
+                    self.options.prevSlide();
+                }
+
+                    
+                // Scroll top
+                self._ignoreHashChange = true;
+                if(self.$current.prev().attr('id'))
+                    self.setHash(self.$current.prev().attr('id'));
+                 
+       
+                self.$current.removeClass('current').css({marginTop: 0})
+                    .nextAll().css({display:'none'}).end()
+                    .prev().addClass('current').css({display:'block'});
+  
+                // Cache
+                self.$current = self.$element.find('.current');
+                self.$fixed = self.$current.find('.fixed');
+                self.$step = self.$current.find('.step');
+                self.currentP = parseInt(self.$current.attr('data-position'), 10);
+                self.currentHeight = parseInt(self.$current.attr('data-height'), 10);
+
+            } else if(docTop < (self.currentP + self.$current.height())){
+                // Animate the current pannel during the scroll
+                var position = -(docTop-self.currentP);
+                self.$current.css({marginTop:position});
+
+                // If there is a fixed element in the current panel
+                if(self.$fixed.length){
+                    var dataTop = parseInt(self.$fixed.attr('data-top'), 10);
+                    
+                    if((docTop-self.currentP+windowHeight) >= self.currentHeight && self.$fixed.css('position') === 'fixed'){
+        
+                        self.$fixed.css({
+                            position: 'absolute',
+                            top: Math.abs(docTop-self.currentP + dataTop)
+                        });
+         
+
+                    } else if((docTop-self.currentP+windowHeight) <= self.currentHeight && self.$fixed.css('position') === 'absolute'){
+                        self.$fixed.css({
+                            position: 'fixed',
+                            top: dataTop
+                        });
+                    }
+
+                    
+                }
+
+                
+                // If there is a step element in the current panel
+                if(self.$step.length){
+                    $.each(self.$step, function(i,el){
+                        if($(el).offset().top <= docTop+5 && ($(el).offset().top + $(el).outerHeight()) >= docTop+5){
+                            if(!$(el).hasClass('current-step')){
+                                self.$step.removeClass('current-step');
+                                $(el).addClass('current-step');
+                            }
+                        }
+                    });
+                }
+
+            } else {
+                if (self.options.nextSlide) {
+                    self.options.nextSlide();
+                }
+                // Scroll bottom
+                self._ignoreHashChange = true;
+                if(self.$current.next().attr('id'))
+                    self.setHash(self.$current.next().attr('id'));
+
+                self.$current.removeClass('current')
+                    .css({display:'none'})
+                    .next().addClass('current').nextAll().css({display:'block'});
+
+                // Cache
+                self.$current = self.$element.find('.current');
+                self.$fixed = self.$current.find('.fixed');
+                self.$step = self.$current.find('.step');
+                self.currentP = parseInt(self.$current.attr('data-position'), 10);
+                self.currentHeight = parseInt(self.$current.attr('data-height'), 10);
+            }
+
+
+        },
+        scrollMobileEvent: function() {
+            var self = this;
+
+            var docTop = self.$element.scrollTop(),
+                $current = self.$element.find('.current'),
+                $step = $current.find('.step'),
+                currentP = parseInt($current.attr('data-position'), 10),
+                currentHeight = parseInt($current.attr('data-height'), 10),
+                windowHeight = $(window).height();
+
+            if(docTop+10 < currentP && $current.index() > 0){
+                $current.removeClass('current').prev().addClass('current');
+            } else if(docTop+10 < (currentP + $current.height())){
+
+                // If there is a step element in the current panel
+                if($step.length){
+                    $.each($step, function(i,el){
+                        if(($(el).position().top+currentP) <= docTop && (($(el).position().top+currentP) + $(el).outerHeight()) >= docTop){
+                            if(!$(el).hasClass('current-step')){
+                                $step.removeClass('current-step');
+                                $(el).addClass('current-step');
+                            }
+                        }
+                    });
+                }
+
+            } else {
+                $current.removeClass('current').next().addClass('current');
+            }
+
+
+        },
+        // Setters
+        setDimensions: function(){
+            var windowHeight = $(window).height(),
+                levelHeight = 0,
+                cover = false,
+                height = null;
+
+            this.$li.each(function(index) {
+                var $self = $(this);
+                cover = $self.hasClass('cover');
+
+                if(cover){
+                    $self.css({height: windowHeight, zIndex: 999-index})
+                        .attr('data-height',windowHeight)
+                        .attr('data-position',levelHeight);
+                    levelHeight += windowHeight;
+                } else{
+                    height = ($self.outerHeight() <= windowHeight) ? windowHeight : $self.outerHeight();
+                    $self.css({minHeight: height, zIndex: 999-index})
+                        .attr('data-height',height)
+                        .attr('data-position',levelHeight);
+                    levelHeight += height;
+                }
+
+                if($self.find('.fixed').length){
+                    var top = $self.find('.fixed').css('top');
+                    $self.find('.fixed').attr('data-top', top);
+                }
+            });
+            if(!this.options.mobile)
+                this.setBodyHeight();
+        },
+        setEvents: function() {
+            var self = this;
+
+            $(window).on('resize', function(){
+                self.setDimensions();
+            });
+
+            if(self.options.mobile) {
+                self.$element.on('scroll', function(){
+                    self.scrollMobileEvent();
+                });
+            } else {
+                $(window).on('scroll', function(){
+                    self.scrollEvent();
+                });
+            }
+            
+            if(self.options.enableKeys) {
+                $(document).on('keydown', function(e){
+                    if(e.keyCode === 38 || e.keyCode === 37) {
+                        self.scrollToPosition('up');
+                        e.preventDefault();
+                        return false;
+                    }
+                    if(e.keyCode === 40 || e.keyCode === 39){
+                        self.scrollToPosition('down');
+                        e.preventDefault();
+                        return false;
+                    }
+                    // Home button
+                    if(e.keyCode === 36){
+                        self.scrollToPosition('top');
+                        e.preventDefault();
+                        return false;
+                    }
+                    // End button
+                    if(e.keyCode === 35){
+                        self.scrollToPosition('bottom');
+                        e.preventDefault();
+                        return false;
+                    }
+                });
+            }
+
+            if(self.options.scrollButtons){
+                if(self.options.scrollButtons.up){
+                    self.options.scrollButtons.up.on('click', function(e){
+                        e.preventDefault();
+                        self.scrollToPosition('up');
+                    });
+                }
+                if(self.options.scrollButtons.down){
+                    self.options.scrollButtons.down.on('click', function(e){
+                        e.preventDefault();
+                        self.scrollToPosition('down');
+                    });
+                }
+            }
+
+            if(self.options.curtainLinks){
+                $(self.options.curtainLinks).on('click', function(e){
+                    e.preventDefault();
+                    var href = $(this).attr('href');
+                    
+                    if(!self.isHashIsOnList(href.substring(1)) && position)
+                        return false;
+
+                    var position = $(href).attr('data-position') || null;
+                    if(position){
+                        self.scrollEl.animate({
+                            scrollTop:position
+                        }, self.options.scrollSpeed, self.options.easing);
+                    }
+                    return false;
+                });
+            }
+
+            if ("onhashchange" in window) {
+                window.addEventListener("hashchange", function(){
+                    if(self._ignoreHashChange === false){
+                        self.isHashIsOnList(location.hash.substring(1));
+                    }
+                    self._ignoreHashChange = false;
+                }, false);
+            }
+        },
+        setBodyHeight: function(){
+            var h = 0;
+            this.$li.each(function() {
+               h += $(this).height();
+            });
+            this.options.bodyHeight = h;
+            $('body').height(h);
+        },
+        setLinks: function(){
+            var self = this;
+            this.$li.each(function() {
+                var id = $(this).attr('id') || 0;
+                self.options.linksArray.push(id);
+            });
+        },
+        setHash: function(hash){
+            if(history.pushState) {
+                history.pushState(null, null, '#'+hash);
+            }
+            else {
+                location.hash = hash;
+            }
+        },
+        // Utils
+        isHashIsOnList: function(hash){
+            var self = this;
+            $.each(self.options.linksArray, function(i,val){
+                if(val === hash){
+                    self.scrollToPosition(hash);
+                    return false;
+                }
+            });
+        },
+        readyElement: function(el,callback){
+          var interval = setInterval(function(){
+            if(el.length){
+              callback(el.length);
+              clearInterval(interval);
+            }
+          },60);
+        }
+    };
+
+
+
+    $.fn[pluginName] = function ( options ) {
+        return this.each(function () {
+            if (!$.data(this, 'plugin_' + pluginName)) {
+                $.data(this, 'plugin_' + pluginName, new Plugin( this, options ));
+            }
+        });
+    };
+
+
+})( jQuery, window, document );

about/js/jquery.scrollorama.js

@@ -0,0 +1,519 @@
+/*
+	scrollorama - The jQuery plugin for doing cool scrolly stuff
+	by John Polacek (@johnpolacek)
+	
+	Dual licensed under MIT and GPL.
+*/
+
+(function($) {
+    $.scrollorama = function(options) {
+		var scrollorama = this,
+			blocks = [],
+			browserPrefix = '',
+			onBlockChange = function() {},
+			latestKnownScrollY = 0,
+            ticking = false,
+            requestAnimFrame =	window.requestAnimationFrame ||
+								window.webkitRequestAnimationFrame ||
+								window.mozRequestAnimationFrame    ||
+								window.oRequestAnimationFrame      ||
+								window.msRequestAnimationFrame     ||
+								function( callback ){
+									window.setTimeout(callback, 1000 / 60);
+								},
+			defaults = {offset:0, enablePin: true};
+		
+		scrollorama.settings = $.extend({}, defaults, options);
+		scrollorama.blockIndex = 0;
+		
+		if (options.blocks === undefined) { alert('ERROR: Must assign blocks class selector to scrollorama plugin'); }
+		
+		// PRIVATE FUNCTIONS
+		function init() {
+			var i, block, didScroll, marginTop = false;
+			if (typeof scrollorama.settings.blocks === 'string') { scrollorama.settings.blocks = $(scrollorama.settings.blocks); }
+			
+			// set browser prefix
+			if ($.browser.mozilla) { browserPrefix = '-moz-'; }
+			if ($.browser.webkit) { browserPrefix = '-webkit-'; }
+			if ($.browser.opera) { browserPrefix = '-o-'; }
+			if ($.browser.msie) { browserPrefix = '-ms-'; }
+			
+			// create blocks array to contain animation props
+			$('body').css('position','relative');
+			for (i=0; i<scrollorama.settings.blocks.length; i++) {
+				block = scrollorama.settings.blocks.eq(i);
+				marginTop = block.css('margin-top');
+				blocks.push({
+					block: block,
+					top: block.offset().top - (!Boolean(marginTop) ? parseInt(marginTop, 10) : 0),
+					pin: 0,
+					animations:[]
+				});
+			}
+			
+			// convert block elements to absolute position
+			if (scrollorama.settings.enablePin.toString() === 'true') {
+				for (i=0; i<blocks.length; i++) {
+					blocks[i].block
+						.css('position', 'absolute')
+						.css('top', blocks[i].top);
+				}
+			}
+			
+			$('body').prepend('<div id="scroll-wrap"></div>');
+			
+			latestKnownScrollY = 0;
+            ticking = false;
+            $(window).on( 'scroll.scrollorama', onScroll );
+		}
+
+		function onScroll() {
+            latestKnownScrollY = window.scrollY;
+            requestTick();
+        }
+        
+        function requestTick() {
+            if(!ticking) {
+                requestAnimFrame(function(){
+                    onScrollorama();
+                    update();
+                });
+            }
+            ticking = true;
+        }
+        
+        function update() {
+            // reset the tick so we can
+            // capture the next onScroll
+            ticking = false;
+        }
+		
+		function onScrollorama() {
+			var scrollTop = $(window).scrollTop(),
+			currBlockIndex = getCurrBlockIndex(scrollTop),
+			i, j, anim, startAnimPos, endAnimPos, animPercent, animVal;
+			
+			// update all animations
+			for (i=0; i<blocks.length; i++) {
+				
+				// go through the animations for each block
+				if (blocks[i].animations.length) {
+					for (j=0; j<blocks[i].animations.length; j++) {
+						anim = blocks[i].animations[j];
+						
+						// if above current block, settings should be at start value
+						if (i > currBlockIndex) {
+							if (currBlockIndex !== i-1 && anim.baseline !== 'bottom') {
+								setProperty(anim.element, anim.property, anim.startVal);
+							}
+							if (blocks[i].pin) {
+								blocks[i].block
+								.css('position', 'absolute')
+								.css('top', blocks[i].top);
+							}
+						}
+						
+						// if below current block, settings should be at end value
+						// unless on an element that gets animated when it hits the bottom of the viewport
+						else if (i < currBlockIndex) {
+							setProperty(anim.element, anim.property, anim.endVal);
+							if (blocks[i].pin) {
+								blocks[i].block
+                                    .css('position', 'absolute')
+                                    .css('top', (blocks[i].top + blocks[i].pin));
+							}
+						}
+						
+						// otherwise, set values per scroll position
+						if (i === currBlockIndex || (currBlockIndex === i-1 && anim.baseline === 'bottom')) {
+							// if block gets pinned, set position fixed
+							if (blocks[i].pin && currBlockIndex === i) {
+								blocks[i].block
+                                    .css('position', 'fixed')
+                                    .css('top', 0);
+							}
+							
+							// set start and end animation positions
+							startAnimPos = blocks[i].top + anim.delay;
+							if (anim.baseline === 'bottom') { startAnimPos -= $(window).height(); }
+							endAnimPos = startAnimPos + anim.duration;
+							
+							// if scroll is before start of animation, set to start value
+							if (scrollTop < startAnimPos) {
+								setProperty(anim.element, anim.property, anim.startVal);
+							}
+							
+							// if scroll is after end of animation, set to end value
+							else if (scrollTop > endAnimPos) {
+								setProperty(anim.element, anim.property, anim.endVal);
+								if (blocks[i].pin) {
+									blocks[i].block
+                                        .css('position', 'absolute')
+                                        .css('top', (blocks[i].top + blocks[i].pin));
+								}
+							}
+							
+							// otherwise, set value based on scroll
+							else {
+								// calculate percent to animate
+								animPercent = (scrollTop - startAnimPos) / anim.duration;
+								// account for easing if there is any
+								if ( anim.easing && $.isFunction( $.easing[anim.easing] ) ) {
+									animPercent = $.easing[anim.easing]( animPercent, animPercent*1000, 0, 1, 1000 );
+								}
+								// then multiply the percent by the value range and calculate the new value
+								animVal = anim.startVal + (animPercent * (anim.endVal - anim.startVal));
+								setProperty(anim.element, anim.property, animVal);
+							}
+						}
+					}
+				}
+			}
+			
+			// update blockIndex and trigger event if changed
+			if (scrollorama.blockIndex !== currBlockIndex) {
+				scrollorama.blockIndex = currBlockIndex;
+				onBlockChange();
+			}
+		}
+		
+		function getCurrBlockIndex(scrollTop) {
+			var currBlockIndex = 0, i;
+			for (i=0; i<blocks.length; i++) {
+				// check if block is in view
+				if (blocks[i].top <= scrollTop - scrollorama.settings.offset) { currBlockIndex = i; }
+			}
+			return currBlockIndex;
+		}
+		
+		function setProperty(target, prop, val) {
+			var scaleCSS, currentPosition;
+			if (prop === 'rotate' || prop === 'zoom' || prop === 'scale') {
+				if (prop === 'rotate') {
+					target.css(browserPrefix+'transform', 'rotate('+val+'deg)');
+				} else if (prop === 'zoom' || prop === 'scale') {
+					scaleCSS = 'scale('+val+')';
+					if (browserPrefix !== '-ms-') {
+						target.css(browserPrefix+'transform', scaleCSS);
+					} else {
+						target.css('zoom', scaleCSS);
+					}
+				}
+			}
+			else if(prop === 'background-position-x' || prop === 'background-position-y' ) {
+				currentPosition = target.css('background-position').split(' ');
+				if(prop === 'background-position-x') {
+					target.css('background-position',val+'px '+currentPosition[1]);
+				}
+				if(prop === 'background-position-y') {
+					target.css('background-position', currentPosition[0]+' '+val+'px');
+				}
+			}
+			else if(prop === 'text-shadow' ) {
+				target.css(prop,'0px 0px '+val+'px #ffffff');
+			} else {
+				target.css(prop, val);
+			}
+		}
+		
+		
+		// PUBLIC FUNCTIONS
+		scrollorama.animate = function(target) {
+			var targetIndex,
+				targetBlock,
+				anim,
+				offset,
+				i, j;
+			/*
+				target		= animation target
+				arguments	= array of animation parameters
+				anim		= object that contains all animation params (created from arguments)
+				offset		= positioning helper for pinning
+				
+				animation parameters:
+				delay		= amount of scrolling (in pixels) before animation starts
+				duration	= amount of scrolling (in pixels) over which the animation occurs
+				property	= css property being animated
+				start		= start value of the property
+				end			= end value of the property
+				pin			= pin block during animation duration (applies to all animations within block)
+				baseline	= top (default, when block reaches top of viewport) or bottom (when block first comies into view)
+				easing		= just like jquery's easing functions
+			*/
+			
+			// if string, convert to DOM object
+			if (typeof target === 'string') { target = $(target); }
+			
+			// find block of target
+			for (i=0; i<blocks.length; i++) {
+				if (blocks[i].block.has(target).length) {
+					targetBlock = blocks[i];
+					targetIndex = i;
+				}
+			}
+			
+			// add each animation to the blocks animations array from function arguments
+			for (i=1; i<arguments.length; i++) {
+				
+				anim = arguments[i];
+				
+				// for top/left/right/bottom, set relative positioning if static
+				if (anim.property === 'top' || anim.property === 'left' || anim.property === 'bottom' || anim.property === 'right' ) {
+					if (target.css('position') === 'static') { target.css('position','relative'); }
+					// set anim.start, anim.end defaults
+					cssValue = parseInt(target.css(anim.property),10);
+					if (anim.start === undefined) {
+						anim.start = isNaN(cssValue) ? 0 : cssValue;
+					} else if (anim.end === undefined) {
+						anim.end = isNaN(cssValue) ? 0 : cssValue;
+					}
+				}
+				
+				// set anim.start/anim.end defaults for rotate, zoom/scale, letter-spacing
+				if (anim.property === 'rotate') {
+					if (anim.start === undefined) { anim.start = 0; }
+					if (anim.end === undefined) { anim.end = 0; }
+				} else if (anim.property === 'zoom' || anim.property === 'scale' ) {
+					if (anim.start === undefined) { anim.start = 1; }
+					if (anim.end === undefined) { anim.end = 1; }
+				} else if (anim.property === 'letter-spacing' && target.css(anim.property)) {
+					if (anim.start === undefined) { anim.start = 1; }
+					if (anim.end === undefined) { anim.end = 1; }
+				}
+				
+				if (anim.baseline === undefined) {
+					if (anim.pin || targetBlock.pin || targetIndex === 0) {
+						anim.baseline = 'top';
+					} else {
+						anim.baseline = 'bottom';
+					}
+				}
+				
+				if (anim.delay === undefined) { anim.delay = 0; }
+				
+				targetBlock.animations.push({
+					element: target,
+					delay: anim.delay,
+					duration: anim.duration,
+					property: anim.property,
+					startVal: anim.start !== undefined ? anim.start : parseInt(target.css(anim.property),10),	// if undefined, use current css value
+					endVal: anim.end !== undefined ? anim.end : parseInt(target.css(anim.property),10),			// if undefined, use current css value
+					baseline: anim.baseline !== undefined ? anim.baseline : 'bottom',
+					easing: anim.easing
+				});
+				
+				if (anim.pin) {
+					if (targetBlock.pin < anim.duration + anim.delay) {
+						offset = anim.duration + anim.delay - targetBlock.pin;
+						targetBlock.pin += offset;
+						
+						// adjust positions of blocks below target block
+						for (j=targetIndex+1; j<blocks.length; j++) {
+							blocks[j].top += offset;
+							blocks[j].block.css('top', blocks[j].top);
+						}
+					}
+				}
+			}
+			
+			onScrollorama();
+		};
+		
+		// function for passing blockChange event callback
+		scrollorama.onBlockChange = function(f) {
+			onBlockChange = f;
+		};
+		
+		// function for getting an array of scrollpoints
+		// (top of each animation block and animation element scroll start point)
+		scrollorama.getScrollpoints = function() {
+			var scrollpoints = [],i,j,anim;
+			for (i=0; i<blocks.length; i++) {
+				scrollpoints.push(blocks[i].top);
+				// go through the animations for each block
+				if (blocks[i].animations.length && blocks[i].pin > 0) {
+					for (j=0; j<blocks[i].animations.length; j++) {
+						anim = blocks[i].animations[j];
+						scrollpoints.push(blocks[i].top + anim.delay + anim.duration);
+					}
+				}
+			}
+			// make sure scrollpoints are in numeric order
+			scrollpoints.sort(function(a,b) {return a - b;});
+			return scrollpoints;
+		};
+		
+		// Remove scrollorama
+		scrollorama.destroy = function () {
+			// Remove animations
+			for (i=0; i<blocks.length; i++) {
+				// Remove CSS rules
+				blocks[i].block.css({
+					top: '',
+					position: ''
+				});
+				
+				// Remove scrolloroma-specific attributes
+				delete blocks[i].animations;
+				delete blocks[i].top;
+				delete blocks[i].pin;
+			}
+
+			// Unbind the window scroll event
+			$(window).off('scroll.scrollorama');
+			$('#scroll-wrap').remove();
+			
+			// Remove the scrolloroma object
+			delete scrollorama;
+		};
+		
+		
+		// INIT
+		init();
+		
+		return scrollorama;
+    };
+
+	//
+	//		Easing functions from jQuery UI
+	//
+	$.extend($.easing, {
+		def: 'easeOutQuad',
+		swing: function (x, t, b, c, d) {
+			//alert($.easing.default);
+			return $.easing[$.easing.def](x, t, b, c, d);
+		},
+		easeInQuad: function (x, t, b, c, d) {
+			return c*(t/=d)*t + b;
+		},
+		easeOutQuad: function (x, t, b, c, d) {
+			return -c *(t/=d)*(t-2) + b;
+		},
+		easeInOutQuad: function (x, t, b, c, d) {
+			if ((t/=d/2) < 1) { return c/2*t*t + b; }
+			return -c/2 * ((--t)*(t-2) - 1) + b;
+		},
+		easeInCubic: function (x, t, b, c, d) {
+			return c*(t/=d)*t*t + b;
+		},
+		easeOutCubic: function (x, t, b, c, d) {
+			return c*((t=t/d-1)*t*t + 1) + b;
+		},
+		easeInOutCubic: function (x, t, b, c, d) {
+			if ((t/=d/2) < 1) { return c/2*t*t*t + b; }
+			return c/2*((t-=2)*t*t + 2) + b;
+		},
+		easeInQuart: function (x, t, b, c, d) {
+			return c*(t/=d)*t*t*t + b;
+		},
+		easeOutQuart: function (x, t, b, c, d) {
+			return -c * ((t=t/d-1)*t*t*t - 1) + b;
+		},
+		easeInOutQuart: function (x, t, b, c, d) {
+			if ((t/=d/2) < 1) { return c/2*t*t*t*t + b; }
+			return -c/2 * ((t-=2)*t*t*t - 2) + b;
+		},
+		easeInQuint: function (x, t, b, c, d) {
+			return c*(t/=d)*t*t*t*t + b;
+		},
+		easeOutQuint: function (x, t, b, c, d) {
+			return c*((t=t/d-1)*t*t*t*t + 1) + b;
+		},
+		easeInOutQuint: function (x, t, b, c, d) {
+			if ((t/=d/2) < 1) { return c/2*t*t*t*t*t + b; }
+			return c/2*((t-=2)*t*t*t*t + 2) + b;
+		},
+		easeInSine: function (x, t, b, c, d) {
+			return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
+		},
+		easeOutSine: function (x, t, b, c, d) {
+			return c * Math.sin(t/d * (Math.PI/2)) + b;
+		},
+		easeInOutSine: function (x, t, b, c, d) {
+			return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
+		},
+		easeInExpo: function (x, t, b, c, d) {
+			return (t===0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
+		},
+		easeOutExpo: function (x, t, b, c, d) {
+			return (t===d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
+		},
+		easeInOutExpo: function (x, t, b, c, d) {
+			if (t===0) { return b; }
+			if (t===d) { return b+c; }
+			if ((t/=d/2) < 1) { return c/2 * Math.pow(2, 10 * (t - 1)) + b; }
+			return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
+		},
+		easeInCirc: function (x, t, b, c, d) {
+			return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
+		},
+		easeOutCirc: function (x, t, b, c, d) {
+			return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
+		},
+		easeInOutCirc: function (x, t, b, c, d) {
+			if ((t/=d/2) < 1) { return -c/2 * (Math.sqrt(1 - t*t) - 1) + b; }
+			return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
+		},
+		easeInElastic: function (x, t, b, c, d) {
+			var s=1.70158,p=0,a=c;
+			if (t===0) { return b; }
+			if ((t/=d)===1) { return b+c; }
+			if (!p) { p=d*0.3; }
+			if (a < Math.abs(c)) { a=c; s=p/4; }
+			else{ s = p/(2*Math.PI) * Math.asin (c/a); }
+			return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+		},
+		easeOutElastic: function (x, t, b, c, d) {
+			var s=1.70158,p=0,a=c;
+			if (t===0) { return b; }
+			if ((t/=d)===1) { return b+c; }
+			if (!p) { p=d*0.3; }
+			if (a < Math.abs(c)) { a=c; s=p/4; }
+			else { s = p/(2*Math.PI) * Math.asin (c/a); }
+			return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
+		},
+		easeInOutElastic: function (x, t, b, c, d) {
+			var s=1.70158,p=0,a=c;
+			if (t===0) { return b; }
+			if ((t/=d/2)===2) { return b+c; }
+			if (!p) { p=d*(0.3*1.5); }
+			if (a < Math.abs(c)) { a=c; s=p/4; }
+			else { s = p/(2*Math.PI) * Math.asin (c/a); }
+			if (t < 1) { return -0.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b; }
+			return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*0.5 + c + b;
+		},
+		easeInBack: function (x, t, b, c, d, s) {
+			if (s === undefined) { s = 1.70158; }
+			return c*(t/=d)*t*((s+1)*t - s) + b;
+		},
+		easeOutBack: function (x, t, b, c, d, s) {
+			if (s === undefined) { s = 1.70158; }
+			return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
+		},
+		easeInOutBack: function (x, t, b, c, d, s) {
+			if (s === undefined) { s = 1.70158; }
+			if ((t/=d/2) < 1) { return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b; }
+			return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
+		},
+		easeInBounce: function (x, t, b, c, d) {
+			return c - $.easing.easeOutBounce (x, d-t, 0, c, d) + b;
+		},
+		easeOutBounce: function (x, t, b, c, d) {
+			if ((t/=d) < (1/2.75)) {
+				return c*(7.5625*t*t) + b;
+			} else if (t < (2/2.75)) {
+				return c*(7.5625*(t-=(1.5/2.75))*t + 0.75) + b;
+			} else if (t < (2.5/2.75)) {
+				return c*(7.5625*(t-=(2.25/2.75))*t + 0.9375) + b;
+			} else {
+				return c*(7.5625*(t-=(2.625/2.75))*t + 0.984375) + b;
+			}
+		},
+		easeInOutBounce: function (x, t, b, c, d) {
+			if (t < d/2) { return $.easing.easeInBounce (x, t*2, 0, c, d) * 0.5 + b; }
+			return $.easing.easeOutBounce (x, t*2-d, 0, c, d) * 0.5 + c*0.5 + b;
+		}
+	});
+     
+})(jQuery);

about/js/scripts.js

@@ -0,0 +1,50 @@
+
+$(document).ready(function(){
+
+	$('.curtains>li').css('position', 'fixed');
+
+   $('.curtains').curtain();
+   
+	var scrollorama = $.scrollorama({
+		blocks:'.curtains'
+	});
+    
+    scrollorama.animate('#intro h1',{
+    	duration:200, property:'left', end:-860
+    });
+    
+    scrollorama.animate('#reset-photo',{
+    	delay:900, duration:993, property:'top', start:300, end:-300
+   	});
+   	 
+    scrollorama.animate('#simio-photo',{
+    	delay:993, duration:1986, property:'rotate', start:-10, end:10
+   	});
+   	
+   	scrollorama.animate('#pusset .btn',{
+    	delay:2700, duration:993, property:'left', start:-800, easing:'easeOutBounce'
+   	});
+   
+   	scrollorama.animate('#sakrecoer ul li:nth-child(1)',{
+        delay:2979, duration:993, property:'top', start:840, end: 690
+        });
+        scrollorama.animate('#sakrecoer ul li:nth-child(2)',{
+        delay:2979, duration:993, property:'top', start:800, end: 690
+        });
+        scrollorama.animate('#sakrecoer ul li:nth-child(3)',{
+        delay:2979, duration:993, property:'top', start:920, end: 630
+        });
+        scrollorama.animate('#sakrecoer ul li:nth-child(4)',{
+        delay:2979, duration:993, property:'top', start:880, end: 670
+        });
+        scrollorama.animate('#sakrecoer ul li:nth-child(5)',{
+        delay:2979, duration:993, property:'top', start:830, end: 710
+        });
+        scrollorama.animate('#sakrecoer ul li:nth-child(6)',{
+        delay:2979, duration:993, property:'top', start:960, end: 650
+        });
+   	
+   	scrollorama.animate('#final h2',{
+    	delay:4500, duration:900, property:'top', start:0, easing:'easeOutBounce'
+   	});
+});