" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
+
+ // Otherwise use the full result
+ responseText );
+
+ // If the request succeeds, this function gets "data", "status", "jqXHR"
+ // but they are ignored because response was set above.
+ // If it fails, this function gets "jqXHR", "status", "error"
+ } ).always( callback && function( jqXHR, status ) {
+ self.each( function() {
+ callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
+ } );
+ } );
+ }
+
+ return this;
+};
+
+
+
+
+// Attach a bunch of functions for handling common AJAX events
+jQuery.each( [
+ "ajaxStart",
+ "ajaxStop",
+ "ajaxComplete",
+ "ajaxError",
+ "ajaxSuccess",
+ "ajaxSend"
+], function( i, type ) {
+ jQuery.fn[ type ] = function( fn ) {
+ return this.on( type, fn );
+ };
+} );
+
+
+
+
+jQuery.expr.filters.animated = function( elem ) {
+ return jQuery.grep( jQuery.timers, function( fn ) {
+ return elem === fn.elem;
+ } ).length;
+};
+
+
+
+
+
+/**
+ * Gets a window from an element
+ */
+function getWindow( elem ) {
+ return jQuery.isWindow( elem ) ?
+ elem :
+ elem.nodeType === 9 ?
+ elem.defaultView || elem.parentWindow :
+ false;
+}
+
+jQuery.offset = {
+ setOffset: function( elem, options, i ) {
+ var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
+ position = jQuery.css( elem, "position" ),
+ curElem = jQuery( elem ),
+ props = {};
+
+ // set position first, in-case top/left are set even on static elem
+ if ( position === "static" ) {
+ elem.style.position = "relative";
+ }
+
+ curOffset = curElem.offset();
+ curCSSTop = jQuery.css( elem, "top" );
+ curCSSLeft = jQuery.css( elem, "left" );
+ calculatePosition = ( position === "absolute" || position === "fixed" ) &&
+ jQuery.inArray( "auto", [ curCSSTop, curCSSLeft ] ) > -1;
+
+ // need to be able to calculate position if either top or left
+ // is auto and position is either absolute or fixed
+ if ( calculatePosition ) {
+ curPosition = curElem.position();
+ curTop = curPosition.top;
+ curLeft = curPosition.left;
+ } else {
+ curTop = parseFloat( curCSSTop ) || 0;
+ curLeft = parseFloat( curCSSLeft ) || 0;
+ }
+
+ if ( jQuery.isFunction( options ) ) {
+
+ // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
+ options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
+ }
+
+ if ( options.top != null ) {
+ props.top = ( options.top - curOffset.top ) + curTop;
+ }
+ if ( options.left != null ) {
+ props.left = ( options.left - curOffset.left ) + curLeft;
+ }
+
+ if ( "using" in options ) {
+ options.using.call( elem, props );
+ } else {
+ curElem.css( props );
+ }
+ }
+};
+
+jQuery.fn.extend( {
+ offset: function( options ) {
+ if ( arguments.length ) {
+ return options === undefined ?
+ this :
+ this.each( function( i ) {
+ jQuery.offset.setOffset( this, options, i );
+ } );
+ }
+
+ var docElem, win,
+ box = { top: 0, left: 0 },
+ elem = this[ 0 ],
+ doc = elem && elem.ownerDocument;
+
+ if ( !doc ) {
+ return;
+ }
+
+ docElem = doc.documentElement;
+
+ // Make sure it's not a disconnected DOM node
+ if ( !jQuery.contains( docElem, elem ) ) {
+ return box;
+ }
+
+ // If we don't have gBCR, just use 0,0 rather than error
+ // BlackBerry 5, iOS 3 (original iPhone)
+ if ( typeof elem.getBoundingClientRect !== "undefined" ) {
+ box = elem.getBoundingClientRect();
+ }
+ win = getWindow( doc );
+ return {
+ top: box.top + ( win.pageYOffset || docElem.scrollTop ) - ( docElem.clientTop || 0 ),
+ left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
+ };
+ },
+
+ position: function() {
+ if ( !this[ 0 ] ) {
+ return;
+ }
+
+ var offsetParent, offset,
+ parentOffset = { top: 0, left: 0 },
+ elem = this[ 0 ];
+
+ // Fixed elements are offset from window (parentOffset = {top:0, left: 0},
+ // because it is its only offset parent
+ if ( jQuery.css( elem, "position" ) === "fixed" ) {
+
+ // we assume that getBoundingClientRect is available when computed position is fixed
+ offset = elem.getBoundingClientRect();
+ } else {
+
+ // Get *real* offsetParent
+ offsetParent = this.offsetParent();
+
+ // Get correct offsets
+ offset = this.offset();
+ if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
+ parentOffset = offsetParent.offset();
+ }
+
+ // Add offsetParent borders
+ parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
+ parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
+ }
+
+ // Subtract parent offsets and element margins
+ // note: when an element has margin: auto the offsetLeft and marginLeft
+ // are the same in Safari causing offset.left to incorrectly be 0
+ return {
+ top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
+ left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
+ };
+ },
+
+ offsetParent: function() {
+ return this.map( function() {
+ var offsetParent = this.offsetParent;
+
+ while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) &&
+ jQuery.css( offsetParent, "position" ) === "static" ) ) {
+ offsetParent = offsetParent.offsetParent;
+ }
+ return offsetParent || documentElement;
+ } );
+ }
+} );
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
+ var top = /Y/.test( prop );
+
+ jQuery.fn[ method ] = function( val ) {
+ return access( this, function( elem, method, val ) {
+ var win = getWindow( elem );
+
+ if ( val === undefined ) {
+ return win ? ( prop in win ) ? win[ prop ] :
+ win.document.documentElement[ method ] :
+ elem[ method ];
+ }
+
+ if ( win ) {
+ win.scrollTo(
+ !top ? val : jQuery( win ).scrollLeft(),
+ top ? val : jQuery( win ).scrollTop()
+ );
+
+ } else {
+ elem[ method ] = val;
+ }
+ }, method, val, arguments.length, null );
+ };
+} );
+
+// Support: Safari<7-8+, Chrome<37-44+
+// Add the top/left cssHooks using jQuery.fn.position
+// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+// getComputedStyle returns percent when specified for top/left/bottom/right
+// rather than make the css module depend on the offset module, we just check for it here
+jQuery.each( [ "top", "left" ], function( i, prop ) {
+ jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
+ function( elem, computed ) {
+ if ( computed ) {
+ computed = curCSS( elem, prop );
+
+ // if curCSS returns percentage, fallback to offset
+ return rnumnonpx.test( computed ) ?
+ jQuery( elem ).position()[ prop ] + "px" :
+ computed;
+ }
+ }
+ );
+} );
+
+
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
+ jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
+ function( defaultExtra, funcName ) {
+
+ // margin is only for outerHeight, outerWidth
+ jQuery.fn[ funcName ] = function( margin, value ) {
+ var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
+ extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
+
+ return access( this, function( elem, type, value ) {
+ var doc;
+
+ if ( jQuery.isWindow( elem ) ) {
+
+ // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
+ // isn't a whole lot we can do. See pull request at this URL for discussion:
+ // https://github.com/jquery/jquery/pull/764
+ return elem.document.documentElement[ "client" + name ];
+ }
+
+ // Get document width or height
+ if ( elem.nodeType === 9 ) {
+ doc = elem.documentElement;
+
+ // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
+ // whichever is greatest
+ // unfortunately, this causes bug #3838 in IE6/8 only,
+ // but there is currently no good, small way to fix it.
+ return Math.max(
+ elem.body[ "scroll" + name ], doc[ "scroll" + name ],
+ elem.body[ "offset" + name ], doc[ "offset" + name ],
+ doc[ "client" + name ]
+ );
+ }
+
+ return value === undefined ?
+
+ // Get width or height on the element, requesting but not forcing parseFloat
+ jQuery.css( elem, type, extra ) :
+
+ // Set width or height on the element
+ jQuery.style( elem, type, value, extra );
+ }, type, chainable ? margin : undefined, chainable, null );
+ };
+ } );
+} );
+
+
+jQuery.fn.extend( {
+
+ bind: function( types, data, fn ) {
+ return this.on( types, null, data, fn );
+ },
+ unbind: function( types, fn ) {
+ return this.off( types, null, fn );
+ },
+
+ delegate: function( selector, types, data, fn ) {
+ return this.on( types, selector, data, fn );
+ },
+ undelegate: function( selector, types, fn ) {
+
+ // ( namespace ) or ( selector, types [, fn] )
+ return arguments.length === 1 ?
+ this.off( selector, "**" ) :
+ this.off( types, selector || "**", fn );
+ }
+} );
+
+// The number of elements contained in the matched element set
+jQuery.fn.size = function() {
+ return this.length;
+};
+
+jQuery.fn.andSelf = jQuery.fn.addBack;
+
+
+
+
+// Register as a named AMD module, since jQuery can be concatenated with other
+// files that may use define, but not via a proper concatenation script that
+// understands anonymous AMD modules. A named AMD is safest and most robust
+// way to register. Lowercase jquery is used because AMD module names are
+// derived from file names, and jQuery is normally delivered in a lowercase
+// file name. Do this after creating the global so that if an AMD module wants
+// to call noConflict to hide this version of jQuery, it will work.
+
+// Note that for maximum portability, libraries that are not jQuery should
+// declare themselves as anonymous modules, and avoid setting a global if an
+// AMD loader is present. jQuery is a special case. For more information, see
+// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
+
+if ( typeof define === "function" && define.amd ) {
+ define( "jquery", [], function() {
+ return jQuery;
+ } );
+}
+
+
+
+var
+
+ // Map over jQuery in case of overwrite
+ _jQuery = window.jQuery,
+
+ // Map over the $ in case of overwrite
+ _$ = window.$;
+
+jQuery.noConflict = function( deep ) {
+ if ( window.$ === jQuery ) {
+ window.$ = _$;
+ }
+
+ if ( deep && window.jQuery === jQuery ) {
+ window.jQuery = _jQuery;
+ }
+
+ return jQuery;
+};
+
+// Expose jQuery and $ identifiers, even in
+// AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
+// and CommonJS for browser emulators (#13566)
+if ( !noGlobal ) {
+ window.jQuery = window.$ = jQuery;
+}
+
+return jQuery;
+}));
diff --git a/js/rslides.js b/js/rslides.js
new file mode 100644
index 0000000..fbc331a
--- /dev/null
+++ b/js/rslides.js
@@ -0,0 +1,391 @@
+/*! ResponsiveSlides.js v1.54
+ * http://responsiveslides.com
+ * http://viljamis.com
+ *
+ * Copyright (c) 2011-2012 @viljamis
+ * Available under the MIT license
+ */
+
+/*jslint browser: true, sloppy: true, vars: true, plusplus: true, indent: 2 */
+
+(function ($, window, i) {
+ $.fn.responsiveSlides = function (options) {
+
+ // Default settings
+ var settings = $.extend({
+ "auto": true, // Boolean: Animate automatically, true or false
+ "speed": 500, // Integer: Speed of the transition, in milliseconds
+ "timeout": 4000, // Integer: Time between slide transitions, in milliseconds
+ "pager": false, // Boolean: Show pager, true or false
+ "nav": false, // Boolean: Show navigation, true or false
+ "random": false, // Boolean: Randomize the order of the slides, true or false
+ "pause": false, // Boolean: Pause on hover, true or false
+ "pauseControls": true, // Boolean: Pause when hovering controls, true or false
+ "prevText": "Previous", // String: Text for the "previous" button
+ "nextText": "Next", // String: Text for the "next" button
+ "maxwidth": "", // Integer: Max-width of the slideshow, in pixels
+ "navContainer": "", // Selector: Where auto generated controls should be appended to, default is after the
+ "manualControls": "", // Selector: Declare custom pager navigation
+ "namespace": "rslides", // String: change the default namespace used
+ "before": $.noop, // Function: Before callback
+ "after": $.noop // Function: After callback
+ }, options);
+
+ return this.each(function () {
+
+ // Index for namespacing
+ i++;
+
+ var $this = $(this),
+
+ // Local variables
+ vendor,
+ selectTab,
+ startCycle,
+ restartCycle,
+ rotate,
+ $tabs,
+
+ // Helpers
+ index = 0,
+ $slide = $this.children(),
+ length = $slide.size(),
+ fadeTime = parseFloat(settings.speed),
+ waitTime = parseFloat(settings.timeout),
+ maxw = parseFloat(settings.maxwidth),
+
+ // Namespacing
+ namespace = settings.namespace,
+ namespaceIdx = namespace + i,
+
+ // Classes
+ navClass = namespace + "_nav " + namespaceIdx + "_nav",
+ activeClass = namespace + "_here",
+ visibleClass = namespaceIdx + "_on",
+ slideClassPrefix = namespaceIdx + "_s",
+
+ // Pager
+ $pager = $(""),
+
+ // Styles for visible and hidden slides
+ visible = {"float": "left", "position": "relative", "opacity": 1, "zIndex": 2},
+ hidden = {"float": "none", "position": "absolute", "opacity": 0, "zIndex": 1},
+
+ // Detect transition support
+ supportsTransitions = (function () {
+ var docBody = document.body || document.documentElement;
+ var styles = docBody.style;
+ var prop = "transition";
+ if (typeof styles[prop] === "string") {
+ return true;
+ }
+ // Tests for vendor specific prop
+ vendor = ["Moz", "Webkit", "Khtml", "O", "ms"];
+ prop = prop.charAt(0).toUpperCase() + prop.substr(1);
+ var i;
+ for (i = 0; i < vendor.length; i++) {
+ if (typeof styles[vendor[i] + prop] === "string") {
+ return true;
+ }
+ }
+ return false;
+ })(),
+
+ // Fading animation
+ slideTo = function (idx) {
+ settings.before(idx);
+ // If CSS3 transitions are supported
+ if (supportsTransitions) {
+ $slide
+ .removeClass(visibleClass)
+ .css(hidden)
+ .eq(idx)
+ .addClass(visibleClass)
+ .css(visible);
+ index = idx;
+ setTimeout(function () {
+ settings.after(idx);
+ }, fadeTime);
+ // If not, use jQuery fallback
+ } else {
+ $slide
+ .stop()
+ .fadeOut(fadeTime, function () {
+ $(this)
+ .removeClass(visibleClass)
+ .css(hidden)
+ .css("opacity", 1);
+ })
+ .eq(idx)
+ .fadeIn(fadeTime, function () {
+ $(this)
+ .addClass(visibleClass)
+ .css(visible);
+ settings.after(idx);
+ index = idx;
+ });
+ }
+ };
+
+ // Random order
+ if (settings.random) {
+ $slide.sort(function () {
+ return (Math.round(Math.random()) - 0.5);
+ });
+ $this
+ .empty()
+ .append($slide);
+ }
+
+ // Add ID's to each slide
+ $slide.each(function (i) {
+ this.id = slideClassPrefix + i;
+ });
+
+ // Add max-width and classes
+ $this.addClass(namespace + " " + namespaceIdx);
+ if (options && options.maxwidth) {
+ $this.css("max-width", maxw);
+ }
+
+ // Hide all slides, then show first one
+ $slide
+ .hide()
+ .css(hidden)
+ .eq(0)
+ .addClass(visibleClass)
+ .css(visible)
+ .show();
+
+ // CSS transitions
+ if (supportsTransitions) {
+ $slide
+ .show()
+ .css({
+ // -ms prefix isn't needed as IE10 uses prefix free version
+ "-webkit-transition": "opacity " + fadeTime + "ms ease-in-out",
+ "-moz-transition": "opacity " + fadeTime + "ms ease-in-out",
+ "-o-transition": "opacity " + fadeTime + "ms ease-in-out",
+ "transition": "opacity " + fadeTime + "ms ease-in-out"
+ });
+ }
+
+ // Only run if there's more than one slide
+ if ($slide.size() > 1) {
+
+ // Make sure the timeout is at least 100ms longer than the fade
+ if (waitTime < fadeTime + 100) {
+ return;
+ }
+
+ // Pager
+ if (settings.pager && !settings.manualControls) {
+ var tabMarkup = [];
+ $slide.each(function (i) {
+ var n = i + 1;
+ tabMarkup +=
+ "- " +
+ "" + n + "" +
+ "
";
+ });
+ $pager.append(tabMarkup);
+
+ // Inject pager
+ if (options.navContainer) {
+ $(settings.navContainer).append($pager);
+ } else {
+ $this.after($pager);
+ }
+ }
+
+ // Manual pager controls
+ if (settings.manualControls) {
+ $pager = $(settings.manualControls);
+ $pager.addClass(namespace + "_tabs " + namespaceIdx + "_tabs");
+ }
+
+ // Add pager slide class prefixes
+ if (settings.pager || settings.manualControls) {
+ $pager.find('li').each(function (i) {
+ $(this).addClass(slideClassPrefix + (i + 1));
+ });
+ }
+
+ // If we have a pager, we need to set up the selectTab function
+ if (settings.pager || settings.manualControls) {
+ $tabs = $pager.find('a');
+
+ // Select pager item
+ selectTab = function (idx) {
+ $tabs
+ .closest("li")
+ .removeClass(activeClass)
+ .eq(idx)
+ .addClass(activeClass);
+ };
+ }
+
+ // Auto cycle
+ if (settings.auto) {
+
+ startCycle = function () {
+ rotate = setInterval(function () {
+
+ // Clear the event queue
+ $slide.stop(true, true);
+
+ var idx = index + 1 < length ? index + 1 : 0;
+
+ // Remove active state and set new if pager is set
+ if (settings.pager || settings.manualControls) {
+ selectTab(idx);
+ }
+
+ slideTo(idx);
+ }, waitTime);
+ };
+
+ // Init cycle
+ startCycle();
+ }
+
+ // Restarting cycle
+ restartCycle = function () {
+ if (settings.auto) {
+ // Stop
+ clearInterval(rotate);
+ // Restart
+ startCycle();
+ }
+ };
+
+ // Pause on hover
+ if (settings.pause) {
+ $this.hover(function () {
+ clearInterval(rotate);
+ }, function () {
+ restartCycle();
+ });
+ }
+
+ // Pager click event handler
+ if (settings.pager || settings.manualControls) {
+ $tabs.bind("click", function (e) {
+ e.preventDefault();
+
+ if (!settings.pauseControls) {
+ restartCycle();
+ }
+
+ // Get index of clicked tab
+ var idx = $tabs.index(this);
+
+ // Break if element is already active or currently animated
+ if (index === idx || $("." + visibleClass).queue('fx').length) {
+ return;
+ }
+
+ // Remove active state from old tab and set new one
+ selectTab(idx);
+
+ // Do the animation
+ slideTo(idx);
+ })
+ .eq(0)
+ .closest("li")
+ .addClass(activeClass);
+
+ // Pause when hovering pager
+ if (settings.pauseControls) {
+ $tabs.hover(function () {
+ clearInterval(rotate);
+ }, function () {
+ restartCycle();
+ });
+ }
+ }
+
+ // Navigation
+ if (settings.nav) {
+ var navMarkup =
+ "" + settings.prevText + "" +
+ "" + settings.nextText + "";
+
+ // Inject navigation
+ if (options.navContainer) {
+ $(settings.navContainer).append(navMarkup);
+ } else {
+ $this.after(navMarkup);
+ }
+
+ var $trigger = $("." + namespaceIdx + "_nav"),
+ $prev = $trigger.filter(".prev");
+
+ // Click event handler
+ $trigger.bind("click", function (e) {
+ e.preventDefault();
+
+ var $visibleClass = $("." + visibleClass);
+
+ // Prevent clicking if currently animated
+ if ($visibleClass.queue('fx').length) {
+ return;
+ }
+
+ // Adds active class during slide animation
+ // $(this)
+ // .addClass(namespace + "_active")
+ // .delay(fadeTime)
+ // .queue(function (next) {
+ // $(this).removeClass(namespace + "_active");
+ // next();
+ // });
+
+ // Determine where to slide
+ var idx = $slide.index($visibleClass),
+ prevIdx = idx - 1,
+ nextIdx = idx + 1 < length ? index + 1 : 0;
+
+ // Go to slide
+ slideTo($(this)[0] === $prev[0] ? prevIdx : nextIdx);
+ if (settings.pager || settings.manualControls) {
+ selectTab($(this)[0] === $prev[0] ? prevIdx : nextIdx);
+ }
+
+ if (!settings.pauseControls) {
+ restartCycle();
+ }
+ });
+
+ // Pause when hovering navigation
+ if (settings.pauseControls) {
+ $trigger.hover(function () {
+ clearInterval(rotate);
+ }, function () {
+ restartCycle();
+ });
+ }
+ }
+
+ }
+
+ // Max-width fallback
+ if (typeof document.body.style.maxWidth === "undefined" && options.maxwidth) {
+ var widthSupport = function () {
+ $this.css("width", "100%");
+ if ($this.width() > maxw) {
+ $this.css("width", maxw);
+ }
+ };
+
+ // Init fallback
+ widthSupport();
+ $(window).bind("resize", function () {
+ widthSupport();
+ });
+ }
+
+ });
+
+ };
+})(jQuery, this, 0);
diff --git a/js/scripts.js b/js/scripts.js
new file mode 100644
index 0000000..5a44107
--- /dev/null
+++ b/js/scripts.js
@@ -0,0 +1,13 @@
+$(document).ready(function(){
+
+ $('.menu').on('click', function(){
+ $(this).toggleClass('open');
+ });
+
+ $('.thumbnail').on('click', function(){
+ $('.pop-up').fadeIn(100);
+ });
+
+ $(".rslides").responsiveSlides();
+
+});