/* jQuery.serialScroll
* Copyright (c) 2007-2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
* Dual licensed under MIT and GPL.
* Date: 3/20/2008
* @projectDescription Animated scrolling of series.
* @author Ariel Flesler
* @version 1.2.1
* @id jQuery.serialScroll
* @id jQuery.fn.serialScroll
* @param {Object} settings Hash of settings, it is passed in to jQuery.ScrollTo, none is required.
* @return {jQuery} Returns the same jQuery object, for chaining.
* http://flesler.blogspot.com/2008/02/jqueryserialscroll.html
* Notes:
* - The plugin requires jQuery.ScrollTo.
* - The hash of settings, is passed to jQuery.ScrollTo, so its settings can be used as well.
*/
;(function( $ ){
	var $serialScroll = $.serialScroll = function( settings ){
		$.scrollTo.window().serialScroll( settings );
};
//Many of these defaults, belong to jQuery.ScrollTo, check it's demo for an example of each option.
//@see http://flesler.webs/jQuery.ScrollTo/
$serialScroll.defaults = {//the defaults are public and can be overriden.
	duration:1000, //how long to animate.
	axis:'x', //which of top and left should be scrolled
	event:'click', //on which event to react.
	start:0, //first element (zero-based index)
	step:1, //how many elements to scroll on each action
	lock:true,//ignore events if already animating
	cycle:true, //cycle endlessly ( constant velocity )
	constant:true //use contant speed ?
	/*
	navigation:null,//if specified, it's a selector a collection of items to navigate the container
	target:null, //if specified, it's a selector to the element to be scrolled.
	interval:0, //it's the number of milliseconds to automatically go to the next
	lazy:false,//go find the elements each time (allows AJAX or JS content, or reordering)
	stop:false, //stop any previous animations to avoid queueing
	force:false,//force the scroll to the first element on start?
	jump: false,//if true, when the event is triggered on an element, the pane scrolls to it
	items:null, //selector to the items (relative to the matched elements)
	prev:null, //selector to the 'prev' button
	next:null, //selector to the 'next' button
	onBefore: function(){}, //function called before scrolling, if it returns false, the event is ignored
	exclude:0 //exclude the last x elements, so we cannot scroll past the end
	*/
};
$.fn.serialScroll = function( settings ){
	settings = $.extend( {}, $serialScroll.defaults, settings );
	var event = settings.event, //this one is just to get shorter code when compressed
		step = settings.step, // idem
		lazy = settings.lazy;//idem

	return this.each(function(){
		var 
			context = settings.target ? this : document, //if a target is specified, then everything's relative to 'this'.
			$pane = $(settings.target || this, context),//the element to be scrolled (will carry all the events)
			pane = $pane[0], //will be reused, save it into a variable
			items = settings.items, //will hold a lazy list of elements
			active = settings.start, //active index
			auto = settings.interval, //boolean, do auto or not
			nav = settings.navigation, //save it now to make the code shorter
			timer; //holds the interval id

		if( !lazy )//if not lazy, go get the items now
			items = getItems();

		if( settings.force )
			jump( {}, active );//generate an initial call

		// Button binding, optionall
		$(settings.prev||[], context).bind( event, -step, move );
		$(settings.next||[], context).bind( event, step, move );

		// Custom events bound to the container
		if( !pane.ssbound )//don't bind more than once
			$pane
				.bind('prev.serialScroll', -step, move ) //you can trigger with just 'prev'
				.bind('next.serialScroll', step, move ) //for example: $(container).trigger('next');
				.bind('goto.serialScroll', jump ); //for example: $(container).trigger('goto', [4] );
		if( auto )
			$pane
				.bind('start.serialScroll', function(e){
					if( !auto ){
						clear();
						auto = true;
						next();
					}
				 })
				.bind('stop.serialScroll', function(){//stop a current animation
					clear();
					auto = false;
				});
		$pane.bind('notify.serialScroll', function(e, elem){//let serialScroll know that the index changed externally
			var i = index(elem);
			if( i > -1 )
				active = i;
		});
		pane.ssbound = true;//avoid many bindings

		if( settings.jump )//can't use jump if using lazy items and a non-bubbling event
			(lazy ? $pane : getItems()).bind( event, function( e ){
				jump( e, index(e.target) );
			});

		if( nav )
			nav = $(nav, context).bind(event, function( e ){
				e.data = Math.round(getItems().length / nav.length) * nav.index(this);
				jump( e, this );
			});

		function move( e ){
			e.data += active;
			jump( e, this );
		};
		function jump( e, button ){
			if( !isNaN(button) ){//initial or special call from the outside $(container).trigger('goto',[index]);
				e.data = button;
				button = pane;
			}

			var
				pos = e.data, n,
				real = e.type, //is a real event triggering ?
				$items = settings.exclude ? getItems().slice(0,-settings.exclude) : getItems(),//handle a possible exclude
				limit = $items.length,
				elem = $items[pos],
				duration = settings.duration;

			if( real )//real event object
				e.preventDefault();

			if( auto ){
				clear();//clear any possible automatic scrolling.
				timer = setTimeout( next, settings.interval ); 
			}

			if( !elem ){ //exceeded the limits
				n = pos < 0 ? 0 : limit - 1;
				if( active != n )//we exceeded for the first time
					pos = n;
				else if( !settings.cycle )//this is a bad case
					return;
				else
					pos = limit - n - 1;//invert, go to the other side
				elem = $items[pos];
			}

			if( !elem || real && active == pos || //could happen, save some CPU cycles in vain
				settings.lock && $pane.is(':animated') || //no animations while busy
				real && settings.onBefore && //callback returns false ?
				settings.onBefore.call(button, e, elem, $pane, getItems(), pos) === false ) return;

			if( settings.stop )
				$pane.queue('fx',[]).stop();//remove all its animations

			if( settings.constant )
				duration = Math.abs(duration/step * (active - pos ));//keep constant velocity

			$pane
				.scrollTo( elem, duration, settings )//do scroll
				.trigger('notify.serialScroll',[pos]);//in case serialScroll was called on this elem more than once.
		};
		function next(){//I'll use the namespace to avoid conflicts
			$pane.trigger('next.serialScroll');
		};
		function clear(){
			clearTimeout(timer);
		};
		function getItems(){
			return $( items, pane );
		};
		function index( elem ){
			if( !isNaN(elem) ) return elem;//number
			var $items = getItems(), i;
			while(( i = $items.index(elem)) == -1 && elem != pane )//see if it matches or one of its ancestors
				elem = elem.parentNode;
			return i;
		};
	});
};
})( jQuery );