Website templates

eat-restaurant-bootstrap-html5-template/js/classie.js

@@ -0,0 +1,80 @@
+/*!
+ * classie - class helper functions
+ * from bonzo https://github.com/ded/bonzo
+ * 
+ * classie.has( elem, 'my-class' ) -> true/false
+ * classie.add( elem, 'my-new-class' )
+ * classie.remove( elem, 'my-unwanted-class' )
+ * classie.toggle( elem, 'my-class' )
+ */
+
+/*jshint browser: true, strict: true, undef: true */
+/*global define: false */
+
+( function( window ) {
+
+'use strict';
+
+// class helper functions from bonzo https://github.com/ded/bonzo
+
+function classReg( className ) {
+  return new RegExp("(^|\\s+)" + className + "(\\s+|$)");
+}
+
+// classList support for class management
+// altho to be fair, the api sucks because it won't accept multiple classes at once
+var hasClass, addClass, removeClass;
+
+if ( 'classList' in document.documentElement ) {
+  hasClass = function( elem, c ) {
+    return elem.classList.contains( c );
+  };
+  addClass = function( elem, c ) {
+    elem.classList.add( c );
+  };
+  removeClass = function( elem, c ) {
+    elem.classList.remove( c );
+  };
+}
+else {
+  hasClass = function( elem, c ) {
+    return classReg( c ).test( elem.className );
+  };
+  addClass = function( elem, c ) {
+    if ( !hasClass( elem, c ) ) {
+      elem.className = elem.className + ' ' + c;
+    }
+  };
+  removeClass = function( elem, c ) {
+    elem.className = elem.className.replace( classReg( c ), ' ' );
+  };
+}
+
+function toggleClass( elem, c ) {
+  var fn = hasClass( elem, c ) ? removeClass : addClass;
+  fn( elem, c );
+}
+
+var classie = {
+  // full names
+  hasClass: hasClass,
+  addClass: addClass,
+  removeClass: removeClass,
+  toggleClass: toggleClass,
+  // short names
+  has: hasClass,
+  add: addClass,
+  remove: removeClass,
+  toggle: toggleClass
+};
+
+// transport
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( classie );
+} else {
+  // browser global
+  window.classie = classie;
+}
+
+})( window );

eat-restaurant-bootstrap-html5-template/js/colorfinder.js

@@ -0,0 +1,126 @@
+// Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
+// This work is free. You can redistribute it and/or modify it
+// under the terms of the WTFPL, Version 2
+// For more information see LICENSE.txt or http://www.wtfpl.net/
+//
+// For more information, the home page:
+// http://pieroxy.net/blog/pages/color-finder/index.html
+//
+// Detection of the most prominent color in an image
+// version 1.1.1
+
+function ColorFinder(colorFactorCallback) {
+  this.callback = colorFactorCallback;
+  this.getMostProminentColor = function(imgEl) {
+    var rgb = null;
+    if (!this.callback) this.callback = function() { return 1; };
+    var data = this.getImageData(imgEl);
+    rgb = this.getMostProminentRGBImpl(data, 6, rgb, this.callback);
+    rgb = this.getMostProminentRGBImpl(data, 4, rgb, this.callback);
+    rgb = this.getMostProminentRGBImpl(data, 2, rgb, this.callback);
+    rgb = this.getMostProminentRGBImpl(data, 0, rgb, this.callback);
+    return rgb;
+  };
+
+  this.getImageData = function(imgEl, degrade, rgbMatch, colorFactorCallback) {
+    
+    var rgb,
+        canvas = document.createElement('canvas'),
+        context = canvas.getContext && canvas.getContext('2d'),
+        data, width, height, key,
+        i = -4,
+        db={},
+        length,r,g,b,
+        count = 0;
+    
+    if (!context) {
+      return defaultRGB;
+    }
+    
+    height = canvas.height = imgEl.naturalHeight || imgEl.offsetHeight || imgEl.height;
+    width = canvas.width = imgEl.naturalWidth || imgEl.offsetWidth || imgEl.width;
+    
+    context.drawImage(imgEl, 0, 0);
+    
+    try {
+      data = context.getImageData(0, 0, width, height);
+    } catch(e) {
+      /* security error, img on diff domain */
+      return null;
+    }
+
+    length = data.data.length;
+    
+    var factor = Math.max(1,Math.round(length/5000));
+    var result = {};
+    
+    while ( (i += 4*factor) < length ) {
+      if (data.data[i+3]>32) {
+        key = (data.data[i]>>degrade) + "," + (data.data[i+1]>>degrade) + "," + (data.data[i+2]>>degrade);
+        if (!result.hasOwnProperty(key)) {
+          rgb = {r:data.data[i], g:data.data[i+1], b:data.data[i+2],count:1};
+          rgb.weight = this.callback(rgb.r, rgb.g, rgb.b);
+          if (rgb.weight<=0) rgb.weight = 1e-10;
+          result[key]=rgb;
+        } else {
+          rgb=result[key];
+          rgb.count++;
+        }
+      }
+    }
+
+    return result;
+
+  };
+  
+  this.getMostProminentRGBImpl = function(pixels, degrade, rgbMatch, colorFactorCallback) {
+    
+    var rgb = {r:0,g:0,b:0,count:0,d:degrade},
+        db={},
+        pixel,pixelKey,pixelGroupKey,
+        length,r,g,b,
+        count = 0;
+    
+    
+    for (pixelKey in pixels) {
+      pixel = pixels[pixelKey];
+      totalWeight = pixel.weight * pixel.count;
+      ++count;
+      if (this.doesRgbMatch(rgbMatch, pixel.r, pixel.g, pixel.b)) {
+        pixelGroupKey = (pixel.r>>degrade) + "," + (pixel.g>>degrade) + "," + (pixel.b>>degrade);
+        if (db.hasOwnProperty(pixelGroupKey))
+          db[pixelGroupKey]+=totalWeight;
+        else
+          db[pixelGroupKey]=totalWeight;
+      }
+    }
+    
+    for (i in db) {
+      data = i.split(",");
+      r = data[0];
+      g = data[1];
+      b = data[2];
+      count = db[i];
+      
+      if (count>rgb.count) {
+        rgb.count = count;
+        data = i.split(",");
+        rgb.r = r;
+        rgb.g = g;
+        rgb.b = b;
+      }
+    }
+    
+    return rgb;
+    
+  };
+
+  this.doesRgbMatch = function(rgb,r,g,b) {
+    if (rgb==null) return true;
+    r = r >> rgb.d;
+    g = g >> rgb.d;
+    b = b >> rgb.d;
+    return rgb.r == r && rgb.g == g && rgb.b == b;
+  }
+
+}

eat-restaurant-bootstrap-html5-template/js/contact.js

@@ -0,0 +1,85 @@
+//////CONTACT FORM VALIDATION
+jQuery(document).ready(function ($) {
+	
+	//if submit button is clicked
+	$('#submit').click(function () {		
+		
+		//Get the data from all the fields
+		var name = $('input[name=name]');
+		var email = $('input[name=email]');
+		var regx = /^([a-z0-9_\-\.])+\@([a-z0-9_\-\.])+\.([a-z]{2,4})$/i;
+		var comment = $('textarea[name=comment]');
+		var returnError = false;
+		
+		//Simple validation to make sure user entered something
+		//Add your own error checking here with JS, but also do some error checking with PHP.
+		//If error found, add hightlight class to the text field
+		if (name.val()=='') {
+			name.addClass('error');
+			returnError = true;
+		} else name.removeClass('error');
+		
+		if (email.val()=='') {
+			email.addClass('error');
+			returnError = true;
+		} else email.removeClass('error');		
+		
+		if(!regx.test(email.val())){
+          email.addClass('error');
+          returnError = true;
+		} else email.removeClass('error');
+		
+		
+		if (comment.val()=='') {
+			comment.addClass('error');
+			returnError = true;
+		} else comment.removeClass('error');
+		
+		// Highlight all error fields, then quit.
+		if(returnError == true){
+			return false;	
+		}
+		
+		//organize the data
+		
+		var data = 'name=' + name.val() + '&email=' + email.val() + '&comment='  + encodeURIComponent(comment.val());
+
+		//disabled all the text fields
+		$('.text').attr('disabled','true');
+		
+		//show the loading sign
+		$('.loading').show();
+		
+		//start the ajax
+		$.ajax({
+			//this is the php file that processes the data and sends email
+			url: "contact.php",	
+			
+			//GET method is used
+			type: "GET",
+
+			//pass the data			
+			data: data,		
+			
+			//Do not cache the page
+			cache: false,
+			
+			//success
+			success: function (html) {				
+				//if contact.php returned 1/true (send mail success)
+				if (html==1) {
+				
+					//show the success message
+					$('.done').fadeIn('slow');
+					
+					$(".form").find('input[type=text], textarea').val("");
+					
+				//if contact.php returned 0/false (send mail failed)
+				} else alert('Sorry, unexpected error. Please try again later.');				
+			}		
+		});
+		
+		//cancel the submit button default behaviours
+		return false;
+	});	
+});	

eat-restaurant-bootstrap-html5-template/js/custom.js

@@ -0,0 +1,59 @@
+jQuery(function($) {
+
+    'use strict';
+
+    $('#quote-carousel').carousel({
+        pause: true,
+        interval: 4000,
+    });
+
+    new WOW().init();
+
+    $(function() {
+        $('a[href*=#]:not([href=#])').click(function() {
+            if (location.pathname.replace(/^\//, '') == this.pathname.replace(/^\//, '') && location.hostname == this.hostname) {
+                var target = $(this.hash);
+                target = target.length ? target : $('[name=' + this.hash.slice(1) + ']');
+                if (target.length) {
+                    $('html,body').animate({
+                        scrollTop: target.offset().top - 40
+                    }, 1000);
+                    return false;
+                }
+            }
+        });
+    });
+
+    $('#header_wrapper').scrollToFixed();
+    $('.res-nav_click').click(function() {
+        $('.mainNav').slideToggle();
+        return false
+
+    });
+
+    $('#main-nav').onePageNav({
+        currentClass: 'active',
+        changeHash: false,
+        scrollSpeed: 950,
+        scrollThreshold: 0.2,
+        filter: '',
+        easing: 'swing',
+        begin: function() {},
+        end: function() {
+            if (!$('#main-nav ul li:first-child').hasClass('active')) {
+                $('.header').addClass('addBg');
+            } else {
+                $('.header').removeClass('addBg');
+            }
+
+        },
+        scrollChange: function($currentListItem) {
+            if (!$('#main-nav ul li:first-child').hasClass('active')) {
+                $('.header').addClass('addBg');
+            } else {
+                $('.header').removeClass('addBg');
+            }
+        }
+    });
+
+});

eat-restaurant-bootstrap-html5-template/js/easing.js

@@ -0,0 +1,205 @@
+/*
+ * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
+ *
+ * Uses the built in easing capabilities added In jQuery 1.1
+ * to offer multiple easing options
+ *
+ * TERMS OF USE - jQuery Easing
+ * 
+ * Open source under the BSD License. 
+ * 
+ * Copyright © 2008 George McGinley Smith
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ * Redistributions of source code must retain the above copyright notice, this list of 
+ * conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list 
+ * of conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution.
+ * 
+ * Neither the name of the author nor the names of contributors may be used to endorse 
+ * or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ * OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *
+*/
+
+// t: current time, b: begInnIng value, c: change In value, d: duration
+jQuery.easing['jswing'] = jQuery.easing['swing'];
+
+jQuery.extend( jQuery.easing,
+{
+	def: 'easeOutQuad',
+	swing: function (x, t, b, c, d) {
+		//alert(jQuery.easing.default);
+		return jQuery.easing[jQuery.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;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var 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;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var 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;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var s = p/(2*Math.PI) * Math.asin (c/a);
+		if (t < 1) return -.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 )*.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 - jQuery.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 + .75) + b;
+		} else if (t < (2.5/2.75)) {
+			return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
+		} else {
+			return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
+		}
+	},
+	easeInOutBounce: function (x, t, b, c, d) {
+		if (t < d/2) return jQuery.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
+		return jQuery.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
+	}
+});
+
+/*
+ *
+ * TERMS OF USE - EASING EQUATIONS
+ * 
+ * Open source under the BSD License. 
+ * 
+ * Copyright © 2001 Robert Penner
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ * Redistributions of source code must retain the above copyright notice, this list of 
+ * conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list 
+ * of conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution.
+ * 
+ * Neither the name of the author nor the names of contributors may be used to endorse 
+ * or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ * OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *
+ */

eat-restaurant-bootstrap-html5-template/js/gallery.js

@@ -0,0 +1,528 @@
+/*
+* debouncedresize: special jQuery event that happens once after a window resize
+*
+* latest version and complete README available on Github:
+* https://github.com/louisremi/jquery-smartresize/blob/master/jquery.debouncedresize.js
+*
+* Copyright 2011 @louis_remi
+* Licensed under the MIT license.
+*/
+var $event = $.event,
+$special,
+resizeTimeout;
+
+$special = $event.special.debouncedresize = {
+	setup: function() {
+		$( this ).on( "resize", $special.handler );
+	},
+	teardown: function() {
+		$( this ).off( "resize", $special.handler );
+	},
+	handler: function( event, execAsap ) {
+		// Save the context
+		var context = this,
+			args = arguments,
+			dispatch = function() {
+				// set correct event type
+				event.type = "debouncedresize";
+				$event.dispatch.apply( context, args );
+			};
+
+		if ( resizeTimeout ) {
+			clearTimeout( resizeTimeout );
+		}
+
+		execAsap ?
+			dispatch() :
+			resizeTimeout = setTimeout( dispatch, $special.threshold );
+	},
+	threshold: 250
+};
+
+// ======================= imagesLoaded Plugin ===============================
+// https://github.com/desandro/imagesloaded
+
+// $('#my-container').imagesLoaded(myFunction)
+// execute a callback when all images have loaded.
+// needed because .load() doesn't work on cached images
+
+// callback function gets image collection as argument
+//  this is the container
+
+// original: MIT license. Paul Irish. 2010.
+// contributors: Oren Solomianik, David DeSandro, Yiannis Chatzikonstantinou
+
+// blank image data-uri bypasses webkit log warning (thx doug jones)
+var BLANK = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==';
+
+$.fn.imagesLoaded = function( callback ) {
+	var $this = this,
+		deferred = $.isFunction($.Deferred) ? $.Deferred() : 0,
+		hasNotify = $.isFunction(deferred.notify),
+		$images = $this.find('img').add( $this.filter('img') ),
+		loaded = [],
+		proper = [],
+		broken = [];
+
+	// Register deferred callbacks
+	if ($.isPlainObject(callback)) {
+		$.each(callback, function (key, value) {
+			if (key === 'callback') {
+				callback = value;
+			} else if (deferred) {
+				deferred[key](value);
+			}
+		});
+	}
+
+	function doneLoading() {
+		var $proper = $(proper),
+			$broken = $(broken);
+
+		if ( deferred ) {
+			if ( broken.length ) {
+				deferred.reject( $images, $proper, $broken );
+			} else {
+				deferred.resolve( $images );
+			}
+		}
+
+		if ( $.isFunction( callback ) ) {
+			callback.call( $this, $images, $proper, $broken );
+		}
+	}
+
+	function imgLoaded( img, isBroken ) {
+		// don't proceed if BLANK image, or image is already loaded
+		if ( img.src === BLANK || $.inArray( img, loaded ) !== -1 ) {
+			return;
+		}
+
+		// store element in loaded images array
+		loaded.push( img );
+
+		// keep track of broken and properly loaded images
+		if ( isBroken ) {
+			broken.push( img );
+		} else {
+			proper.push( img );
+		}
+
+		// cache image and its state for future calls
+		$.data( img, 'imagesLoaded', { isBroken: isBroken, src: img.src } );
+
+		// trigger deferred progress method if present
+		if ( hasNotify ) {
+			deferred.notifyWith( $(img), [ isBroken, $images, $(proper), $(broken) ] );
+		}
+
+		// call doneLoading and clean listeners if all images are loaded
+		if ( $images.length === loaded.length ){
+			setTimeout( doneLoading );
+			$images.unbind( '.imagesLoaded' );
+		}
+	}
+
+	// if no images, trigger immediately
+	if ( !$images.length ) {
+		doneLoading();
+	} else {
+		$images.bind( 'load.imagesLoaded error.imagesLoaded', function( event ){
+			// trigger imgLoaded
+			imgLoaded( event.target, event.type === 'error' );
+		}).each( function( i, el ) {
+			var src = el.src;
+
+			// find out if this image has been already checked for status
+			// if it was, and src has not changed, call imgLoaded on it
+			var cached = $.data( el, 'imagesLoaded' );
+			if ( cached && cached.src === src ) {
+				imgLoaded( el, cached.isBroken );
+				return;
+			}
+
+			// if complete is true and browser supports natural sizes, try
+			// to check for image status manually
+			if ( el.complete && el.naturalWidth !== undefined ) {
+				imgLoaded( el, el.naturalWidth === 0 || el.naturalHeight === 0 );
+				return;
+			}
+
+			// cached images don't fire load sometimes, so we reset src, but only when
+			// dealing with IE, or image is complete (loaded) and failed manual check
+			// webkit hack from http://groups.google.com/group/jquery-dev/browse_thread/thread/eee6ab7b2da50e1f
+			if ( el.readyState || el.complete ) {
+				el.src = BLANK;
+				el.src = src;
+			}
+		});
+	}
+
+	return deferred ? deferred.promise( $this ) : $this;
+};
+
+var ExpandPreview = (function() {
+
+		// list of items
+	var $grid = $( '#preview-grid' ),
+		// the items
+		$items = $grid.children( 'li' ),
+		// current expanded item's index
+		current = -1,
+		// position (top) of the expanded item
+		// used to know if the preview will expand in a different row
+		previewPos = -1,
+		// extra amount of pixels to scroll the window
+		scrollExtra = 0,
+		// extra margin when expanded (between preview overlay and the next items)
+		marginExpanded = 10,
+		$window = $( window ), winsize,
+		$body = $( 'html, body' ),
+		// transitionend events
+		transEndEventNames = {
+			'WebkitTransition' : 'webkitTransitionEnd',
+			'MozTransition' : 'transitionend',
+			'OTransition' : 'oTransitionEnd',
+			'msTransition' : 'MSTransitionEnd',
+			'transition' : 'transitionend'
+		},
+		transEndEventName = transEndEventNames[ Modernizr.prefixed( 'transition' ) ],
+		// support for csstransitions
+		support = Modernizr.csstransitions,
+		// default settings
+		settings = {
+			minHeight : 500,
+			speed : 350,
+			easing : 'ease'
+		};
+
+	function init( config ) {
+		
+		// the settings..
+		settings = $.extend( true, {}, settings, config );
+
+		// preload all images
+		$grid.imagesLoaded( function() {
+
+			// save item´s size and offset
+			saveItemInfo( true );
+			// get window´s size
+			getWinSize();
+			// initialize some events
+			initEvents();
+
+		} );
+
+	}
+
+	// add more items to the grid.
+	// the new items need to appended to the grid.
+	// after that call Grid.addItems(theItems);
+	function addItems( $newitems ) {
+
+		$items = $items.add( $newitems );
+
+		$newitems.each( function() {
+			var $item = $( this );
+			$item.data( {
+				offsetTop : $item.offset().top,
+				height : $item.height()
+			} );
+		} );
+
+		initItemsEvents( $newitems );
+
+	}
+
+	// saves the item´s offset top and height (if saveheight is true)
+	function saveItemInfo( saveheight ) {
+		$items.each( function() {
+			var $item = $( this );
+			$item.data( 'offsetTop', $item.offset().top );
+			if( saveheight ) {
+				$item.data( 'height', $item.height() );
+			}
+		} );
+	}
+
+	function initEvents() {
+		
+		// when clicking an item, show the preview with the item´s info and large image.
+		// close the item if already expanded.
+		// also close if clicking on the item´s cross
+		initItemsEvents( $items );
+		
+		// on window resize get the window´s size again
+		// reset some values..
+		$window.on( 'debouncedresize', function() {
+			
+			scrollExtra = 0;
+			previewPos = -1;
+			// save item´s offset
+			saveItemInfo();
+			getWinSize();
+			var preview = $.data( this, 'preview' );
+			if( typeof preview != 'undefined' ) {
+				hidePreview();
+			}
+
+		} );
+
+	}
+
+	function initItemsEvents( $items ) {
+		$items.on( 'click', 'span.preview-close', function() {
+			hidePreview();
+			return false;
+		} ).children( 'a' ).on( 'click', function(e) {
+
+			var $item = $( this ).parent();
+			// check if item already opened
+			current === $item.index() ? hidePreview() : showPreview( $item );
+			return false;
+
+		} );
+	}
+
+	function getWinSize() {
+		winsize = { width : $window.width(), height : $window.height() };
+	}
+
+	function showPreview( $item ) {
+
+		var preview = $.data( this, 'preview' ),
+			// item´s offset top
+			position = $item.data( 'offsetTop' );
+
+		scrollExtra = 0;
+
+		// if a preview exists and previewPos is different (different row) from item´s top then close it
+		if( typeof preview != 'undefined' ) {
+
+			// not in the same row
+			if( previewPos !== position ) {
+				// if position > previewPos then we need to take te current preview´s height in consideration when scrolling the window
+				if( position > previewPos ) {
+					scrollExtra = preview.height;
+				}
+				hidePreview();
+			}
+			// same row
+			else {
+				preview.update( $item );
+				return false;
+			}
+			
+		}
+
+		// update previewPos
+		previewPos = position;
+		// initialize new preview for the clicked item
+		preview = $.data( this, 'preview', new Preview( $item ) );
+		// expand preview overlay
+		preview.open();
+
+	}
+
+	function hidePreview() {
+		current = -1;
+		var preview = $.data( this, 'preview' );
+		preview.close();
+		$.removeData( this, 'preview' );
+	}
+
+	// the preview obj / overlay
+	function Preview( $item ) {
+		this.$item = $item;
+		this.expandedIdx = this.$item.index();
+		this.create();
+		this.update();
+	}
+
+	Preview.prototype = {
+		create : function() {
+			// create Preview structure:
+			this.$title = $( '<h3></h3>' );
+			this.$description = $( '<p></p>' );
+			this.$href = $( '<a href="#">Visit website</a>' );
+			this.$details = $( '<div class="preview-details"></div>' ).append( this.$title, this.$description, this.$href );
+			this.$loading = $( '<div class="preview-loading"></div>' );
+			this.$fullimage = $( '<div class="preview-fullimg"></div>' ).append( this.$loading );
+			this.$closePreview = $( '<span class="preview-close"></span>' );
+			this.$previewInner = $( '<div class="preview-expander-inner"></div>' ).append( this.$closePreview, this.$fullimage, this.$details );
+			this.$previewEl = $( '<div class="preview-expander"></div>' ).append( this.$previewInner );
+			// append preview element to the item
+			this.$item.append( this.getEl() );
+			// set the transitions for the preview and the item
+			if( support ) {
+				this.setTransition();
+			}
+		},
+		update : function( $item ) {
+
+			if( $item ) {
+				this.$item = $item;
+			}
+			
+			// if already expanded remove class "og-expanded" from current item and add it to new item
+			if( current !== -1 ) {
+				var $currentItem = $items.eq( current );
+				$currentItem.removeClass( 'preview-expanded' );
+				this.$item.addClass( 'preview-expanded' );
+				// position the preview correctly
+				this.positionPreview();
+			}
+
+			// update current value
+			current = this.$item.index();
+
+			// update preview´s content
+			var $itemEl = this.$item.children( 'a' ),
+				eldata = {
+					href : $itemEl.attr( 'href' ),
+					largesrc : $itemEl.data( 'largesrc' ),
+					title : $itemEl.data( 'title' ),
+					description : $itemEl.data( 'description' )
+				};
+
+			this.$title.html( eldata.title );
+			this.$description.html( eldata.description );
+			this.$href.attr( 'href', eldata.href );
+
+			var self = this;
+			
+			// remove the current image in the preview
+			if( typeof self.$largeImg != 'undefined' ) {
+				self.$largeImg.remove();
+			}
+
+			// preload large image and add it to the preview
+			// for smaller screens we don´t display the large image (the media query will hide the fullimage wrapper)
+			if( self.$fullimage.is( ':visible' ) ) {
+				this.$loading.show();
+				$( '<img/>' ).load( function() {
+					var $img = $( this );
+					if( $img.attr( 'src' ) === self.$item.children('a').data( 'largesrc' ) ) {
+						self.$loading.hide();
+						self.$fullimage.find( 'img' ).remove();
+						self.$largeImg = $img.fadeIn( 350 );
+						self.$fullimage.append( self.$largeImg );
+					}
+				} ).attr( 'src', eldata.largesrc );	
+			}
+
+		},
+		open : function() {
+
+			setTimeout( $.proxy( function() {	
+				// set the height for the preview and the item
+				this.setHeights();
+				// scroll to position the preview in the right place
+				this.positionPreview();
+			}, this ), 25 );
+
+		},
+		close : function() {
+
+			var self = this,
+				onEndFn = function() {
+					if( support ) {
+						$( this ).off( transEndEventName );
+					}
+					self.$item.removeClass( 'preview-expanded' );
+					self.$previewEl.remove();
+				};
+
+			setTimeout( $.proxy( function() {
+
+				if( typeof this.$largeImg !== 'undefined' ) {
+					this.$largeImg.fadeOut( 'fast' );
+				}
+				this.$previewEl.css( 'height', 0 );
+				// the current expanded item (might be different from this.$item)
+				var $expandedItem = $items.eq( this.expandedIdx );
+				$expandedItem.css( 'height', $expandedItem.data( 'height' ) ).on( transEndEventName, onEndFn );
+
+				if( !support ) {
+					onEndFn.call();
+				}
+
+			}, this ), 25 );
+			
+			return false;
+
+		},
+		calcHeight : function() {
+
+			var heightPreview = winsize.height - this.$item.data( 'height' ) - marginExpanded,
+				itemHeight = winsize.height;
+
+			if( heightPreview < settings.minHeight ) {
+				heightPreview = settings.minHeight;
+				itemHeight = settings.minHeight + this.$item.data( 'height' ) + marginExpanded;
+			}
+
+			this.height = heightPreview;
+			this.itemHeight = itemHeight;
+
+		},
+		setHeights : function() {
+
+			var self = this,
+				onEndFn = function() {
+					if( support ) {
+						self.$item.off( transEndEventName );
+					}
+					self.$item.addClass( 'preview-expanded' );
+				};
+
+			this.calcHeight();
+			this.$previewEl.css( 'height', this.height );
+			this.$item.css( 'height', this.itemHeight ).on( transEndEventName, onEndFn );
+
+			if( !support ) {
+				onEndFn.call();
+			}
+
+		},
+		positionPreview : function() {
+
+			// scroll page
+			// case 1 : preview height + item height fits in window´s height
+			// case 2 : preview height + item height does not fit in window´s height and preview height is smaller than window´s height
+			// case 3 : preview height + item height does not fit in window´s height and preview height is bigger than window´s height
+			var position = this.$item.data( 'offsetTop' ),
+				previewOffsetT = this.$previewEl.offset().top - scrollExtra,
+				scrollVal = this.height + this.$item.data( 'height' ) + marginExpanded <= winsize.height ? position : this.height < winsize.height ? previewOffsetT - ( winsize.height - this.height ) : previewOffsetT;
+			
+			$body.animate( { scrollTop : scrollVal }, settings.speed );
+
+		},
+		setTransition  : function() {
+			this.$previewEl.css( 'transition', 'height ' + settings.speed + 'ms ' + settings.easing );
+			this.$item.css( 'transition', 'height ' + settings.speed + 'ms ' + settings.easing );
+		},
+		getEl : function() {
+			return this.$previewEl;
+		}
+	}
+
+	return { 
+		init : init,
+		addItems : addItems
+	};
+
+})();
+
+
+
+
+
+
+
+
+
+
+$(function() {
+				ExpandPreview.init();
+			});

eat-restaurant-bootstrap-html5-template/js/gridscroll.js

@@ -0,0 +1,371 @@
+/**
+ * cbpGridGallery.js v1.0.0
+ * http://www.codrops.com
+ *
+ * Licensed under the MIT license.
+ * http://www.opensource.org/licenses/mit-license.php
+ * 
+ * Copyright 2014, Codrops
+ * http://www.codrops.com
+ */
+;( function( window ) {
+	
+	'use strict';
+
+	var docElem = window.document.documentElement,
+		transEndEventNames = {
+			'WebkitTransition': 'webkitTransitionEnd',
+			'MozTransition': 'transitionend',
+			'OTransition': 'oTransitionEnd',
+			'msTransition': 'MSTransitionEnd',
+			'transition': 'transitionend'
+		},
+		transEndEventName = transEndEventNames[ Modernizr.prefixed( 'transition' ) ],
+		support = {
+			transitions : Modernizr.csstransitions,
+			support3d : Modernizr.csstransforms3d
+		};
+
+	function setTransform( el, transformStr ) {
+		el.style.WebkitTransform = transformStr;
+		el.style.msTransform = transformStr;
+		el.style.transform = transformStr;
+	}
+
+	// from http://responsejs.com/labs/dimensions/
+	function getViewportW() {
+		var client = docElem['clientWidth'],
+			inner = window['innerWidth'];
+		
+		if( client < inner )
+			return inner;
+		else
+			return client;
+	}
+
+	function extend( a, b ) {
+		for( var key in b ) { 
+			if( b.hasOwnProperty( key ) ) {
+				a[key] = b[key];
+			}
+		}
+		return a;
+	}
+
+	function CBPGridGallery( el, options ) {
+		this.el = el;
+		this.options = extend( {}, this.options );
+  		extend( this.options, options );
+  		this._init();
+	}
+
+	CBPGridGallery.prototype.options = {
+	};
+
+	CBPGridGallery.prototype._init = function() {
+		// main grid
+		this.grid = this.el.querySelector( 'section.grid-wrap > ul.grid' );
+		// main grid items
+		this.gridItems = [].slice.call( this.grid.querySelectorAll( 'li:not(.grid-sizer)' ) );
+		// items total
+		this.itemsCount = this.gridItems.length;
+		// slideshow grid
+		this.slideshow = this.el.querySelector( 'section.slideshow > ul' );
+		// slideshow grid items
+		this.slideshowItems = [].slice.call( this.slideshow.children );
+		// index of current slideshow item
+		this.current = -1;
+		// slideshow control buttons
+		this.ctrlPrev = this.el.querySelector( 'section.slideshow > nav > span.nav-prev' );
+		this.ctrlNext = this.el.querySelector( 'section.slideshow > nav > span.nav-next' );
+		this.ctrlClose = this.el.querySelector( 'section.slideshow > nav > span.nav-close' );
+		// init masonry grid
+		this._initMasonry();
+		// init events
+		this._initEvents();
+	};
+
+	CBPGridGallery.prototype._initMasonry = function() {
+		var grid = this.grid;
+		imagesLoaded( grid, function() {
+			new Masonry( grid, {
+				itemSelector: 'li',
+				columnWidth: grid.querySelector( '.grid-sizer' )
+			});
+		});
+	};
+
+	CBPGridGallery.prototype._initEvents = function() {
+		var self = this;
+
+		// open the slideshow when clicking on the main grid items
+		this.gridItems.forEach( function( item, idx ) {
+			item.addEventListener( 'click', function() {
+				self._openSlideshow( idx );
+			} );
+		} );
+
+		// slideshow controls
+		this.ctrlPrev.addEventListener( 'click', function() { self._navigate( 'prev' ); } );
+		this.ctrlNext.addEventListener( 'click', function() { self._navigate( 'next' ); } );
+		this.ctrlClose.addEventListener( 'click', function() { self._closeSlideshow(); } );
+
+		// window resize
+		window.addEventListener( 'resize', function() { self._resizeHandler(); } );
+
+		// keyboard navigation events
+		document.addEventListener( 'keydown', function( ev ) {
+			if ( self.isSlideshowVisible ) {
+				var keyCode = ev.keyCode || ev.which;
+
+				switch (keyCode) {
+					case 37:
+						self._navigate( 'prev' );
+						break;
+					case 39:
+						self._navigate( 'next' );
+						break;
+					case 27:
+						self._closeSlideshow();
+						break;
+				}
+			}
+		} );
+
+		// trick to prevent scrolling when slideshow is visible
+		window.addEventListener( 'scroll', function() {
+			if ( self.isSlideshowVisible ) {
+				window.scrollTo( self.scrollPosition ? self.scrollPosition.x : 0, self.scrollPosition ? self.scrollPosition.y : 0 );
+			}
+			else {
+				self.scrollPosition = { x : window.pageXOffset || docElem.scrollLeft, y : window.pageYOffset || docElem.scrollTop };
+			}
+		});
+	};
+
+	CBPGridGallery.prototype._openSlideshow = function( pos ) {
+		this.isSlideshowVisible = true;
+		this.current = pos;
+
+		classie.addClass( this.el, 'slideshow-open' );
+
+		/* position slideshow items */
+
+		// set viewport items (current, next and previous)
+		this._setViewportItems();
+		
+		// add class "current" and "show" to currentItem
+		classie.addClass( this.currentItem, 'current' );
+		classie.addClass( this.currentItem, 'show' );
+
+		// add class show to next and previous items
+		// position previous item on the left side and the next item on the right side
+		if( this.prevItem ) {
+			classie.addClass( this.prevItem, 'show' );
+			var translateVal = Number( -1 * ( getViewportW() / 2 + this.prevItem.offsetWidth / 2 ) );
+			setTransform( this.prevItem, support.support3d ? 'translate3d(' + translateVal + 'px, 0, -150px)' : 'translate(' + translateVal + 'px)' );
+		}
+		if( this.nextItem ) {
+			classie.addClass( this.nextItem, 'show' );
+			var translateVal = Number( getViewportW() / 2 + this.nextItem.offsetWidth / 2 );
+			setTransform( this.nextItem, support.support3d ? 'translate3d(' + translateVal + 'px, 0, -150px)' : 'translate(' + translateVal + 'px)' );
+		}
+	};
+
+	CBPGridGallery.prototype._navigate = function( dir ) {
+		if( this.isAnimating ) return;
+		if( dir === 'next' && this.current === this.itemsCount - 1 ||  dir === 'prev' && this.current === 0  ) {
+			this._closeSlideshow();
+			return;
+		}
+
+		this.isAnimating = true;
+		
+		// reset viewport items
+		this._setViewportItems();
+
+		var self = this,
+			itemWidth = this.currentItem.offsetWidth,
+			// positions for the centered/current item, both the side items and the incoming ones
+			transformLeftStr = support.support3d ? 'translate3d(-' + Number( getViewportW() / 2 + itemWidth / 2 ) + 'px, 0, -150px)' : 'translate(-' + Number( getViewportW() / 2 + itemWidth / 2 ) + 'px)',
+			transformRightStr = support.support3d ? 'translate3d(' + Number( getViewportW() / 2 + itemWidth / 2 ) + 'px, 0, -150px)' : 'translate(' + Number( getViewportW() / 2 + itemWidth / 2 ) + 'px)',
+			transformCenterStr = '', transformOutStr, transformIncomingStr,
+			// incoming item
+			incomingItem;
+
+		if( dir === 'next' ) {
+			transformOutStr = support.support3d ? 'translate3d( -' + Number( (getViewportW() * 2) / 2 + itemWidth / 2 ) + 'px, 0, -150px )' : 'translate(-' + Number( (getViewportW() * 2) / 2 + itemWidth / 2 ) + 'px)';
+			transformIncomingStr = support.support3d ? 'translate3d( ' + Number( (getViewportW() * 2) / 2 + itemWidth / 2 ) + 'px, 0, -150px )' : 'translate(' + Number( (getViewportW() * 2) / 2 + itemWidth / 2 ) + 'px)';
+		}
+		else {
+			transformOutStr = support.support3d ? 'translate3d( ' + Number( (getViewportW() * 2) / 2 + itemWidth / 2 ) + 'px, 0, -150px )' : 'translate(' + Number( (getViewportW() * 2) / 2 + itemWidth / 2 ) + 'px)';
+			transformIncomingStr = support.support3d ? 'translate3d( -' + Number( (getViewportW() * 2) / 2 + itemWidth / 2 ) + 'px, 0, -150px )' : 'translate(-' + Number( (getViewportW() * 2) / 2 + itemWidth / 2 ) + 'px)';
+		}
+
+		// remove class animatable from the slideshow grid (if it has already)
+		classie.removeClass( self.slideshow, 'animatable' );
+
+		if( dir === 'next' && this.current < this.itemsCount - 2 || dir === 'prev' && this.current > 1 ) {
+			// we have an incoming item!
+			incomingItem = this.slideshowItems[ dir === 'next' ? this.current + 2 : this.current - 2 ];
+			setTransform( incomingItem, transformIncomingStr );
+			classie.addClass( incomingItem, 'show' );
+		}
+
+		var slide = function() {
+			// add class animatable to the slideshow grid
+			classie.addClass( self.slideshow, 'animatable' );
+
+			// overlays:
+			classie.removeClass( self.currentItem, 'current' );
+			var nextCurrent = dir === 'next' ? self.nextItem : self.prevItem;
+			classie.addClass( nextCurrent, 'current' );
+
+			setTransform( self.currentItem, dir === 'next' ? transformLeftStr : transformRightStr );
+
+			if( self.nextItem ) {
+				setTransform( self.nextItem, dir === 'next' ? transformCenterStr : transformOutStr );
+			}
+
+			if( self.prevItem ) {
+				setTransform( self.prevItem, dir === 'next' ? transformOutStr : transformCenterStr );
+			}
+
+			if( incomingItem ) {
+				setTransform( incomingItem, dir === 'next' ? transformRightStr : transformLeftStr );
+			}
+
+			var onEndTransitionFn = function( ev ) {
+				if( support.transitions ) {
+					if( ev.propertyName.indexOf( 'transform' ) === -1 ) return false;
+					this.removeEventListener( transEndEventName, onEndTransitionFn );
+				}
+
+				if( self.prevItem && dir === 'next' ) {
+					classie.removeClass( self.prevItem, 'show' );
+				}
+				else if( self.nextItem && dir === 'prev' ) {
+					classie.removeClass( self.nextItem, 'show' );
+				}
+
+				if( dir === 'next' ) {
+					self.prevItem = self.currentItem;
+					self.currentItem = self.nextItem;
+					if( incomingItem ) {
+						self.nextItem = incomingItem;
+					}
+				}
+				else {
+					self.nextItem = self.currentItem;
+					self.currentItem = self.prevItem;
+					if( incomingItem ) {
+						self.prevItem = incomingItem;
+					}
+				}
+
+				self.current = dir === 'next' ? self.current + 1 : self.current - 1;
+				self.isAnimating = false;
+			};
+
+			if( support.transitions ) {
+				self.currentItem.addEventListener( transEndEventName, onEndTransitionFn );
+			}
+			else {
+				onEndTransitionFn();
+			}
+		};
+
+		setTimeout( slide, 25 );
+	}
+
+	CBPGridGallery.prototype._closeSlideshow = function( pos ) {
+		// remove class slideshow-open from the grid gallery elem
+		classie.removeClass( this.el, 'slideshow-open' );
+		// remove class animatable from the slideshow grid
+		classie.removeClass( this.slideshow, 'animatable' );
+
+		var self = this,
+			onEndTransitionFn = function( ev ) {
+				if( support.transitions ) {
+					if( ev.target.tagName.toLowerCase() !== 'ul' ) return;
+					this.removeEventListener( transEndEventName, onEndTransitionFn );
+				}
+				// remove classes show and current from the slideshow items
+				classie.removeClass( self.currentItem, 'current' );
+				classie.removeClass( self.currentItem, 'show' );
+				
+				if( self.prevItem ) {
+					classie.removeClass( self.prevItem, 'show' );
+				}
+				if( self.nextItem ) {
+					classie.removeClass( self.nextItem, 'show' );
+				}
+
+				// also reset any transforms for all the items
+				self.slideshowItems.forEach( function( item ) { setTransform( item, '' ); } );
+
+				self.isSlideshowVisible = false;
+			};
+
+		if( support.transitions ) {
+			this.el.addEventListener( transEndEventName, onEndTransitionFn );
+		}
+		else {
+			onEndTransitionFn();
+		}
+	};
+
+	CBPGridGallery.prototype._setViewportItems = function() {
+		this.currentItem = null;
+		this.prevItem = null;
+		this.nextItem = null;
+
+		if( this.current > 0 ) {
+			this.prevItem = this.slideshowItems[ this.current - 1 ];
+		}
+		if( this.current < this.itemsCount - 1 ) {
+			this.nextItem = this.slideshowItems[ this.current + 1 ];
+		}
+		this.currentItem = this.slideshowItems[ this.current ];
+	}
+
+	// taken from https://github.com/desandro/vanilla-masonry/blob/master/masonry.js by David DeSandro
+	// original debounce by John Hann
+	// http://unscriptable.com/index.php/2009/03/20/debouncing-javascript-methods/
+	CBPGridGallery.prototype._resizeHandler = function() {
+		var self = this;
+		function delayed() {
+			self._resize();
+			self._resizeTimeout = null;
+		}
+		if ( this._resizeTimeout ) {
+			clearTimeout( this._resizeTimeout );
+		}
+		this._resizeTimeout = setTimeout( delayed, 50 );
+	}
+
+	CBPGridGallery.prototype._resize = function() {
+		if ( this.isSlideshowVisible ) {
+			// update width value
+			if( this.prevItem ) {
+				var translateVal = Number( -1 * ( getViewportW() / 2 + this.prevItem.offsetWidth / 2 ) );
+				setTransform( this.prevItem, support.support3d ? 'translate3d(' + translateVal + 'px, 0, -150px)' : 'translate(' + translateVal + 'px)' );
+			}
+			if( this.nextItem ) {
+				var translateVal = Number( getViewportW() / 2 + this.nextItem.offsetWidth / 2 );
+				setTransform( this.nextItem, support.support3d ? 'translate3d(' + translateVal + 'px, 0, -150px)' : 'translate(' + translateVal + 'px)' );
+			}
+		}
+	}
+
+	// add to global namespace
+	window.CBPGridGallery = CBPGridGallery;
+
+})( window );
+
+
+
+
+
+
+new CBPGridGallery( document.getElementById( 'grid-gallery' ) );

eat-restaurant-bootstrap-html5-template/js/jquery-scrolltofixed.js

@@ -0,0 +1,558 @@
+/*
+ * ScrollToFixed
+ * https://github.com/bigspotteddog/ScrollToFixed
+ * 
+ * Copyright (c) 2011 Joseph Cava-Lynch
+ * MIT license
+ */
+(function($) {
+    $.isScrollToFixed = function(el) {
+        return !!$(el).data('ScrollToFixed');
+    };
+
+    $.ScrollToFixed = function(el, options) {
+        // To avoid scope issues, use 'base' instead of 'this' to reference this
+        // class from internal events and functions.
+        var base = this;
+
+        // Access to jQuery and DOM versions of element.
+        base.$el = $(el);
+        base.el = el;
+
+        // Add a reverse reference to the DOM object.
+        base.$el.data('ScrollToFixed', base);
+
+        // A flag so we know if the scroll has been reset.
+        var isReset = false;
+
+        // The element that was given to us to fix if scrolled above the top of
+        // the page.
+        var target = base.$el;
+
+        var position;
+        var originalPosition;
+        var originalOffsetTop;
+        var originalZIndex;
+
+        // The offset top of the element when resetScroll was called. This is
+        // used to determine if we have scrolled past the top of the element.
+        var offsetTop = 0;
+
+        // The offset left of the element when resetScroll was called. This is
+        // used to move the element left or right relative to the horizontal
+        // scroll.
+        var offsetLeft = 0;
+        var originalOffsetLeft = -1;
+
+        // This last offset used to move the element horizontally. This is used
+        // to determine if we need to move the element because we would not want
+        // to do that for no reason.
+        var lastOffsetLeft = -1;
+
+        // This is the element used to fill the void left by the target element
+        // when it goes fixed; otherwise, everything below it moves up the page.
+        var spacer = null;
+
+        var spacerClass;
+
+        var className;
+
+        // Capture the original offsets for the target element. This needs to be
+        // called whenever the page size changes or when the page is first
+        // scrolled. For some reason, calling this before the page is first
+        // scrolled causes the element to become fixed too late.
+        function resetScroll() {
+            // Set the element to it original positioning.
+            target.trigger('preUnfixed.ScrollToFixed');
+            setUnfixed();
+            target.trigger('unfixed.ScrollToFixed');
+
+            // Reset the last offset used to determine if the page has moved
+            // horizontally.
+            lastOffsetLeft = -1;
+
+            // Capture the offset top of the target element.
+            offsetTop = target.offset().top;
+
+            // Capture the offset left of the target element.
+            offsetLeft = target.offset().left;
+
+            // If the offsets option is on, alter the left offset.
+            if (base.options.offsets) {
+                offsetLeft += (target.offset().left - target.position().left);
+            }
+
+            if (originalOffsetLeft == -1) {
+                originalOffsetLeft = offsetLeft;
+            }
+
+            position = target.css('position');
+
+            // Set that this has been called at least once.
+            isReset = true;
+
+            if (base.options.bottom != -1) {
+                target.trigger('preFixed.ScrollToFixed');
+                setFixed();
+                target.trigger('fixed.ScrollToFixed');
+            }
+        }
+
+        function getLimit() {
+            var limit = base.options.limit;
+            if (!limit) return 0;
+
+            if (typeof(limit) === 'function') {
+                return limit.apply(target);
+            }
+            return limit;
+        }
+
+        // Returns whether the target element is fixed or not.
+        function isFixed() {
+            return position === 'fixed';
+        }
+
+        // Returns whether the target element is absolute or not.
+        function isAbsolute() {
+            return position === 'absolute';
+        }
+
+        function isUnfixed() {
+            return !(isFixed() || isAbsolute());
+        }
+
+        // Sets the target element to fixed. Also, sets the spacer to fill the
+        // void left by the target element.
+        function setFixed() {
+            // Only fix the target element and the spacer if we need to.
+            if (!isFixed()) {
+                // Set the spacer to fill the height and width of the target
+                // element, then display it.
+                spacer.css({
+                    'display' : target.css('display'),
+                    'width' : target.outerWidth(true),
+                    'height' : target.outerHeight(true),
+                    'float' : target.css('float')
+                });
+
+                // Set the target element to fixed and set its width so it does
+                // not fill the rest of the page horizontally. Also, set its top
+                // to the margin top specified in the options.
+
+                cssOptions={
+                    'z-index' : base.options.zIndex,
+                    'position' : 'fixed',
+                    'top' : base.options.bottom == -1?getMarginTop():'',
+                    'bottom' : base.options.bottom == -1?'':base.options.bottom,
+                    'margin-left' : '0px'
+                }
+                if (!base.options.dontSetWidth){ cssOptions['width']=target.width(); };
+
+                target.css(cssOptions);
+                
+                target.addClass(base.options.baseClassName);
+                
+                if (base.options.className) {
+                    target.addClass(base.options.className);
+                }
+
+                position = 'fixed';
+            }
+        }
+
+        function setAbsolute() {
+
+            var top = getLimit();
+            var left = offsetLeft;
+
+            if (base.options.removeOffsets) {
+                left = '';
+                top = top - offsetTop;
+            }
+
+            cssOptions={
+              'position' : 'absolute',
+              'top' : top,
+              'left' : left,
+              'margin-left' : '0px',
+              'bottom' : ''
+            }
+            if (!base.options.dontSetWidth){ cssOptions['width']=target.width(); };
+
+            target.css(cssOptions);
+
+            position = 'absolute';
+        }
+
+        // Sets the target element back to unfixed. Also, hides the spacer.
+        function setUnfixed() {
+            // Only unfix the target element and the spacer if we need to.
+            if (!isUnfixed()) {
+                lastOffsetLeft = -1;
+
+                // Hide the spacer now that the target element will fill the
+                // space.
+                spacer.css('display', 'none');
+
+                // Remove the style attributes that were added to the target.
+                // This will reverse the target back to the its original style.
+                target.css({
+                    'z-index' : originalZIndex,
+                    'width' : '',
+                    'position' : originalPosition,
+                    'left' : '',
+                    'top' : originalOffsetTop,
+                    'margin-left' : ''
+                });
+
+                target.removeClass('scroll-to-fixed-fixed');
+
+                if (base.options.className) {
+                    target.removeClass(base.options.className);
+                }
+
+                position = null;
+            }
+        }
+
+        // Moves the target element left or right relative to the horizontal
+        // scroll position.
+        function setLeft(x) {
+            // Only if the scroll is not what it was last time we did this.
+            if (x != lastOffsetLeft) {
+                // Move the target element horizontally relative to its original
+                // horizontal position.
+                target.css('left', offsetLeft - x);
+
+                // Hold the last horizontal position set.
+                lastOffsetLeft = x;
+            }
+        }
+
+        function getMarginTop() {
+            var marginTop = base.options.marginTop;
+            if (!marginTop) return 0;
+
+            if (typeof(marginTop) === 'function') {
+                return marginTop.apply(target);
+            }
+            return marginTop;
+        }
+
+        // Checks to see if we need to do something based on new scroll position
+        // of the page.
+        function checkScroll() {
+            if (!$.isScrollToFixed(target)) return;
+            var wasReset = isReset;
+
+            // If resetScroll has not yet been called, call it. This only
+            // happens once.
+            if (!isReset) {
+                resetScroll();
+            } else if (isUnfixed()) {
+                // if the offset has changed since the last scroll,
+                // we need to get it again.
+
+                // Capture the offset top of the target element.
+                offsetTop = target.offset().top;
+
+                // Capture the offset left of the target element.
+                offsetLeft = target.offset().left;
+            }
+
+            // Grab the current horizontal scroll position.
+            var x = $(window).scrollLeft();
+
+            // Grab the current vertical scroll position.
+            var y = $(window).scrollTop();
+
+            // Get the limit, if there is one.
+            var limit = getLimit();
+
+            // If the vertical scroll position, plus the optional margin, would
+            // put the target element at the specified limit, set the target
+            // element to absolute.
+            if (base.options.minWidth && $(window).width() < base.options.minWidth) {
+                if (!isUnfixed() || !wasReset) {
+                    postPosition();
+                    target.trigger('preUnfixed.ScrollToFixed');
+                    setUnfixed();
+                    target.trigger('unfixed.ScrollToFixed');
+                }
+            } else if (base.options.maxWidth && $(window).width() > base.options.maxWidth) {
+                if (!isUnfixed() || !wasReset) {
+                    postPosition();
+                    target.trigger('preUnfixed.ScrollToFixed');
+                    setUnfixed();
+                    target.trigger('unfixed.ScrollToFixed');
+                }
+            } else if (base.options.bottom == -1) {
+                // If the vertical scroll position, plus the optional margin, would
+                // put the target element at the specified limit, set the target
+                // element to absolute.
+                if (limit > 0 && y >= limit - getMarginTop()) {
+                    if (!isAbsolute() || !wasReset) {
+                        postPosition();
+                        target.trigger('preAbsolute.ScrollToFixed');
+                        setAbsolute();
+                        target.trigger('unfixed.ScrollToFixed');
+                    }
+                // If the vertical scroll position, plus the optional margin, would
+                // put the target element above the top of the page, set the target
+                // element to fixed.
+                } else if (y >= offsetTop - getMarginTop()) {
+                    if (!isFixed() || !wasReset) {
+                        postPosition();
+                        target.trigger('preFixed.ScrollToFixed');
+
+                        // Set the target element to fixed.
+                        setFixed();
+
+                        // Reset the last offset left because we just went fixed.
+                        lastOffsetLeft = -1;
+
+                        target.trigger('fixed.ScrollToFixed');
+                    }
+                    // If the page has been scrolled horizontally as well, move the
+                    // target element accordingly.
+                    setLeft(x);
+                } else {
+                    // Set the target element to unfixed, placing it where it was
+                    // before.
+                    if (!isUnfixed() || !wasReset) {
+                        postPosition();
+                        target.trigger('preUnfixed.ScrollToFixed');
+                        setUnfixed();
+                        target.trigger('unfixed.ScrollToFixed');
+                    }
+                }
+            } else {
+                if (limit > 0) {
+                    if (y + $(window).height() - target.outerHeight(true) >= limit - (getMarginTop() || -getBottom())) {
+                        if (isFixed()) {
+                            postPosition();
+                            target.trigger('preUnfixed.ScrollToFixed');
+
+                            if (originalPosition === 'absolute') {
+                                setAbsolute();
+                            } else {
+                                setUnfixed();
+                            }
+
+                            target.trigger('unfixed.ScrollToFixed');
+                        }
+                    } else {
+                        if (!isFixed()) {
+                            postPosition();
+                            target.trigger('preFixed.ScrollToFixed');
+                            setFixed();
+                        }
+                        setLeft(x);
+                        target.trigger('fixed.ScrollToFixed');
+                    }
+                } else {
+                    setLeft(x);
+                }
+            }
+        }
+
+        function getBottom() {
+            if (!base.options.bottom) return 0;
+            return base.options.bottom;
+        }
+
+        function postPosition() {
+            var position = target.css('position');
+
+            if (position == 'absolute') {
+                target.trigger('postAbsolute.ScrollToFixed');
+            } else if (position == 'fixed') {
+                target.trigger('postFixed.ScrollToFixed');
+            } else {
+                target.trigger('postUnfixed.ScrollToFixed');
+            }
+        }
+
+        var windowResize = function(event) {
+            // Check if the element is visible before updating it's position, which
+            // improves behavior with responsive designs where this element is hidden.
+            if(target.is(':visible')) {
+                isReset = false;
+                checkScroll();
+            }
+        }
+
+        var windowScroll = function(event) {
+            (!!window.requestAnimationFrame) ? requestAnimationFrame(checkScroll) : checkScroll();
+        }
+
+        // From: http://kangax.github.com/cft/#IS_POSITION_FIXED_SUPPORTED
+        var isPositionFixedSupported = function() {
+            var container = document.body;
+
+            if (document.createElement && container && container.appendChild && container.removeChild) {
+                var el = document.createElement('div');
+
+                if (!el.getBoundingClientRect) return null;
+
+                el.innerHTML = 'x';
+                el.style.cssText = 'position:fixed;top:100px;';
+                container.appendChild(el);
+
+                var originalHeight = container.style.height,
+                originalScrollTop = container.scrollTop;
+
+                container.style.height = '3000px';
+                container.scrollTop = 500;
+
+                var elementTop = el.getBoundingClientRect().top;
+                container.style.height = originalHeight;
+
+                var isSupported = (elementTop === 100);
+                container.removeChild(el);
+                container.scrollTop = originalScrollTop;
+
+                return isSupported;
+            }
+
+            return null;
+        }
+
+        var preventDefault = function(e) {
+            e = e || window.event;
+            if (e.preventDefault) {
+                e.preventDefault();
+            }
+            e.returnValue = false;
+        }
+
+        // Initializes this plugin. Captures the options passed in, turns this
+        // off for devices that do not support fixed position, adds the spacer,
+        // and binds to the window scroll and resize events.
+        base.init = function() {
+            // Capture the options for this plugin.
+            base.options = $.extend({}, $.ScrollToFixed.defaultOptions, options);
+
+            originalZIndex = target.css('z-index')
+
+            // Turn off this functionality for devices that do not support it.
+            // if (!(base.options && base.options.dontCheckForPositionFixedSupport)) {
+            //     var fixedSupported = isPositionFixedSupported();
+            //     if (!fixedSupported) return;
+            // }
+
+            // Put the target element on top of everything that could be below
+            // it. This reduces flicker when the target element is transitioning
+            // to fixed.
+            base.$el.css('z-index', base.options.zIndex);
+
+            // Create a spacer element to fill the void left by the target
+            // element when it goes fixed.
+            spacer = $('<div />');
+
+            position = target.css('position');
+            originalPosition = target.css('position');
+
+            originalOffsetTop = target.css('top');
+
+            // Place the spacer right after the target element.
+            if (isUnfixed()) base.$el.after(spacer);
+
+            // Reset the target element offsets when the window is resized, then
+            // check to see if we need to fix or unfix the target element.
+            $(window).bind('resize.ScrollToFixed', windowResize);
+
+            // When the window scrolls, check to see if we need to fix or unfix
+            // the target element.
+            $(window).bind('scroll.ScrollToFixed', windowScroll);
+
+            // For touch devices, call checkScroll directlly rather than
+            // rAF wrapped windowScroll to animate the element
+            if ('ontouchmove' in window) {
+              $(window).bind('touchmove.ScrollToFixed', checkScroll);
+            }
+
+            if (base.options.preFixed) {
+                target.bind('preFixed.ScrollToFixed', base.options.preFixed);
+            }
+            if (base.options.postFixed) {
+                target.bind('postFixed.ScrollToFixed', base.options.postFixed);
+            }
+            if (base.options.preUnfixed) {
+                target.bind('preUnfixed.ScrollToFixed', base.options.preUnfixed);
+            }
+            if (base.options.postUnfixed) {
+                target.bind('postUnfixed.ScrollToFixed', base.options.postUnfixed);
+            }
+            if (base.options.preAbsolute) {
+                target.bind('preAbsolute.ScrollToFixed', base.options.preAbsolute);
+            }
+            if (base.options.postAbsolute) {
+                target.bind('postAbsolute.ScrollToFixed', base.options.postAbsolute);
+            }
+            if (base.options.fixed) {
+                target.bind('fixed.ScrollToFixed', base.options.fixed);
+            }
+            if (base.options.unfixed) {
+                target.bind('unfixed.ScrollToFixed', base.options.unfixed);
+            }
+
+            if (base.options.spacerClass) {
+                spacer.addClass(base.options.spacerClass);
+            }
+
+            target.bind('resize.ScrollToFixed', function() {
+                spacer.height(target.height());
+            });
+
+            target.bind('scroll.ScrollToFixed', function() {
+                target.trigger('preUnfixed.ScrollToFixed');
+                setUnfixed();
+                target.trigger('unfixed.ScrollToFixed');
+                checkScroll();
+            });
+
+            target.bind('detach.ScrollToFixed', function(ev) {
+                preventDefault(ev);
+
+                target.trigger('preUnfixed.ScrollToFixed');
+                setUnfixed();
+                target.trigger('unfixed.ScrollToFixed');
+
+                $(window).unbind('resize.ScrollToFixed', windowResize);
+                $(window).unbind('scroll.ScrollToFixed', windowScroll);
+
+                target.unbind('.ScrollToFixed');
+
+                //remove spacer from dom
+                spacer.remove();
+
+                base.$el.removeData('ScrollToFixed');
+            });
+
+            // Reset everything.
+            windowResize();
+        };
+
+        // Initialize the plugin.
+        base.init();
+    };
+
+    // Sets the option defaults.
+    $.ScrollToFixed.defaultOptions = {
+        marginTop : 0,
+        limit : 0,
+        bottom : -1,
+        zIndex : 1000,
+        baseClassName: 'scroll-to-fixed-fixed'
+    };
+
+    // Returns enhanced elements that will fix to the top of the page when the
+    // page is scrolled.
+    $.fn.scrollToFixed = function(options) {
+        return this.each(function() {
+            (new $.ScrollToFixed(this, options));
+        });
+    };
+})(jQuery);

eat-restaurant-bootstrap-html5-template/js/jquery.easing.1.3.js

@@ -0,0 +1,205 @@
+/*
+ * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
+ *
+ * Uses the built in easing capabilities added In jQuery 1.1
+ * to offer multiple easing options
+ *
+ * TERMS OF USE - jQuery Easing
+ * 
+ * Open source under the BSD License. 
+ * 
+ * Copyright © 2008 George McGinley Smith
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ * Redistributions of source code must retain the above copyright notice, this list of 
+ * conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list 
+ * of conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution.
+ * 
+ * Neither the name of the author nor the names of contributors may be used to endorse 
+ * or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ * OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *
+*/
+
+// t: current time, b: begInnIng value, c: change In value, d: duration
+jQuery.easing['jswing'] = jQuery.easing['swing'];
+
+jQuery.extend( jQuery.easing,
+{
+	def: 'easeOutQuad',
+	swing: function (x, t, b, c, d) {
+		//alert(jQuery.easing.default);
+		return jQuery.easing[jQuery.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;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var 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;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var 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;var p=0;var a=c;
+		if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
+		if (a < Math.abs(c)) { a=c; var s=p/4; }
+		else var s = p/(2*Math.PI) * Math.asin (c/a);
+		if (t < 1) return -.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 )*.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 - jQuery.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 + .75) + b;
+		} else if (t < (2.5/2.75)) {
+			return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
+		} else {
+			return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
+		}
+	},
+	easeInOutBounce: function (x, t, b, c, d) {
+		if (t < d/2) return jQuery.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
+		return jQuery.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
+	}
+});
+
+/*
+ *
+ * TERMS OF USE - EASING EQUATIONS
+ * 
+ * Open source under the BSD License. 
+ * 
+ * Copyright © 2001 Robert Penner
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ * Redistributions of source code must retain the above copyright notice, this list of 
+ * conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list 
+ * of conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution.
+ * 
+ * Neither the name of the author nor the names of contributors may be used to endorse 
+ * or promote products derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ * OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *
+ */

eat-restaurant-bootstrap-html5-template/js/jquery.nav.js

@@ -0,0 +1,226 @@
+/*
+ * jQuery One Page Nav Plugin
+ * http://github.com/davist11/jQuery-One-Page-Nav
+ *
+ * Copyright (c) 2010 Trevor Davis (http://trevordavis.net)
+ * Dual licensed under the MIT and GPL licenses.
+ * Uses the same license as jQuery, see:
+ * http://jquery.org/license
+ *
+ * @version 3.0.0
+ *
+ * Example usage:
+ * $('#nav').onePageNav({
+ *   currentClass: 'current',
+ *   changeHash: false,
+ *   scrollSpeed: 750
+ * });
+ */
+
+; (function ($, window, document, undefined) {
+
+    // our plugin constructor
+    var OnePageNav = function (elem, options) {
+        this.elem = elem;
+        this.$elem = $(elem);
+        this.options = options;
+        this.metadata = this.$elem.data('plugin-options');
+        this.$win = $(window);
+        this.sections = {};
+        this.didScroll = false;
+        this.$doc = $(document);
+        this.docHeight = this.$doc.height();
+    };
+
+    // the plugin prototype
+    OnePageNav.prototype = {
+        defaults: {
+            navItems: 'a',
+            currentClass: 'current',
+            changeHash: false,
+            easing: 'swing',
+            filter: '',
+			navHeight: 70,
+            scrollSpeed: 750,
+            scrollThreshold: 0.5,
+            begin: false,
+            end: false,
+            scrollChange: false
+        },
+
+        init: function () {
+            // Introduce defaults that can be extended either
+            // globally or using an object literal.
+            this.config = $.extend({}, this.defaults, this.options, this.metadata);
+
+            this.$nav = this.$elem.find(this.config.navItems);
+
+            //Filter any links out of the nav
+            if (this.config.filter !== '') {
+                this.$nav = this.$nav.filter(this.config.filter);
+            }
+
+            //Handle clicks on the nav
+            this.$nav.on('click.onePageNav', $.proxy(this.handleClick, this));
+
+            //Get the section positions
+            this.getPositions();
+
+            //Handle scroll changes
+            this.bindInterval();
+
+            //Update the positions on resize too
+            this.$win.on('resize.onePageNav', $.proxy(this.getPositions, this));
+
+            return this;
+        },
+
+        adjustNav: function (self, $parent) {
+            self.$elem.find('.' + self.config.currentClass).removeClass(self.config.currentClass);
+            $parent.addClass(self.config.currentClass);
+        },
+
+        bindInterval: function () {
+            var self = this;
+            var docHeight;
+
+            self.$win.on('scroll.onePageNav', function () {
+                self.didScroll = true;
+            });
+
+            self.t = setInterval(function () {
+                docHeight = self.$doc.height();
+
+                //If it was scrolled
+                if (self.didScroll) {
+                    self.didScroll = false;
+                    self.scrollChange();
+                }
+
+                //If the document height changes
+                if (docHeight !== self.docHeight) {
+                    self.docHeight = docHeight;
+                    self.getPositions();
+                }
+            }, 250);
+        },
+
+        getHash: function ($link) {
+            return $link.attr('href').split('#')[1];
+        },
+
+        getPositions: function () {
+            var self = this;
+            var linkHref;
+            var topPos;
+            var $target;
+
+            self.$nav.each(function () {
+                linkHref = self.getHash($(this));
+                $target = $('#' + linkHref);
+
+                if ($target.length) {
+                    topPos = $target.offset().top;
+
+                    self.sections[linkHref] = Math.round(topPos);
+                }
+            });
+        },
+
+        getSection: function (windowPos) {
+            var returnValue = null;
+            var windowHeight = Math.round(this.$win.height() * this.config.scrollThreshold);
+
+
+            for (var section in this.sections) {
+                if ((this.sections[section] - windowHeight) < windowPos) {
+                    returnValue = section;
+										
+                }
+            }
+
+            return returnValue;
+        },
+
+        handleClick: function (e) {
+            var self = this;
+            var $link = $(e.currentTarget);
+            var $parent = $link.parent();
+            var newLoc = '#' + self.getHash($link);
+
+            if (!$parent.hasClass(self.config.currentClass)) {
+                //Start callback
+                if (self.config.begin) {
+                    self.config.begin();
+                }
+
+                //Change the highlighted nav item
+                self.adjustNav(self, $parent);
+
+                //Removing the auto-adjust on scroll
+                self.unbindInterval();
+
+                //Scroll to the correct position
+                self.scrollTo(newLoc, function () {
+                    //Do we need to change the hash?
+                    if (self.config.changeHash) {
+                        window.location.hash = newLoc;
+                    }
+//				$('#aboutUs').offset({'top':'60'});
+                    //Add the auto-adjust on scroll back in
+                    self.bindInterval();
+
+                    //End callback
+                    if (self.config.end) {
+                        self.config.end();
+                    }
+                });
+            }
+
+            e.preventDefault();
+        },
+
+        scrollChange: function () {
+            var windowTop = this.$win.scrollTop();
+            var position = this.getSection(windowTop);
+            var $parent;
+
+            //If the position is set
+            if (position !== null) {
+                $parent = this.$elem.find('a[href$="#' + position + '"]').parent();
+
+                //If it's not already the current section
+                if (!$parent.hasClass(this.config.currentClass)) {
+                    //Change the highlighted nav item
+                    this.adjustNav(this, $parent);
+
+                    //If there is a scrollChange callback
+                    if (this.config.scrollChange) {
+                        this.config.scrollChange($parent);
+                    }
+                }
+            }
+        },
+
+        scrollTo: function (target, callback) {
+            var offset = $(target).offset().top - this.config.navHeight;
+            $('html, body').animate({
+                scrollTop: offset
+            }, this.config.scrollSpeed, this.config.easing, callback);
+        },
+
+        unbindInterval: function () {
+            clearInterval(this.t);
+            this.$win.unbind('scroll.onePageNav');
+        }
+    };
+
+    OnePageNav.defaults = OnePageNav.prototype.defaults;
+
+    $.fn.onePageNav = function (options) {
+        return this.each(function () {
+            new OnePageNav(this, options).init();
+        });
+    };
+
+})(jQuery, window, document);

eat-restaurant-bootstrap-html5-template/js/menustick.js

@@ -0,0 +1,124 @@
+jQuery(
+function($) {
+	
+	$(document).ready(function(){
+		var contentButton = [];
+		var contentTop = [];
+		var content = [];
+		var lastScrollTop = 0;
+		var scrollDir = '';
+		var itemClass = '';
+		var itemHover = '';
+		var menuSize = null;
+		var stickyHeight = 0;
+		var stickyMarginB = 0;
+		var currentMarginT = 0;
+		var topMargin = 0;
+		$(window).scroll(function(event){
+   			var st = $(this).scrollTop();
+   			if (st > lastScrollTop){
+       			scrollDir = 'down';
+   			} else {
+      			scrollDir = 'up';
+   			}
+  			lastScrollTop = st;
+		});
+		$.fn.stickUp = function( options ) {
+			// adding a class to users div
+			$(this).addClass('stuckMenu');
+        	//getting options
+        	var objn = 0;
+        	if(options != null) {
+	        	for(var o in options.parts) {
+	        		if (options.parts.hasOwnProperty(o)){
+	        			content[objn] = options.parts[objn];
+	        			objn++;
+	        		}
+	        	}
+	  			if(objn == 0) {
+	  				console.log('error:needs arguments');
+	  			}
+
+	  			itemClass = options.itemClass;
+	  			itemHover = options.itemHover;
+	  			if(options.topMargin != null) {
+	  				if(options.topMargin == 'auto') {
+	  					topMargin = parseInt($('.stuckMenu').css('margin-top'));
+	  				} else {
+	  					if(isNaN(options.topMargin) && options.topMargin.search("px") > 0){
+	  						topMargin = parseInt(options.topMargin.replace("px",""));
+	  					} else if(!isNaN(parseInt(options.topMargin))) {
+	  						topMargin = parseInt(options.topMargin);
+	  					} else {
+	  						console.log("incorrect argument, ignored.");
+	  						topMargin = 0;
+	  					}	
+	  				}
+	  			} else {
+	  				topMargin = 0;
+	  			}
+	  			menuSize = $('.'+itemClass).size();
+  			}			
+			stickyHeight = parseInt($(this).height());
+			stickyMarginB = parseInt($(this).css('margin-bottom'));
+			currentMarginT = parseInt($(this).next().closest('div').css('margin-top'));
+			vartop = parseInt($(this).offset().top);
+			//$(this).find('*').removeClass(itemHover);
+		}
+		$(document).on('scroll', function() {
+			varscroll = parseInt($(document).scrollTop());
+			if(menuSize != null){
+				for(var i=0;i < menuSize;i++)
+				{
+					contentTop[i] = $('#'+content[i]+'').offset().top;
+					function bottomView(i) {
+						contentView = $('#'+content[i]+'').height()*.4;
+						testView = contentTop[i] - contentView;
+						//console.log(varscroll);
+						if(varscroll > testView){
+							$('.'+itemClass).removeClass(itemHover);
+							$('.'+itemClass+':eq('+i+')').addClass(itemHover);
+						} else if(varscroll < 100){
+							$('.'+itemClass).removeClass(itemHover);
+							$('.'+itemClass+':eq(0)').addClass(itemHover);
+						}
+					}
+					if(scrollDir == 'down' && varscroll > contentTop[i]-100 && varscroll < contentTop[i]+100) {
+						$('.'+itemClass).removeClass(itemHover);
+						$('.'+itemClass+':eq('+i+')').addClass(itemHover);
+					}
+					if(scrollDir == 'up') {
+						bottomView(i);
+					}
+				}
+			}
+
+
+
+			if(vartop < varscroll + topMargin){
+				$('.wrapper').addClass('spHeight');
+				$('.stuckMenu').addClass('isFixed');
+				$('.stuckMenu').next().closest('div').css({
+					'margin-top': stickyHeight + stickyMarginB + currentMarginT + 'px'
+				}, 10);
+				$('.stuckMenu').css("position","fixed");
+				$('.isFixed').css({
+					top: '0px'
+				}, 10, function(){
+
+				});
+			};
+
+			if(varscroll + topMargin < vartop){
+				$('.wrapper').removeClass('spHeight');
+				$('.stuckMenu').removeClass('isFixed');
+				$('.stuckMenu').next().closest('div').css({
+					'margin-top': currentMarginT + 'px'
+				}, 10);
+				$('.stuckMenu').css("position","relative");
+			};
+
+		});
+	});
+
+});

eat-restaurant-bootstrap-html5-template/js/parallax.js

@@ -0,0 +1,69 @@
+/*
+Plugin: jQuery Parallax
+Version 1.1.3
+Author: Ian Lunn
+Twitter: @IanLunn
+Author URL: http://www.ianlunn.co.uk/
+Plugin URL: http://www.ianlunn.co.uk/plugins/jquery-parallax/
+
+Dual licensed under the MIT and GPL licenses:
+http://www.opensource.org/licenses/mit-license.php
+http://www.gnu.org/licenses/gpl.html
+*/
+
+(function( $ ){
+	var $window = $(window);
+	var windowHeight = $window.height();
+
+	$window.resize(function () {
+		windowHeight = $window.height();
+	});
+
+	$.fn.parallax = function(xpos, speedFactor, outerHeight) {
+		var $this = $(this);
+		var getHeight;
+		var firstTop;
+		var paddingTop = 0;
+		
+		//get the starting position of each element to have parallax applied to it		
+		$this.each(function(){
+		    firstTop = $this.offset().top;
+		});
+
+		if (outerHeight) {
+			getHeight = function(jqo) {
+				return jqo.outerHeight(true);
+			};
+		} else {
+			getHeight = function(jqo) {
+				return jqo.height();
+			};
+		}
+			
+		// setup defaults if arguments aren't specified
+		if (arguments.length < 1 || xpos === null) xpos = "50%";
+		if (arguments.length < 2 || speedFactor === null) speedFactor = 0.1;
+		if (arguments.length < 3 || outerHeight === null) outerHeight = true;
+		
+		// function to be called whenever the window is scrolled or resized
+		function update(){
+			var pos = $window.scrollTop();				
+
+			$this.each(function(){
+				var $element = $(this);
+				var top = $element.offset().top;
+				var height = getHeight($element);
+
+				// Check if totally above or totally below viewport
+				if (top + height < pos || top > pos + windowHeight) {
+					return;
+				}
+
+				$this.css('backgroundPosition', xpos + " " + Math.round((firstTop - pos) * speedFactor) + "px");
+			});
+		}		
+
+		$window.bind('scroll', update).resize(update);
+		update();
+	};
+})(jQuery);

eat-restaurant-bootstrap-html5-template/js/smoothscroll.js

@@ -0,0 +1,535 @@
+// SmoothScroll for websites v1.2.1
+// Licensed under the terms of the MIT license.
+
+// People involved
+//  - Balazs Galambosi (maintainer)  
+//  - Michael Herf     (Pulse Algorithm)
+
+(function(){
+  
+// Scroll Variables (tweakable)
+var defaultOptions = {
+
+    // Scrolling Core
+    frameRate        : 150, // [Hz]
+    animationTime    : 400, // [px]
+    stepSize         : 120, // [px]
+
+    // Pulse (less tweakable)
+    // ratio of "tail" to "acceleration"
+    pulseAlgorithm   : true,
+    pulseScale       : 8,
+    pulseNormalize   : 1,
+
+    // Acceleration
+    accelerationDelta : 20,  // 20
+    accelerationMax   : 1,   // 1
+
+    // Keyboard Settings
+    keyboardSupport   : true,  // option
+    arrowScroll       : 50,     // [px]
+
+    // Other
+    touchpadSupport   : true,
+    fixedBackground   : true, 
+    excluded          : ""    
+};
+
+var options = defaultOptions;
+
+
+// Other Variables
+var isExcluded = false;
+var isFrame = false;
+var direction = { x: 0, y: 0 };
+var initDone  = false;
+var root = document.documentElement;
+var activeElement;
+var observer;
+var deltaBuffer = [ 120, 120, 120 ];
+
+var key = { left: 37, up: 38, right: 39, down: 40, spacebar: 32, 
+            pageup: 33, pagedown: 34, end: 35, home: 36 };
+
+
+/***********************************************
+ * SETTINGS
+ ***********************************************/
+
+var options = defaultOptions;
+
+
+/***********************************************
+ * INITIALIZE
+ ***********************************************/
+
+/**
+ * Tests if smooth scrolling is allowed. Shuts down everything if not.
+ */
+function initTest() {
+
+    var disableKeyboard = false; 
+    
+    // disable keyboard support if anything above requested it
+    if (disableKeyboard) {
+        removeEvent("keydown", keydown);
+    }
+
+    if (options.keyboardSupport && !disableKeyboard) {
+        addEvent("keydown", keydown);
+    }
+}
+
+/**
+ * Sets up scrolls array, determines if frames are involved.
+ */
+function init() {
+  
+    if (!document.body) return;
+
+    var body = document.body;
+    var html = document.documentElement;
+    var windowHeight = window.innerHeight; 
+    var scrollHeight = body.scrollHeight;
+    
+    // check compat mode for root element
+    root = (document.compatMode.indexOf('CSS') >= 0) ? html : body;
+    activeElement = body;
+    
+    initTest();
+    initDone = true;
+
+    // Checks if this script is running in a frame
+    if (top != self) {
+        isFrame = true;
+    }
+
+    /**
+     * This fixes a bug where the areas left and right to 
+     * the content does not trigger the onmousewheel event
+     * on some pages. e.g.: html, body { height: 100% }
+     */
+    else if (scrollHeight > windowHeight &&
+            (body.offsetHeight <= windowHeight || 
+             html.offsetHeight <= windowHeight)) {
+
+        // DOMChange (throttle): fix height
+        var pending = false;
+        var refresh = function () {
+            if (!pending && html.scrollHeight != document.height) {
+                pending = true; // add a new pending action
+                setTimeout(function () {
+                    html.style.height = document.height + 'px';
+                    pending = false;
+                }, 500); // act rarely to stay fast
+            }
+        };
+        html.style.height = 'auto';
+        setTimeout(refresh, 10);
+
+        // clearfix
+        if (root.offsetHeight <= windowHeight) {
+            var underlay = document.createElement("div"); 	
+            underlay.style.clear = "both";
+            body.appendChild(underlay);
+        }
+    }
+
+    // disable fixed background
+    if (!options.fixedBackground && !isExcluded) {
+        body.style.backgroundAttachment = "scroll";
+        html.style.backgroundAttachment = "scroll";
+    }
+}
+
+
+/************************************************
+ * SCROLLING 
+ ************************************************/
+ 
+var que = [];
+var pending = false;
+var lastScroll = +new Date;
+
+/**
+ * Pushes scroll actions to the scrolling queue.
+ */
+function scrollArray(elem, left, top, delay) {
+    
+    delay || (delay = 1000);
+    directionCheck(left, top);
+
+    if (options.accelerationMax != 1) {
+        var now = +new Date;
+        var elapsed = now - lastScroll;
+        if (elapsed < options.accelerationDelta) {
+            var factor = (1 + (30 / elapsed)) / 2;
+            if (factor > 1) {
+                factor = Math.min(factor, options.accelerationMax);
+                left *= factor;
+                top  *= factor;
+            }
+        }
+        lastScroll = +new Date;
+    }          
+    
+    // push a scroll command
+    que.push({
+        x: left, 
+        y: top, 
+        lastX: (left < 0) ? 0.99 : -0.99,
+        lastY: (top  < 0) ? 0.99 : -0.99, 
+        start: +new Date
+    });
+        
+    // don't act if there's a pending queue
+    if (pending) {
+        return;
+    }  
+
+    var scrollWindow = (elem === document.body);
+    
+    var step = function (time) {
+        
+        var now = +new Date;
+        var scrollX = 0;
+        var scrollY = 0; 
+    
+        for (var i = 0; i < que.length; i++) {
+            
+            var item = que[i];
+            var elapsed  = now - item.start;
+            var finished = (elapsed >= options.animationTime);
+            
+            // scroll position: [0, 1]
+            var position = (finished) ? 1 : elapsed / options.animationTime;
+            
+            // easing [optional]
+            if (options.pulseAlgorithm) {
+                position = pulse(position);
+            }
+            
+            // only need the difference
+            var x = (item.x * position - item.lastX) >> 0;
+            var y = (item.y * position - item.lastY) >> 0;
+            
+            // add this to the total scrolling
+            scrollX += x;
+            scrollY += y;            
+            
+            // update last values
+            item.lastX += x;
+            item.lastY += y;
+        
+            // delete and step back if it's over
+            if (finished) {
+                que.splice(i, 1); i--;
+            }           
+        }
+
+        // scroll left and top
+        if (scrollWindow) {
+            window.scrollBy(scrollX, scrollY);
+        } 
+        else {
+            if (scrollX) elem.scrollLeft += scrollX;
+            if (scrollY) elem.scrollTop  += scrollY;                    
+        }
+        
+        // clean up if there's nothing left to do
+        if (!left && !top) {
+            que = [];
+        }
+        
+        if (que.length) { 
+            requestFrame(step, elem, (delay / options.frameRate + 1)); 
+        } else { 
+            pending = false;
+        }
+    };
+    
+    // start a new queue of actions
+    requestFrame(step, elem, 0);
+    pending = true;
+}
+
+
+/***********************************************
+ * EVENTS
+ ***********************************************/
+
+/**
+ * Mouse wheel handler.
+ * @param {Object} event
+ */
+function wheel(event) {
+
+    if (!initDone) {
+        init();
+    }
+    
+    var target = event.target;
+    var overflowing = overflowingAncestor(target);
+    
+    // use default if there's no overflowing
+    // element or default action is prevented    
+    if (!overflowing || event.defaultPrevented ||
+        isNodeName(activeElement, "embed") ||
+       (isNodeName(target, "embed") && /\.pdf/i.test(target.src))) {
+        return true;
+    }
+
+    var deltaX = event.wheelDeltaX || 0;
+    var deltaY = event.wheelDeltaY || 0;
+    
+    // use wheelDelta if deltaX/Y is not available
+    if (!deltaX && !deltaY) {
+        deltaY = event.wheelDelta || 0;
+    }
+
+    // check if it's a touchpad scroll that should be ignored
+    if (!options.touchpadSupport && isTouchpad(deltaY)) {
+        return true;
+    }
+
+    // scale by step size
+    // delta is 120 most of the time
+    // synaptics seems to send 1 sometimes
+    if (Math.abs(deltaX) > 1.2) {
+        deltaX *= options.stepSize / 120;
+    }
+    if (Math.abs(deltaY) > 1.2) {
+        deltaY *= options.stepSize / 120;
+    }
+    
+    scrollArray(overflowing, -deltaX, -deltaY);
+    event.preventDefault();
+}
+
+/**
+ * Keydown event handler.
+ * @param {Object} event
+ */
+function keydown(event) {
+
+    var target   = event.target;
+    var modifier = event.ctrlKey || event.altKey || event.metaKey || 
+                  (event.shiftKey && event.keyCode !== key.spacebar);
+    
+    // do nothing if user is editing text
+    // or using a modifier key (except shift)
+    // or in a dropdown
+    if ( /input|textarea|select|embed/i.test(target.nodeName) ||
+         target.isContentEditable || 
+         event.defaultPrevented   ||
+         modifier ) {
+      return true;
+    }
+    // spacebar should trigger button press
+    if (isNodeName(target, "button") &&
+        event.keyCode === key.spacebar) {
+      return true;
+    }
+    
+    var shift, x = 0, y = 0;
+    var elem = overflowingAncestor(activeElement);
+    var clientHeight = elem.clientHeight;
+
+    if (elem == document.body) {
+        clientHeight = window.innerHeight;
+    }
+
+    switch (event.keyCode) {
+        case key.up:
+            y = -options.arrowScroll;
+            break;
+        case key.down:
+            y = options.arrowScroll;
+            break;         
+        case key.spacebar: // (+ shift)
+            shift = event.shiftKey ? 1 : -1;
+            y = -shift * clientHeight * 0.9;
+            break;
+        case key.pageup:
+            y = -clientHeight * 0.9;
+            break;
+        case key.pagedown:
+            y = clientHeight * 0.9;
+            break;
+        case key.home:
+            y = -elem.scrollTop;
+            break;
+        case key.end:
+            var damt = elem.scrollHeight - elem.scrollTop - clientHeight;
+            y = (damt > 0) ? damt+10 : 0;
+            break;
+        case key.left:
+            x = -options.arrowScroll;
+            break;
+        case key.right:
+            x = options.arrowScroll;
+            break;            
+        default:
+            return true; // a key we don't care about
+    }
+
+    scrollArray(elem, x, y);
+    event.preventDefault();
+}
+
+/**
+ * Mousedown event only for updating activeElement
+ */
+function mousedown(event) {
+    activeElement = event.target;
+}
+
+
+/***********************************************
+ * OVERFLOW
+ ***********************************************/
+ 
+var cache = {}; // cleared out every once in while
+setInterval(function () { cache = {}; }, 10 * 1000);
+
+var uniqueID = (function () {
+    var i = 0;
+    return function (el) {
+        return el.uniqueID || (el.uniqueID = i++);
+    };
+})();
+
+function setCache(elems, overflowing) {
+    for (var i = elems.length; i--;)
+        cache[uniqueID(elems[i])] = overflowing;
+    return overflowing;
+}
+
+function overflowingAncestor(el) {
+    var elems = [];
+    var rootScrollHeight = root.scrollHeight;
+    do {
+        var cached = cache[uniqueID(el)];
+        if (cached) {
+            return setCache(elems, cached);
+        }
+        elems.push(el);
+        if (rootScrollHeight === el.scrollHeight) {
+            if (!isFrame || root.clientHeight + 10 < rootScrollHeight) {
+                return setCache(elems, document.body); // scrolling root in WebKit
+            }
+        } else if (el.clientHeight + 10 < el.scrollHeight) {
+            overflow = getComputedStyle(el, "").getPropertyValue("overflow-y");
+            if (overflow === "scroll" || overflow === "auto") {
+                return setCache(elems, el);
+            }
+        }
+    } while (el = el.parentNode);
+}
+
+
+/***********************************************
+ * HELPERS
+ ***********************************************/
+
+function addEvent(type, fn, bubble) {
+    window.addEventListener(type, fn, (bubble||false));
+}
+
+function removeEvent(type, fn, bubble) {
+    window.removeEventListener(type, fn, (bubble||false));  
+}
+
+function isNodeName(el, tag) {
+    return (el.nodeName||"").toLowerCase() === tag.toLowerCase();
+}
+
+function directionCheck(x, y) {
+    x = (x > 0) ? 1 : -1;
+    y = (y > 0) ? 1 : -1;
+    if (direction.x !== x || direction.y !== y) {
+        direction.x = x;
+        direction.y = y;
+        que = [];
+        lastScroll = 0;
+    }
+}
+
+var deltaBufferTimer;
+
+function isTouchpad(deltaY) {
+    if (!deltaY) return;
+    deltaY = Math.abs(deltaY)
+    deltaBuffer.push(deltaY);
+    deltaBuffer.shift();
+    clearTimeout(deltaBufferTimer);
+    var allDivisable = (isDivisible(deltaBuffer[0], 120) &&
+                        isDivisible(deltaBuffer[1], 120) &&
+                        isDivisible(deltaBuffer[2], 120));
+    return !allDivisable;
+} 
+
+function isDivisible(n, divisor) {
+    return (Math.floor(n / divisor) == n / divisor);
+}
+
+var requestFrame = (function () {
+      return  window.requestAnimationFrame       || 
+              window.webkitRequestAnimationFrame || 
+              function (callback, element, delay) {
+                  window.setTimeout(callback, delay || (1000/60));
+              };
+})();
+
+
+/***********************************************
+ * PULSE
+ ***********************************************/
+ 
+/**
+ * Viscous fluid with a pulse for part and decay for the rest.
+ * - Applies a fixed force over an interval (a damped acceleration), and
+ * - Lets the exponential bleed away the velocity over a longer interval
+ * - Michael Herf, http://stereopsis.com/stopping/
+ */
+function pulse_(x) {
+    var val, start, expx;
+    // test
+    x = x * options.pulseScale;
+    if (x < 1) { // acceleartion
+        val = x - (1 - Math.exp(-x));
+    } else {     // tail
+        // the previous animation ended here:
+        start = Math.exp(-1);
+        // simple viscous drag
+        x -= 1;
+        expx = 1 - Math.exp(-x);
+        val = start + (expx * (1 - start));
+    }
+    return val * options.pulseNormalize;
+}
+
+function pulse(x) {
+    if (x >= 1) return 1;
+    if (x <= 0) return 0;
+
+    if (options.pulseNormalize == 1) {
+        options.pulseNormalize /= pulse_(1);
+    }
+    return pulse_(x);
+}
+
+var isChrome = /chrome/i.test(window.navigator.userAgent);
+var wheelEvent = null;
+if ("onwheel" in document.createElement("div"))
+	wheelEvent = "wheel";
+else if ("onmousewheel" in document.createElement("div"))
+	wheelEvent = "mousewheel";
+
+if (wheelEvent && isChrome) {
+	addEvent(wheelEvent, wheel);
+	addEvent("mousedown", mousedown);
+	addEvent("load", init);
+}
+
+})();