docs-cambiocds-com-jekyll-theme 0.0.4 → 0.0.5

data/assets/js/foundation/foundation.interchange.js

@@ -0,0 +1,349 @@
+;
+(function ($, window, document, undefined) {
+    'use strict';
+
+    Foundation.libs.interchange = {
+        name: 'interchange',
+
+        version: '5.5.0',
+
+        cache: {},
+
+        images_loaded: false,
+        nodes_loaded: false,
+
+        settings: {
+            load_attr: 'interchange',
+
+            named_queries: {
+                'default': 'only screen',
+                'small': Foundation.media_queries['small'],
+                'small-only': Foundation.media_queries['small-only'],
+                'medium': Foundation.media_queries['medium'],
+                'medium-only': Foundation.media_queries['medium-only'],
+                'large': Foundation.media_queries['large'],
+                'large-only': Foundation.media_queries['large-only'],
+                'xlarge': Foundation.media_queries['xlarge'],
+                'xlarge-only': Foundation.media_queries['xlarge-only'],
+                'xxlarge': Foundation.media_queries['xxlarge'],
+                'landscape': 'only screen and (orientation: landscape)',
+                'portrait': 'only screen and (orientation: portrait)',
+                'retina': 'only screen and (-webkit-min-device-pixel-ratio: 2),' +
+                'only screen and (min--moz-device-pixel-ratio: 2),' +
+                'only screen and (-o-min-device-pixel-ratio: 2/1),' +
+                'only screen and (min-device-pixel-ratio: 2),' +
+                'only screen and (min-resolution: 192dpi),' +
+                'only screen and (min-resolution: 2dppx)'
+            },
+
+            directives: {
+                replace: function (el, path, trigger) {
+                    // The trigger argument, if called within the directive, fires
+                    // an event named after the directive on the element, passing
+                    // any parameters along to the event that you pass to trigger.
+                    //
+                    // ex. trigger(), trigger([a, b, c]), or trigger(a, b, c)
+                    //
+                    // This allows you to bind a callback like so:
+                    // $('#interchangeContainer').on('replace', function (e, a, b, c) {
+                    //   console.log($(this).html(), a, b, c);
+                    // });
+
+                    if (/IMG/.test(el[0].nodeName)) {
+                        var orig_path = el[0].src;
+
+                        if (new RegExp(path, 'i').test(orig_path)) return;
+
+                        el[0].src = path;
+
+                        return trigger(el[0].src);
+                    }
+                    var last_path = el.data(this.data_attr + '-last-path'),
+                        self = this;
+
+                    if (last_path == path) return;
+
+                    if (/\.(gif|jpg|jpeg|tiff|png)([?#].*)?/i.test(path)) {
+                        $(el).css('background-image', 'url(' + path + ')');
+                        el.data('interchange-last-path', path);
+                        return trigger(path);
+                    }
+
+                    return $.get(path, function (response) {
+                        el.html(response);
+                        el.data(self.data_attr + '-last-path', path);
+                        trigger();
+                    });
+
+                }
+            }
+        },
+
+        init: function (scope, method, options) {
+            Foundation.inherit(this, 'throttle random_str');
+
+            this.data_attr = this.set_data_attr();
+            $.extend(true, this.settings, method, options);
+            this.bindings(method, options);
+            this.load('images');
+            this.load('nodes');
+        },
+
+        get_media_hash: function () {
+            var mediaHash = '';
+            for (var queryName in this.settings.named_queries) {
+                mediaHash += matchMedia(this.settings.named_queries[queryName]).matches.toString();
+            }
+            return mediaHash;
+        },
+
+        events: function () {
+            var self = this, prevMediaHash;
+
+            $(window)
+                .off('.interchange')
+                .on('resize.fndtn.interchange', self.throttle(function () {
+                    var currMediaHash = self.get_media_hash();
+                    if (currMediaHash !== prevMediaHash) {
+                        self.resize();
+                    }
+                    prevMediaHash = currMediaHash;
+                }, 50));
+
+            return this;
+        },
+
+        resize: function () {
+            var cache = this.cache;
+
+            if (!this.images_loaded || !this.nodes_loaded) {
+                setTimeout($.proxy(this.resize, this), 50);
+                return;
+            }
+
+            for (var uuid in cache) {
+                if (cache.hasOwnProperty(uuid)) {
+                    var passed = this.results(uuid, cache[uuid]);
+
+                    if (passed) {
+                        this.settings.directives[passed
+                            .scenario[1]].call(this, passed.el, passed.scenario[0], function () {
+                                if (arguments[0] instanceof Array) {
+                                    var args = arguments[0];
+                                } else {
+                                    var args = Array.prototype.slice.call(arguments, 0);
+                                }
+
+                                passed.el.trigger(passed.scenario[1], args);
+                            });
+                    }
+                }
+            }
+
+        },
+
+        results: function (uuid, scenarios) {
+            var count = scenarios.length;
+
+            if (count > 0) {
+                var el = this.S('[' + this.add_namespace('data-uuid') + '="' + uuid + '"]');
+
+                while (count--) {
+                    var mq, rule = scenarios[count][2];
+                    if (this.settings.named_queries.hasOwnProperty(rule)) {
+                        mq = matchMedia(this.settings.named_queries[rule]);
+                    } else {
+                        mq = matchMedia(rule);
+                    }
+                    if (mq.matches) {
+                        return {el: el, scenario: scenarios[count]};
+                    }
+                }
+            }
+
+            return false;
+        },
+
+        load: function (type, force_update) {
+            if (typeof this['cached_' + type] === 'undefined' || force_update) {
+                this['update_' + type]();
+            }
+
+            return this['cached_' + type];
+        },
+
+        update_images: function () {
+            var images = this.S('img[' + this.data_attr + ']'),
+                count = images.length,
+                i = count,
+                loaded_count = 0,
+                data_attr = this.data_attr;
+
+            this.cache = {};
+            this.cached_images = [];
+            this.images_loaded = (count === 0);
+
+            while (i--) {
+                loaded_count++;
+                if (images[i]) {
+                    var str = images[i].getAttribute(data_attr) || '';
+
+                    if (str.length > 0) {
+                        this.cached_images.push(images[i]);
+                    }
+                }
+
+                if (loaded_count === count) {
+                    this.images_loaded = true;
+                    this.enhance('images');
+                }
+            }
+
+            return this;
+        },
+
+        update_nodes: function () {
+            var nodes = this.S('[' + this.data_attr + ']').not('img'),
+                count = nodes.length,
+                i = count,
+                loaded_count = 0,
+                data_attr = this.data_attr;
+
+            this.cached_nodes = [];
+            this.nodes_loaded = (count === 0);
+
+
+            while (i--) {
+                loaded_count++;
+                var str = nodes[i].getAttribute(data_attr) || '';
+
+                if (str.length > 0) {
+                    this.cached_nodes.push(nodes[i]);
+                }
+
+                if (loaded_count === count) {
+                    this.nodes_loaded = true;
+                    this.enhance('nodes');
+                }
+            }
+
+            return this;
+        },
+
+        enhance: function (type) {
+            var i = this['cached_' + type].length;
+
+            while (i--) {
+                this.object($(this['cached_' + type][i]));
+            }
+
+            return $(window).trigger('resize').trigger('resize.fndtn.interchange');
+        },
+
+        convert_directive: function (directive) {
+
+            var trimmed = this.trim(directive);
+
+            if (trimmed.length > 0) {
+                return trimmed;
+            }
+
+            return 'replace';
+        },
+
+        parse_scenario: function (scenario) {
+            // This logic had to be made more complex since some users were using commas in the url path
+            // So we cannot simply just split on a comma
+            var directive_match = scenario[0].match(/(.+),\s*(\w+)\s*$/),
+                media_query = scenario[1];
+
+            if (directive_match) {
+                var path = directive_match[1],
+                    directive = directive_match[2];
+            }
+            else {
+                var cached_split = scenario[0].split(/,\s*$/),
+                    path = cached_split[0],
+                    directive = '';
+            }
+
+            return [this.trim(path), this.convert_directive(directive), this.trim(media_query)];
+        },
+
+        object: function (el) {
+            var raw_arr = this.parse_data_attr(el),
+                scenarios = [],
+                i = raw_arr.length;
+
+            if (i > 0) {
+                while (i--) {
+                    var split = raw_arr[i].split(/\((.*?)(\))$/);
+
+                    if (split.length > 1) {
+                        var params = this.parse_scenario(split);
+                        scenarios.push(params);
+                    }
+                }
+            }
+
+            return this.store(el, scenarios);
+        },
+
+        store: function (el, scenarios) {
+            var uuid = this.random_str(),
+                current_uuid = el.data(this.add_namespace('uuid', true));
+
+            if (this.cache[current_uuid]) return this.cache[current_uuid];
+
+            el.attr(this.add_namespace('data-uuid'), uuid);
+
+            return this.cache[uuid] = scenarios;
+        },
+
+        trim: function (str) {
+
+            if (typeof str === 'string') {
+                return $.trim(str);
+            }
+
+            return str;
+        },
+
+        set_data_attr: function (init) {
+            if (init) {
+                if (this.namespace.length > 0) {
+                    return this.namespace + '-' + this.settings.load_attr;
+                }
+
+                return this.settings.load_attr;
+            }
+
+            if (this.namespace.length > 0) {
+                return 'data-' + this.namespace + '-' + this.settings.load_attr;
+            }
+
+            return 'data-' + this.settings.load_attr;
+        },
+
+        parse_data_attr: function (el) {
+            var raw = el.attr(this.attr_name()).split(/\[(.*?)\]/),
+                i = raw.length,
+                output = [];
+
+            while (i--) {
+                if (raw[i].replace(/[\W\d]+/, '').length > 4) {
+                    output.push(raw[i]);
+                }
+            }
+
+            return output;
+        },
+
+        reflow: function () {
+            this.load('images', true);
+            this.load('nodes', true);
+        }
+
+    };
+
+}(jQuery, window, window.document));

data/assets/js/foundation/foundation.joyride.js

@@ -0,0 +1,939 @@
+;
+(function ($, window, document, undefined) {
+    'use strict';
+
+    var Modernizr = Modernizr || false;
+
+    Foundation.libs.joyride = {
+        name: 'joyride',
+
+        version: '5.5.0',
+
+        defaults: {
+            expose: false,     // turn on or off the expose feature
+            modal: true,      // Whether to cover page with modal during the tour
+            keyboard: true,      // enable left, right and esc keystrokes
+            tip_location: 'bottom',  // 'top' or 'bottom' in relation to parent
+            nub_position: 'auto',    // override on a per tooltip bases
+            scroll_speed: 1500,      // Page scrolling speed in milliseconds, 0 = no scroll animation
+            scroll_animation: 'linear',  // supports 'swing' and 'linear', extend with jQuery UI.
+            timer: 0,         // 0 = no timer , all other numbers = timer in milliseconds
+            start_timer_on_click: true,      // true or false - true requires clicking the first button start the timer
+            start_offset: 0,         // the index of the tooltip you want to start on (index of the li)
+            next_button: true,      // true or false to control whether a next button is used
+            prev_button: true,      // true or false to control whether a prev button is used
+            tip_animation: 'fade',    // 'pop' or 'fade' in each tip
+            pause_after: [],        // array of indexes where to pause the tour after
+            exposed: [],        // array of expose elements
+            tip_animation_fade_speed: 300,       // when tipAnimation = 'fade' this is speed in milliseconds for the transition
+            cookie_monster: false,     // true or false to control whether cookies are used
+            cookie_name: 'joyride', // Name the cookie you'll use
+            cookie_domain: false,     // Will this cookie be attached to a domain, ie. '.notableapp.com'
+            cookie_expires: 365,       // set when you would like the cookie to expire.
+            tip_container: 'body',    // Where will the tip be attached
+            abort_on_close: true,      // When true, the close event will not fire any callback
+            tip_location_patterns: {
+                top: ['bottom'],
+                bottom: [], // bottom should not need to be repositioned
+                left: ['right', 'top', 'bottom'],
+                right: ['left', 'top', 'bottom']
+            },
+            post_ride_callback: function () {
+            },    // A method to call once the tour closes (canceled or complete)
+            post_step_callback: function () {
+            },    // A method to call after each step
+            pre_step_callback: function () {
+            },    // A method to call before each step
+            pre_ride_callback: function () {
+            },    // A method to call before the tour starts (passed index, tip, and cloned exposed element)
+            post_expose_callback: function () {
+            },    // A method to call after an element has been exposed
+            template: { // HTML segments for tip layout
+                link: '<a href="#close" class="joyride-close-tip">&times;</a>',
+                timer: '<div class="joyride-timer-indicator-wrap"><span class="joyride-timer-indicator"></span></div>',
+                tip: '<div class="joyride-tip-guide"><span class="joyride-nub"></span></div>',
+                wrapper: '<div class="joyride-content-wrapper"></div>',
+                button: '<a href="#" class="small button joyride-next-tip"></a>',
+                prev_button: '<a href="#" class="small button joyride-prev-tip"></a>',
+                modal: '<div class="joyride-modal-bg"></div>',
+                expose: '<div class="joyride-expose-wrapper"></div>',
+                expose_cover: '<div class="joyride-expose-cover"></div>'
+            },
+            expose_add_class: '' // One or more space-separated class names to be added to exposed element
+        },
+
+        init: function (scope, method, options) {
+            Foundation.inherit(this, 'throttle random_str');
+
+            this.settings = this.settings || $.extend({}, this.defaults, (options || method));
+
+            this.bindings(method, options)
+        },
+
+        go_next: function () {
+            if (this.settings.$li.next().length < 1) {
+                this.end();
+            } else if (this.settings.timer > 0) {
+                clearTimeout(this.settings.automate);
+                this.hide();
+                this.show();
+                this.startTimer();
+            } else {
+                this.hide();
+                this.show();
+            }
+        },
+
+        go_prev: function () {
+            if (this.settings.$li.prev().length < 1) {
+                // Do nothing if there are no prev element
+            } else if (this.settings.timer > 0) {
+                clearTimeout(this.settings.automate);
+                this.hide();
+                this.show(null, true);
+                this.startTimer();
+            } else {
+                this.hide();
+                this.show(null, true);
+            }
+        },
+
+        events: function () {
+            var self = this;
+
+            $(this.scope)
+                .off('.joyride')
+                .on('click.fndtn.joyride', '.joyride-next-tip, .joyride-modal-bg', function (e) {
+                    e.preventDefault();
+                    this.go_next()
+                }.bind(this))
+                .on('click.fndtn.joyride', '.joyride-prev-tip', function (e) {
+                    e.preventDefault();
+                    this.go_prev();
+                }.bind(this))
+
+                .on('click.fndtn.joyride', '.joyride-close-tip', function (e) {
+                    e.preventDefault();
+                    this.end(this.settings.abort_on_close);
+                }.bind(this))
+
+                .on('keyup.fndtn.joyride', function (e) {
+                    // Don't do anything if keystrokes are disabled
+                    // or if the joyride is not being shown
+                    if (!this.settings.keyboard || !this.settings.riding) return;
+
+                    switch (e.which) {
+                        case 39: // right arrow
+                            e.preventDefault();
+                            this.go_next();
+                            break;
+                        case 37: // left arrow
+                            e.preventDefault();
+                            this.go_prev();
+                            break;
+                        case 27: // escape
+                            e.preventDefault();
+                            this.end(this.settings.abort_on_close);
+                    }
+                }.bind(this));
+
+            $(window)
+                .off('.joyride')
+                .on('resize.fndtn.joyride', self.throttle(function () {
+                    if ($('[' + self.attr_name() + ']').length > 0 && self.settings.$next_tip && self.settings.riding) {
+                        if (self.settings.exposed.length > 0) {
+                            var $els = $(self.settings.exposed);
+
+                            $els.each(function () {
+                                var $this = $(this);
+                                self.un_expose($this);
+                                self.expose($this);
+                            });
+                        }
+
+                        if (self.is_phone()) {
+                            self.pos_phone();
+                        } else {
+                            self.pos_default(false);
+                        }
+                    }
+                }, 100));
+        },
+
+        start: function () {
+            var self = this,
+                $this = $('[' + this.attr_name() + ']', this.scope),
+                integer_settings = ['timer', 'scrollSpeed', 'startOffset', 'tipAnimationFadeSpeed', 'cookieExpires'],
+                int_settings_count = integer_settings.length;
+
+            if (!$this.length > 0) return;
+
+            if (!this.settings.init) this.events();
+
+            this.settings = $this.data(this.attr_name(true) + '-init');
+
+            // non configureable settings
+            this.settings.$content_el = $this;
+            this.settings.$body = $(this.settings.tip_container);
+            this.settings.body_offset = $(this.settings.tip_container).position();
+            this.settings.$tip_content = this.settings.$content_el.find('> li');
+            this.settings.paused = false;
+            this.settings.attempts = 0;
+            this.settings.riding = true;
+
+            // can we create cookies?
+            if (typeof $.cookie !== 'function') {
+                this.settings.cookie_monster = false;
+            }
+
+            // generate the tips and insert into dom.
+            if (!this.settings.cookie_monster || this.settings.cookie_monster && !$.cookie(this.settings.cookie_name)) {
+                this.settings.$tip_content.each(function (index) {
+                    var $this = $(this);
+                    this.settings = $.extend({}, self.defaults, self.data_options($this));
+
+                    // Make sure that settings parsed from data_options are integers where necessary
+                    var i = int_settings_count;
+                    while (i--) {
+                        self.settings[integer_settings[i]] = parseInt(self.settings[integer_settings[i]], 10);
+                    }
+                    self.create({$li: $this, index: index});
+                });
+
+                // show first tip
+                if (!this.settings.start_timer_on_click && this.settings.timer > 0) {
+                    this.show('init');
+                    this.startTimer();
+                } else {
+                    this.show('init');
+                }
+
+            }
+        },
+
+        resume: function () {
+            this.set_li();
+            this.show();
+        },
+
+        tip_template: function (opts) {
+            var $blank, content;
+
+            opts.tip_class = opts.tip_class || '';
+
+            $blank = $(this.settings.template.tip).addClass(opts.tip_class);
+            content = $.trim($(opts.li).html()) +
+            this.prev_button_text(opts.prev_button_text, opts.index) +
+            this.button_text(opts.button_text) +
+            this.settings.template.link +
+            this.timer_instance(opts.index);
+
+            $blank.append($(this.settings.template.wrapper));
+            $blank.first().attr(this.add_namespace('data-index'), opts.index);
+            $('.joyride-content-wrapper', $blank).append(content);
+
+            return $blank[0];
+        },
+
+        timer_instance: function (index) {
+            var txt;
+
+            if ((index === 0 && this.settings.start_timer_on_click && this.settings.timer > 0) || this.settings.timer === 0) {
+                txt = '';
+            } else {
+                txt = $(this.settings.template.timer)[0].outerHTML;
+            }
+            return txt;
+        },
+
+        button_text: function (txt) {
+            if (this.settings.tip_settings.next_button) {
+                txt = $.trim(txt) || 'Next';
+                txt = $(this.settings.template.button).append(txt)[0].outerHTML;
+            } else {
+                txt = '';
+            }
+            return txt;
+        },
+
+        prev_button_text: function (txt, idx) {
+            if (this.settings.tip_settings.prev_button) {
+                txt = $.trim(txt) || 'Previous';
+
+                // Add the disabled class to the button if it's the first element
+                if (idx == 0)
+                    txt = $(this.settings.template.prev_button).append(txt).addClass('disabled')[0].outerHTML;
+                else
+                    txt = $(this.settings.template.prev_button).append(txt)[0].outerHTML;
+            } else {
+                txt = '';
+            }
+            return txt;
+        },
+
+        create: function (opts) {
+            this.settings.tip_settings = $.extend({}, this.settings, this.data_options(opts.$li));
+            var buttonText = opts.$li.attr(this.add_namespace('data-button'))
+                    || opts.$li.attr(this.add_namespace('data-text')),
+                prevButtonText = opts.$li.attr(this.add_namespace('data-button-prev'))
+                    || opts.$li.attr(this.add_namespace('data-prev-text')),
+                tipClass = opts.$li.attr('class'),
+                $tip_content = $(this.tip_template({
+                    tip_class: tipClass,
+                    index: opts.index,
+                    button_text: buttonText,
+                    prev_button_text: prevButtonText,
+                    li: opts.$li
+                }));
+
+            $(this.settings.tip_container).append($tip_content);
+        },
+
+        show: function (init, is_prev) {
+            var $timer = null;
+
+            // are we paused?
+            if (this.settings.$li === undefined
+                || ($.inArray(this.settings.$li.index(), this.settings.pause_after) === -1)) {
+
+                // don't go to the next li if the tour was paused
+                if (this.settings.paused) {
+                    this.settings.paused = false;
+                } else {
+                    this.set_li(init, is_prev);
+                }
+
+                this.settings.attempts = 0;
+
+                if (this.settings.$li.length && this.settings.$target.length > 0) {
+                    if (init) { //run when we first start
+                        this.settings.pre_ride_callback(this.settings.$li.index(), this.settings.$next_tip);
+                        if (this.settings.modal) {
+                            this.show_modal();
+                        }
+                    }
+
+                    this.settings.pre_step_callback(this.settings.$li.index(), this.settings.$next_tip);
+
+                    if (this.settings.modal && this.settings.expose) {
+                        this.expose();
+                    }
+
+                    this.settings.tip_settings = $.extend({}, this.settings, this.data_options(this.settings.$li));
+
+                    this.settings.timer = parseInt(this.settings.timer, 10);
+
+                    this.settings.tip_settings.tip_location_pattern = this.settings.tip_location_patterns[this.settings.tip_settings.tip_location];
+
+                    // scroll and hide bg if not modal
+                    if (!/body/i.test(this.settings.$target.selector)) {
+                        var joyridemodalbg = $('.joyride-modal-bg');
+                        if (/pop/i.test(this.settings.tipAnimation)) {
+                            joyridemodalbg.hide();
+                        } else {
+                            joyridemodalbg.fadeOut(this.settings.tipAnimationFadeSpeed);
+                        }
+                        this.scroll_to();
+                    }
+
+                    if (this.is_phone()) {
+                        this.pos_phone(true);
+                    } else {
+                        this.pos_default(true);
+                    }
+
+                    $timer = this.settings.$next_tip.find('.joyride-timer-indicator');
+
+                    if (/pop/i.test(this.settings.tip_animation)) {
+
+                        $timer.width(0);
+
+                        if (this.settings.timer > 0) {
+
+                            this.settings.$next_tip.show();
+
+                            setTimeout(function () {
+                                $timer.animate({
+                                    width: $timer.parent().width()
+                                }, this.settings.timer, 'linear');
+                            }.bind(this), this.settings.tip_animation_fade_speed);
+
+                        } else {
+                            this.settings.$next_tip.show();
+
+                        }
+
+
+                    } else if (/fade/i.test(this.settings.tip_animation)) {
+
+                        $timer.width(0);
+
+                        if (this.settings.timer > 0) {
+
+                            this.settings.$next_tip
+                                .fadeIn(this.settings.tip_animation_fade_speed)
+                                .show();
+
+                            setTimeout(function () {
+                                $timer.animate({
+                                    width: $timer.parent().width()
+                                }, this.settings.timer, 'linear');
+                            }.bind(this), this.settings.tip_animation_fade_speed);
+
+                        } else {
+                            this.settings.$next_tip.fadeIn(this.settings.tip_animation_fade_speed);
+                        }
+                    }
+
+                    this.settings.$current_tip = this.settings.$next_tip;
+
+                    // skip non-existant targets
+                } else if (this.settings.$li && this.settings.$target.length < 1) {
+
+                    this.show(init, is_prev);
+
+                } else {
+
+                    this.end();
+
+                }
+            } else {
+
+                this.settings.paused = true;
+
+            }
+
+        },
+
+        is_phone: function () {
+            return matchMedia(Foundation.media_queries.small).matches && !matchMedia(Foundation.media_queries.medium).matches;
+        },
+
+        hide: function () {
+            if (this.settings.modal && this.settings.expose) {
+                this.un_expose();
+            }
+
+            if (!this.settings.modal) {
+                $('.joyride-modal-bg').hide();
+            }
+
+            // Prevent scroll bouncing...wait to remove from layout
+            this.settings.$current_tip.css('visibility', 'hidden');
+            setTimeout($.proxy(function () {
+                this.hide();
+                this.css('visibility', 'visible');
+            }, this.settings.$current_tip), 0);
+            this.settings.post_step_callback(this.settings.$li.index(),
+                this.settings.$current_tip);
+        },
+
+        set_li: function (init, is_prev) {
+            if (init) {
+                this.settings.$li = this.settings.$tip_content.eq(this.settings.start_offset);
+                this.set_next_tip();
+                this.settings.$current_tip = this.settings.$next_tip;
+            } else {
+                if (is_prev)
+                    this.settings.$li = this.settings.$li.prev();
+                else
+                    this.settings.$li = this.settings.$li.next();
+                this.set_next_tip();
+            }
+
+            this.set_target();
+        },
+
+        set_next_tip: function () {
+            this.settings.$next_tip = $('.joyride-tip-guide').eq(this.settings.$li.index());
+            this.settings.$next_tip.data('closed', '');
+        },
+
+        set_target: function () {
+            var cl = this.settings.$li.attr(this.add_namespace('data-class')),
+                id = this.settings.$li.attr(this.add_namespace('data-id')),
+                $sel = function () {
+                    if (id) {
+                        return $(document.getElementById(id));
+                    } else if (cl) {
+                        return $('.' + cl).first();
+                    } else {
+                        return $('body');
+                    }
+                };
+
+            this.settings.$target = $sel();
+        },
+
+        scroll_to: function () {
+            var window_half, tipOffset;
+
+            window_half = $(window).height() / 2;
+            tipOffset = Math.ceil(this.settings.$target.offset().top - window_half + this.settings.$next_tip.outerHeight());
+
+            if (tipOffset != 0) {
+                $('html, body').stop().animate({
+                    scrollTop: tipOffset
+                }, this.settings.scroll_speed, 'swing');
+            }
+        },
+
+        paused: function () {
+            return ($.inArray((this.settings.$li.index() + 1), this.settings.pause_after) === -1);
+        },
+
+        restart: function () {
+            this.hide();
+            this.settings.$li = undefined;
+            this.show('init');
+        },
+
+        pos_default: function (init) {
+            var $nub = this.settings.$next_tip.find('.joyride-nub'),
+                nub_width = Math.ceil($nub.outerWidth() / 2),
+                nub_height = Math.ceil($nub.outerHeight() / 2),
+                toggle = init || false;
+
+            // tip must not be "display: none" to calculate position
+            if (toggle) {
+                this.settings.$next_tip.css('visibility', 'hidden');
+                this.settings.$next_tip.show();
+            }
+
+            if (!/body/i.test(this.settings.$target.selector)) {
+                var topAdjustment = this.settings.tip_settings.tipAdjustmentY ? parseInt(this.settings.tip_settings.tipAdjustmentY) : 0,
+                    leftAdjustment = this.settings.tip_settings.tipAdjustmentX ? parseInt(this.settings.tip_settings.tipAdjustmentX) : 0;
+
+                if (this.bottom()) {
+                    if (this.rtl) {
+                        this.settings.$next_tip.css({
+                            top: (this.settings.$target.offset().top + nub_height + this.settings.$target.outerHeight() + topAdjustment),
+                            left: this.settings.$target.offset().left + this.settings.$target.outerWidth() - this.settings.$next_tip.outerWidth() + leftAdjustment
+                        });
+                    } else {
+                        this.settings.$next_tip.css({
+                            top: (this.settings.$target.offset().top + nub_height + this.settings.$target.outerHeight() + topAdjustment),
+                            left: this.settings.$target.offset().left + leftAdjustment
+                        });
+                    }
+
+                    this.nub_position($nub, this.settings.tip_settings.nub_position, 'top');
+
+                } else if (this.top()) {
+                    if (this.rtl) {
+                        this.settings.$next_tip.css({
+                            top: (this.settings.$target.offset().top - this.settings.$next_tip.outerHeight() - nub_height + topAdjustment),
+                            left: this.settings.$target.offset().left + this.settings.$target.outerWidth() - this.settings.$next_tip.outerWidth()
+                        });
+                    } else {
+                        this.settings.$next_tip.css({
+                            top: (this.settings.$target.offset().top - this.settings.$next_tip.outerHeight() - nub_height + topAdjustment),
+                            left: this.settings.$target.offset().left + leftAdjustment
+                        });
+                    }
+
+                    this.nub_position($nub, this.settings.tip_settings.nub_position, 'bottom');
+
+                } else if (this.right()) {
+
+                    this.settings.$next_tip.css({
+                        top: this.settings.$target.offset().top + topAdjustment,
+                        left: (this.settings.$target.outerWidth() + this.settings.$target.offset().left + nub_width + leftAdjustment)
+                    });
+
+                    this.nub_position($nub, this.settings.tip_settings.nub_position, 'left');
+
+                } else if (this.left()) {
+
+                    this.settings.$next_tip.css({
+                        top: this.settings.$target.offset().top + topAdjustment,
+                        left: (this.settings.$target.offset().left - this.settings.$next_tip.outerWidth() - nub_width + leftAdjustment)
+                    });
+
+                    this.nub_position($nub, this.settings.tip_settings.nub_position, 'right');
+
+                }
+
+                if (!this.visible(this.corners(this.settings.$next_tip)) && this.settings.attempts < this.settings.tip_settings.tip_location_pattern.length) {
+
+                    $nub.removeClass('bottom')
+                        .removeClass('top')
+                        .removeClass('right')
+                        .removeClass('left');
+
+                    this.settings.tip_settings.tip_location = this.settings.tip_settings.tip_location_pattern[this.settings.attempts];
+
+                    this.settings.attempts++;
+
+                    this.pos_default();
+
+                }
+
+            } else if (this.settings.$li.length) {
+
+                this.pos_modal($nub);
+
+            }
+
+            if (toggle) {
+                this.settings.$next_tip.hide();
+                this.settings.$next_tip.css('visibility', 'visible');
+            }
+
+        },
+
+        pos_phone: function (init) {
+            var tip_height = this.settings.$next_tip.outerHeight(),
+                tip_offset = this.settings.$next_tip.offset(),
+                target_height = this.settings.$target.outerHeight(),
+                $nub = $('.joyride-nub', this.settings.$next_tip),
+                nub_height = Math.ceil($nub.outerHeight() / 2),
+                toggle = init || false;
+
+            $nub.removeClass('bottom')
+                .removeClass('top')
+                .removeClass('right')
+                .removeClass('left');
+
+            if (toggle) {
+                this.settings.$next_tip.css('visibility', 'hidden');
+                this.settings.$next_tip.show();
+            }
+
+            if (!/body/i.test(this.settings.$target.selector)) {
+
+                if (this.top()) {
+
+                    this.settings.$next_tip.offset({top: this.settings.$target.offset().top - tip_height - nub_height});
+                    $nub.addClass('bottom');
+
+                } else {
+
+                    this.settings.$next_tip.offset({top: this.settings.$target.offset().top + target_height + nub_height});
+                    $nub.addClass('top');
+
+                }
+
+            } else if (this.settings.$li.length) {
+                this.pos_modal($nub);
+            }
+
+            if (toggle) {
+                this.settings.$next_tip.hide();
+                this.settings.$next_tip.css('visibility', 'visible');
+            }
+        },
+
+        pos_modal: function ($nub) {
+            this.center();
+            $nub.hide();
+
+            this.show_modal();
+        },
+
+        show_modal: function () {
+            if (!this.settings.$next_tip.data('closed')) {
+                var joyridemodalbg = $('.joyride-modal-bg');
+                if (joyridemodalbg.length < 1) {
+                    var joyridemodalbg = $(this.settings.template.modal);
+                    joyridemodalbg.appendTo('body');
+                }
+
+                if (/pop/i.test(this.settings.tip_animation)) {
+                    joyridemodalbg.show();
+                } else {
+                    joyridemodalbg.fadeIn(this.settings.tip_animation_fade_speed);
+                }
+            }
+        },
+
+        expose: function () {
+            var expose,
+                exposeCover,
+                el,
+                origCSS,
+                origClasses,
+                randId = 'expose-' + this.random_str(6);
+
+            if (arguments.length > 0 && arguments[0] instanceof $) {
+                el = arguments[0];
+            } else if (this.settings.$target && !/body/i.test(this.settings.$target.selector)) {
+                el = this.settings.$target;
+            } else {
+                return false;
+            }
+
+            if (el.length < 1) {
+                if (window.console) {
+                    console.error('element not valid', el);
+                }
+                return false;
+            }
+
+            expose = $(this.settings.template.expose);
+            this.settings.$body.append(expose);
+            expose.css({
+                top: el.offset().top,
+                left: el.offset().left,
+                width: el.outerWidth(true),
+                height: el.outerHeight(true)
+            });
+
+            exposeCover = $(this.settings.template.expose_cover);
+
+            origCSS = {
+                zIndex: el.css('z-index'),
+                position: el.css('position')
+            };
+
+            origClasses = el.attr('class') == null ? '' : el.attr('class');
+
+            el.css('z-index', parseInt(expose.css('z-index')) + 1);
+
+            if (origCSS.position == 'static') {
+                el.css('position', 'relative');
+            }
+
+            el.data('expose-css', origCSS);
+            el.data('orig-class', origClasses);
+            el.attr('class', origClasses + ' ' + this.settings.expose_add_class);
+
+            exposeCover.css({
+                top: el.offset().top,
+                left: el.offset().left,
+                width: el.outerWidth(true),
+                height: el.outerHeight(true)
+            });
+
+            if (this.settings.modal) this.show_modal();
+
+            this.settings.$body.append(exposeCover);
+            expose.addClass(randId);
+            exposeCover.addClass(randId);
+            el.data('expose', randId);
+            this.settings.post_expose_callback(this.settings.$li.index(), this.settings.$next_tip, el);
+            this.add_exposed(el);
+        },
+
+        un_expose: function () {
+            var exposeId,
+                el,
+                expose,
+                origCSS,
+                origClasses,
+                clearAll = false;
+
+            if (arguments.length > 0 && arguments[0] instanceof $) {
+                el = arguments[0];
+            } else if (this.settings.$target && !/body/i.test(this.settings.$target.selector)) {
+                el = this.settings.$target;
+            } else {
+                return false;
+            }
+
+            if (el.length < 1) {
+                if (window.console) {
+                    console.error('element not valid', el);
+                }
+                return false;
+            }
+
+            exposeId = el.data('expose');
+            expose = $('.' + exposeId);
+
+            if (arguments.length > 1) {
+                clearAll = arguments[1];
+            }
+
+            if (clearAll === true) {
+                $('.joyride-expose-wrapper,.joyride-expose-cover').remove();
+            } else {
+                expose.remove();
+            }
+
+            origCSS = el.data('expose-css');
+
+            if (origCSS.zIndex == 'auto') {
+                el.css('z-index', '');
+            } else {
+                el.css('z-index', origCSS.zIndex);
+            }
+
+            if (origCSS.position != el.css('position')) {
+                if (origCSS.position == 'static') {// this is default, no need to set it.
+                    el.css('position', '');
+                } else {
+                    el.css('position', origCSS.position);
+                }
+            }
+
+            origClasses = el.data('orig-class');
+            el.attr('class', origClasses);
+            el.removeData('orig-classes');
+
+            el.removeData('expose');
+            el.removeData('expose-z-index');
+            this.remove_exposed(el);
+        },
+
+        add_exposed: function (el) {
+            this.settings.exposed = this.settings.exposed || [];
+            if (el instanceof $ || typeof el === 'object') {
+                this.settings.exposed.push(el[0]);
+            } else if (typeof el == 'string') {
+                this.settings.exposed.push(el);
+            }
+        },
+
+        remove_exposed: function (el) {
+            var search, i;
+            if (el instanceof $) {
+                search = el[0]
+            } else if (typeof el == 'string') {
+                search = el;
+            }
+
+            this.settings.exposed = this.settings.exposed || [];
+            i = this.settings.exposed.length;
+
+            while (i--) {
+                if (this.settings.exposed[i] == search) {
+                    this.settings.exposed.splice(i, 1);
+                    return;
+                }
+            }
+        },
+
+        center: function () {
+            var $w = $(window);
+
+            this.settings.$next_tip.css({
+                top: ((($w.height() - this.settings.$next_tip.outerHeight()) / 2) + $w.scrollTop()),
+                left: ((($w.width() - this.settings.$next_tip.outerWidth()) / 2) + $w.scrollLeft())
+            });
+
+            return true;
+        },
+
+        bottom: function () {
+            return /bottom/i.test(this.settings.tip_settings.tip_location);
+        },
+
+        top: function () {
+            return /top/i.test(this.settings.tip_settings.tip_location);
+        },
+
+        right: function () {
+            return /right/i.test(this.settings.tip_settings.tip_location);
+        },
+
+        left: function () {
+            return /left/i.test(this.settings.tip_settings.tip_location);
+        },
+
+        corners: function (el) {
+            var w = $(window),
+                window_half = w.height() / 2,
+            //using this to calculate since scroll may not have finished yet.
+                tipOffset = Math.ceil(this.settings.$target.offset().top - window_half + this.settings.$next_tip.outerHeight()),
+                right = w.width() + w.scrollLeft(),
+                offsetBottom = w.height() + tipOffset,
+                bottom = w.height() + w.scrollTop(),
+                top = w.scrollTop();
+
+            if (tipOffset < top) {
+                if (tipOffset < 0) {
+                    top = 0;
+                } else {
+                    top = tipOffset;
+                }
+            }
+
+            if (offsetBottom > bottom) {
+                bottom = offsetBottom;
+            }
+
+            return [
+                el.offset().top < top,
+                right < el.offset().left + el.outerWidth(),
+                bottom < el.offset().top + el.outerHeight(),
+                w.scrollLeft() > el.offset().left
+            ];
+        },
+
+        visible: function (hidden_corners) {
+            var i = hidden_corners.length;
+
+            while (i--) {
+                if (hidden_corners[i]) return false;
+            }
+
+            return true;
+        },
+
+        nub_position: function (nub, pos, def) {
+            if (pos === 'auto') {
+                nub.addClass(def);
+            } else {
+                nub.addClass(pos);
+            }
+        },
+
+        startTimer: function () {
+            if (this.settings.$li.length) {
+                this.settings.automate = setTimeout(function () {
+                    this.hide();
+                    this.show();
+                    this.startTimer();
+                }.bind(this), this.settings.timer);
+            } else {
+                clearTimeout(this.settings.automate);
+            }
+        },
+
+        end: function (abort) {
+            if (this.settings.cookie_monster) {
+                $.cookie(this.settings.cookie_name, 'ridden', {
+                    expires: this.settings.cookie_expires,
+                    domain: this.settings.cookie_domain
+                });
+            }
+
+            if (this.settings.timer > 0) {
+                clearTimeout(this.settings.automate);
+            }
+
+            if (this.settings.modal && this.settings.expose) {
+                this.un_expose();
+            }
+
+            // Unplug keystrokes listener
+            $(this.scope).off('keyup.joyride')
+
+            this.settings.$next_tip.data('closed', true);
+            this.settings.riding = false;
+
+            $('.joyride-modal-bg').hide();
+            this.settings.$current_tip.hide();
+
+            if (typeof abort === 'undefined' || abort === false) {
+                this.settings.post_step_callback(this.settings.$li.index(), this.settings.$current_tip);
+                this.settings.post_ride_callback(this.settings.$li.index(), this.settings.$current_tip);
+            }
+
+            $('.joyride-tip-guide').remove();
+        },
+
+        off: function () {
+            $(this.scope).off('.joyride');
+            $(window).off('.joyride');
+            $('.joyride-close-tip, .joyride-next-tip, .joyride-modal-bg').off('.joyride');
+            $('.joyride-tip-guide, .joyride-modal-bg').remove();
+            clearTimeout(this.settings.automate);
+            this.settings = {};
+        },
+
+        reflow: function () {
+        }
+    };
+}(jQuery, window, window.document));