foundation.joyride.js
No OneTemporary
Actions

Size

29 KB

Referenced Files

None

Subscribers

None

foundation.joyride.js
View Options

	;(function ($, window, document, undefined) {
	'use strict';

	var Modernizr = Modernizr \|\| false;

	Foundation.libs.joyride = {
	name : 'joyride',

	version : '5.5.3',

	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', 'bottom', 'left' or 'right' 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">×</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 and not expose
	if (!/body/i.test(this.settings.$target.selector) && !this.settings.expose) {
	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) {
	if (el.length === 0) {
	return [false, false, false, false];
	}

	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);
	},

	reflow : function () {}
	};
	}(jQuery, window, window.document));

File Metadata

Mime Type: text/html
Expires: Sat, Oct 3, 11:37 (5 d, 4 h ago)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: b3/25/fcbe2a63a24b248185b90a76f157
Default Alt Text: foundation.joyride.js (29 KB)

foundation.joyride.jsNo OneTemporaryActions

foundation.joyride.jsView Options

File Metadata

Event Timeline

foundation.joyride.js
No OneTemporary
Actions

foundation.joyride.js
View Options