/**
 * jquery bxslider v3.0
 * http://bxslider.com
 *
 * copyright 2011, steven wanderski
 * http://bxcreative.com
 *
 * free to use and abuse under the mit license.
 * http://www.opensource.org/licenses/mit-license.php
 * 
 */

(function($){
	
	$.fn.bxslider = function(options){		
				
		var defaults = {
			mode: 'horizontal',									// 'horizontal', 'vertical', 'fade'
			childselector: '',  					      // jquery selector - elements to be used as slides
			infiniteloop: true,									// true, false - display first slide after last
			hidecontrolonend: false,						// true, false - if true, will hide 'next' control on last slide and 'prev' control on first
			controls: true,											// true, false - previous and next controls
			speed: 500,													// integer - in ms, duration of time slide transitions will occupy
			easing: 'swing',                    // used with jquery.easing.1.3.js - see http://gsgd.co.uk/sandbox/jquery/easing/ for available options
			pager: false,												// true / false - display a pager
			pagerselector: null,								// jquery selector - element to contain the pager. ex: '#pager'
			pagertype: 'full',									// 'full', 'short' - if 'full' pager displays 1,2,3... if 'short' pager displays 1 / 4
			pagerlocation: 'bottom',						// 'bottom', 'top' - location of pager
			pagershortseparator: '/',						// string - ex: 'of' pager would display 1 of 4
			pageractiveclass: 'pager-active',		// string - classname attached to the active pager link
			nexttext: 'next',										// string - text displayed for 'next' control
			nextimage: '',											// string - filepath of image used for 'next' control. ex: 'images/next.jpg'
			nextselector: null,									// jquery selector - element to contain the next control. ex: '#next'
			prevtext: 'prev',										// string - text displayed for 'previous' control
			previmage: '',											// string - filepath of image used for 'previous' control. ex: 'images/prev.jpg'
			prevselector: null,									// jquery selector - element to contain the previous control. ex: '#next'
			captions: false,										// true, false - display image captions (reads the image 'title' tag)
			captionsselector: null,							// jquery selector - element to contain the captions. ex: '#captions'
			auto: false,												// true, false - make slideshow change automatically
			autodirection: 'next',							// 'next', 'prev' - direction in which auto show will traverse
			autocontrols: false,								// true, false - show 'start' and 'stop' controls for auto show
			autocontrolsselector: null,					// jquery selector - element to contain the auto controls. ex: '#auto-controls'
			autostart: true,										// true, false - if false show will wait for 'start' control to activate
			autohover: false,										// true, false - if true show will pause on mouseover
			autodelay: 0,                       // integer - in ms, the amount of time before starting the auto show
			pause: 3000,												// integer - in ms, the duration between each slide transition
			starttext: 'start',									// string - text displayed for 'start' control
			startimage: '',											// string - filepath of image used for 'start' control. ex: 'images/start.jpg'
			stoptext: 'stop',										// string - text displayed for 'stop' control
			stopimage: '',											// string - filepath of image used for 'stop' control. ex: 'images/stop.jpg'
			ticker: false,											// true, false - continuous motion ticker mode (think news ticker)
																					// note: autocontrols, autocontrolsselector, and autohover apply to ticker!
			tickerspeed: 5000,								  // float - use value between 1 and 5000 to determine ticker speed - the smaller the value the faster the ticker speed
			tickerdirection: 'next',						// 'next', 'prev' - direction in which ticker show will traverse
			tickerhover: false,                 // true, false - if true ticker will pause on mouseover
			wrapperclass: 'bx-wrapper',					// string - classname attached to the slider wraper
			startingslide: 0, 									// integer - show will start on specified slide. note: slides are zero based!
			displayslideqty: 1,									// integer - number of slides to display at once
			moveslideqty: 1,										// integer - number of slides to move at once
			randomstart: false,									// true, false - if true show will start on a random slide
			onbeforeslide: function(){},				// function(currentslidenumber, totalslideqty, currentslidehtmlobject) - advanced use only! see the tutorial here: http://bxslider.com/custom-pager
			onafterslide: function(){},					// function(currentslidenumber, totalslideqty, currentslidehtmlobject) - advanced use only! see the tutorial here: http://bxslider.com/custom-pager
			onlastslide: function(){},					// function(currentslidenumber, totalslideqty, currentslidehtmlobject) - advanced use only! see the tutorial here: http://bxslider.com/custom-pager
			onfirstslide: function(){},					// function(currentslidenumber, totalslideqty, currentslidehtmlobject) - advanced use only! see the tutorial here: http://bxslider.com/custom-pager
			onnextslide: function(){},					// function(currentslidenumber, totalslideqty, currentslidehtmlobject) - advanced use only! see the tutorial here: http://bxslider.com/custom-pager
			onprevslide: function(){},					// function(currentslidenumber, totalslideqty, currentslidehtmlobject) - advanced use only! see the tutorial here: http://bxslider.com/custom-pager
			buildpager: null										// function(slideindex, slidehtmlobject){ return string; } - advanced use only! see the tutorial here: http://bxslider.com/custom-pager
		}
		
		var options = $.extend(defaults, options);
		
		// cache the base element
		var base = this;
		// initialize (and localize) all variables
		var $parent = '';
		var $origelement = '';
		var $children = '';
		var $outerwrapper = '';
		var $firstchild = '';
		var childrenwidth = '';
		var childrenouterwidth = '';
		var wrapperwidth = '';
		var wrapperheight = '';
		var $pager = '';	
		var interval = '';
		var $autocontrols = '';
		var $stophtml = '';
		var $startcontent = '';
		var $stopcontent = '';
		var autoplaying = true;
		var loaded = false;
		var childrenmaxwidth = 0;
		var childrenmaxheight = 0;
		var currentslide = 0;	
		var origleft = 0;
		var origtop = 0;
		var origshowwidth = 0;
		var origshowheight = 0;
		var tickerleft = 0;
		var tickertop = 0;
		var isworking = false;
    
		var firstslide = 0;
		var lastslide = $children.length - 1;
		
						
		// public functions
						
		/**
		 * go to specified slide
		 */		
		this.gotoslide = function(number, stopauto){
			if(!isworking){
				isworking = true;
				// set current slide to argument
				currentslide = number;
				options.onbeforeslide(currentslide, $children.length, $children.eq(currentslide));
				// check if stopauto argument is supplied
				if(typeof(stopauto) == 'undefined'){
					var stopauto = true;
				}
				if(stopauto){
					// if show is auto playing, stop it
					if(options.auto){
						base.stopshow(true);
					}
				}			
				slide = number;
				// check for first slide callback
				if(slide == firstslide){
					options.onfirstslide(currentslide, $children.length, $children.eq(currentslide));
				}
				// check for last slide callback
				if(slide == lastslide){
					options.onlastslide(currentslide, $children.length, $children.eq(currentslide));
				}
				// horizontal
				if(options.mode == 'horizontal'){
					$parent.animate({'left': '-'+getslideposition(slide, 'left')+'px'}, options.speed, options.easing, function(){
						isworking = false;
						// perform the callback function
						options.onafterslide(currentslide, $children.length, $children.eq(currentslide));
					});
				// vertical
				}else if(options.mode == 'vertical'){
					$parent.animate({'top': '-'+getslideposition(slide, 'top')+'px'}, options.speed, options.easing, function(){
						isworking = false;
						// perform the callback function
						options.onafterslide(currentslide, $children.length, $children.eq(currentslide));
					});			
				// fade	
				}else if(options.mode == 'fade'){
					setchildrenfade();
				}
				// check to remove controls on last/first slide
				checkendcontrols();
				// accomodate multi slides
				if(options.moveslideqty > 1){
					number = math.floor(number / options.moveslideqty);
				}
				// make the current slide active
				makeslideactive(number);
				// display the caption
				showcaptions();
			}
		}
		
		/**
		 * go to next slide
		 */		
		this.gotonextslide = function(stopauto){
			// check if stopauto argument is supplied
			if(typeof(stopauto) == 'undefined'){
				var stopauto = true;
			}
			if(stopauto){
				// if show is auto playing, stop it
				if(options.auto){
					base.stopshow(true);
				}
			}			
			// makes slideshow finite
			if(!options.infiniteloop){
				if(!isworking){
					var slideloop = false;
					// make current slide the old value plus moveslideqty
					currentslide = (currentslide + (options.moveslideqty));
					// if current slide has looped on itself
					if(currentslide <= lastslide){
						checkendcontrols();
						// next slide callback
						options.onnextslide(currentslide, $children.length, $children.eq(currentslide));
						// move to appropriate slide
						base.gotoslide(currentslide);						
					}else{
						currentslide -= options.moveslideqty;
					}
				} // end if(!isworking)		
			}else{ 
				if(!isworking){
					isworking = true;					
					var slideloop = false;
					// make current slide the old value plus moveslideqty
					currentslide = (currentslide + options.moveslideqty);
					// if current slide has looped on itself
					if(currentslide > lastslide){
						currentslide = currentslide % $children.length;
						slideloop = true;
					}
					// next slide callback
					options.onnextslide(currentslide, $children.length, $children.eq(currentslide));
					// slide before callback
					options.onbeforeslide(currentslide, $children.length, $children.eq(currentslide));
					if(options.mode == 'horizontal'){						
						// get the new 'left' property for $parent
						var parentleft = (options.moveslideqty * childrenouterwidth);
						// animate to the new 'left'
						$parent.animate({'left': '-='+parentleft+'px'}, options.speed, options.easing, function(){
							isworking = false;
							// if its time to loop, reset the $parent
							if(slideloop){
								$parent.css('left', '-'+getslideposition(currentslide, 'left')+'px');
							}
							// perform the callback function
							options.onafterslide(currentslide, $children.length, $children.eq(currentslide));
						});
					}else if(options.mode == 'vertical'){
						// get the new 'left' property for $parent
						var parenttop = (options.moveslideqty * childrenmaxheight);
						// animate to the new 'left'
						$parent.animate({'top': '-='+parenttop+'px'}, options.speed, options.easing, function(){
							isworking = false;
							// if its time to loop, reset the $parent
							if(slideloop){
								$parent.css('top', '-'+getslideposition(currentslide, 'top')+'px');
							}
							// perform the callback function
							options.onafterslide(currentslide, $children.length, $children.eq(currentslide));
						});
					}else if(options.mode == 'fade'){
						setchildrenfade();
					}					
					// make the current slide active
					if(options.moveslideqty > 1){
						makeslideactive(math.ceil(currentslide / options.moveslideqty));
					}else{
						makeslideactive(currentslide);
					}
					// display the caption
					showcaptions();
				} // end if(!isworking)
				
			}	
		} // end function
		
		/**
		 * go to previous slide
		 */		
		this.gotopreviousslide = function(stopauto){
			// check if stopauto argument is supplied
			if(typeof(stopauto) == 'undefined'){
				var stopauto = true;
			}
			if(stopauto){
				// if show is auto playing, stop it
				if(options.auto){
					base.stopshow(true);
				}
			}			
			// makes slideshow finite
			if(!options.infiniteloop){	
				if(!isworking){
					var slideloop = false;
					// make current slide the old value plus moveslideqty
					currentslide = currentslide - options.moveslideqty;
					// if current slide has looped on itself
					if(currentslide < 0){
						currentslide = 0;
						// if specified, hide the control on the last slide
						if(options.hidecontrolonend){
							$outerwrapper.children('.bx-prev').hide();
						}
					}
					checkendcontrols();
					// next slide callback
					options.onprevslide(currentslide, $children.length, $children.eq(currentslide));
					// move to appropriate slide
					base.gotoslide(currentslide);
				}							
			}else{
				if(!isworking){
					isworking = true;			
					var slideloop = false;
					// make current slide the old value plus moveslideqty
					currentslide = (currentslide - (options.moveslideqty));
					// if current slide has looped on itself
					if(currentslide < 0){
						negativeoffset = (currentslide % $children.length);
						if(negativeoffset == 0){
							currentslide = 0;
						}else{
							currentslide = ($children.length) + negativeoffset; 
						}
						slideloop = true;
					}
					// next slide callback
					options.onprevslide(currentslide, $children.length, $children.eq(currentslide));
					// slide before callback
					options.onbeforeslide(currentslide, $children.length, $children.eq(currentslide));
					if(options.mode == 'horizontal'){
						// get the new 'left' property for $parent
						var parentleft = (options.moveslideqty * childrenouterwidth);
						// animate to the new 'left'
						$parent.animate({'left': '+='+parentleft+'px'}, options.speed, options.easing, function(){
							isworking = false;
							// if its time to loop, reset the $parent
							if(slideloop){
								$parent.css('left', '-'+getslideposition(currentslide, 'left')+'px');
							}
							// perform the callback function
							options.onafterslide(currentslide, $children.length, $children.eq(currentslide));
						});
					}else if(options.mode == 'vertical'){
						// get the new 'left' property for $parent
						var parenttop = (options.moveslideqty * childrenmaxheight);
						// animate to the new 'left'
						$parent.animate({'top': '+='+parenttop+'px'}, options.speed, options.easing, function(){
							isworking = false;
							// if its time to loop, reset the $parent
							if(slideloop){
								$parent.css('top', '-'+getslideposition(currentslide, 'top')+'px');
							}
							// perform the callback function
							options.onafterslide(currentslide, $children.length, $children.eq(currentslide));
						});
					}else if(options.mode == 'fade'){
						setchildrenfade();
					}					
					// make the current slide active
					if(options.moveslideqty > 1){
						makeslideactive(math.ceil(currentslide / options.moveslideqty));
					}else{
						makeslideactive(currentslide);
					}
					// display the caption
					showcaptions();
				} // end if(!isworking)				
			}
		} // end function
		
		/**
		 * go to first slide
		 */		
		this.gotofirstslide = function(stopauto){
			// check if stopauto argument is supplied
			if(typeof(stopauto) == 'undefined'){
				var stopauto = true;
			}
			base.gotoslide(firstslide, stopauto);
		}
		
		/**
		 * go to last slide
		 */		
		this.gotolastslide = function(){
			// check if stopauto argument is supplied
			if(typeof(stopauto) == 'undefined'){
				var stopauto = true;
			}
			base.gotoslide(lastslide, stopauto);
		}
		
		/**
		 * get the current slide
		 */		
		this.getcurrentslide = function(){
			return currentslide;
		}
		
		/**
		 * get the total slide count
		 */		
		this.getslidecount = function(){
			return $children.length;
		}
		
		/**
		 * suspend the slideshow
		 */		
		this.suspendshow = function(changetext){
			clearinterval(interval);
			// check if changetext argument is supplied
			if(typeof(changetext) == 'undefined'){
				var changetext = true;
			}
			if(changetext && options.autocontrols){
				$autocontrols.html($startcontent).removeclass('stop').addclass('start');
			}
		}
		
		/**
		 * restart the suspended slideshow
		 */		
		this.restartshow = function(changetext){
			// check if changetext argument is supplied
			if(typeof(changetext) == 'undefined'){
				var changetext = true;
			}
			if(autoplaying){
				setautointerval();
			}
			if(changetext && options.autocontrols){
				$autocontrols.html($stopcontent).removeclass('start').addclass('stop');
			}
		}
		
		/**
		 * stop the slideshow permanently
		 */		
		this.stopshow = function(changetext){
			autoplaying = false;
			this.suspendshow(changetext);
		}
		
		/**
		 * start the slideshow
		 */		
		this.startshow = function(changetext){
			autoplaying = true;
			this.restartshow(changetext);
		}
		
		/**
		 * stops the ticker
		 */		
		this.stopticker = function(changetext){
			$parent.stop();
			// check if changetext argument is supplied
			if(typeof(changetext) == 'undefined'){
				var changetext = true;
			}
			if(changetext && options.ticker){
				$autocontrols.html($startcontent).removeclass('stop').addclass('start');
				autoplaying = false;
			}			
		}
		
		/**
		 * starts the ticker
		 */		
		this.startticker = function(changetext){
			if(options.mode == 'horizontal'){
				if(options.tickerdirection == 'next'){
					// get the 'left' property where the ticker stopped
					var stoppedleft = parseint($parent.css('left'));
					// calculate the remaining distance the show must travel until the loop
					var remainingdistance = (origshowwidth + stoppedleft) + $children.eq(0).width();			
				}else if(options.tickerdirection == 'prev'){
					// get the 'left' property where the ticker stopped
					var stoppedleft = -parseint($parent.css('left'));
					// calculate the remaining distance the show must travel until the loop
					var remainingdistance = (stoppedleft) - $children.eq(0).width();
				}
				// calculate the speed ratio to seamlessly finish the loop
				var finishingspeed = (remainingdistance * options.tickerspeed) / origshowwidth;
				// call the show
				movetheshow(tickerleft, remainingdistance, finishingspeed);					
			}else if(options.mode == 'vertical'){
				if(options.tickerdirection == 'next'){
					// get the 'top' property where the ticker stopped
					var stoppedtop = parseint($parent.css('top'));
					// calculate the remaining distance the show must travel until the loop
					var remainingdistance = (origshowheight + stoppedtop) + $children.eq(0).height();			
				}else if(options.tickerdirection == 'prev'){
					// get the 'left' property where the ticker stopped
					var stoppedtop = -parseint($parent.css('top'));
					// calculate the remaining distance the show must travel until the loop
					var remainingdistance = (stoppedtop) - $children.eq(0).height();
				}
				// calculate the speed ratio to seamlessly finish the loop
				var finishingspeed = (remainingdistance * options.tickerspeed) / origshowheight;
				// call the show
				movetheshow(tickertop, remainingdistance, finishingspeed);
				// check if changetext argument is supplied
				if(typeof(changetext) == 'undefined'){
					var changetext = true;
				}
				if(changetext && options.ticker){
					$autocontrols.html($stopcontent).removeclass('start').addclass('stop');
					autoplaying = true;
				}						
			}
		}
				
		/**
		 * initialize a new slideshow
		 */		
		this.initshow = function(){
			
			// reinitialize all variables
			// base = this;
			$parent = $(this);
			$origelement = $parent.clone();
			$children = $parent.children(options.childselector);
			$outerwrapper = '';
			$firstchild = $parent.children(options.childselector + ':first');
			childrenwidth = $firstchild.width();
			childrenmaxwidth = 0;
			childrenouterwidth = $firstchild.outerwidth();
			childrenmaxheight = 0;
			wrapperwidth = getwrapperwidth();
			wrapperheight = getwrapperheight();
			isworking = false;
			$pager = '';	
			currentslide = 0;	
			origleft = 0;
			origtop = 0;
			interval = '';
			$autocontrols = '';
			$stophtml = '';
			$startcontent = '';
			$stopcontent = '';
			autoplaying = true;
			loaded = false;
			origshowwidth = 0;
			origshowheight = 0;
			tickerleft = 0;
			tickertop = 0;
      
			firstslide = 0;
			lastslide = $children.length - 1;
						
			// get the largest child's height and width
			$children.each(function(index) {
			  if($(this).outerheight() > childrenmaxheight){
					childrenmaxheight = $(this).outerheight();
				}
				if($(this).outerwidth() > childrenmaxwidth){
					childrenmaxwidth = $(this).outerwidth();
				}
			});

			// get random slide number
			if(options.randomstart){
				var randomnumber = math.floor(math.random() * $children.length);
				currentslide = randomnumber;
				origleft = childrenouterwidth * (options.moveslideqty + randomnumber);
				origtop = childrenmaxheight * (options.moveslideqty + randomnumber);
			// start show at specific slide
			}else{
				currentslide = options.startingslide;
				origleft = childrenouterwidth * (options.moveslideqty + options.startingslide);
				origtop = childrenmaxheight * (options.moveslideqty + options.startingslide);
			}
						
			// set initial css
			initcss();
			
			// check to show pager
			if(options.pager && !options.ticker){
				if(options.pagertype == 'full'){
					showpager('full');
				}else if(options.pagertype == 'short'){
					showpager('short');
				}
			}
						
			// check to show controls
			if(options.controls && !options.ticker && $children.length > 1){
				setcontrolsvars();
			}
						
			// check if auto
			if(options.auto || options.ticker){
				// check if auto controls are displayed
				if(options.autocontrols){
					setautocontrolsvars();
				}
				// check if show should auto start
				if(options.autostart){
					// check if autostart should delay
					autoplaying = false; // prevent playing during the deplay
					settimeout(function(){
						base.startshow(true);
					}, options.autodelay);
				}else{
					base.stopshow(true);
				}
				// check if show should pause on hover
				if(options.autohover && !options.ticker){
					setautohover();
				}
			}						
			// make the starting slide active
			if(options.moveslideqty > 1){
				makeslideactive(math.ceil(currentslide / options.moveslideqty));
			}else{			
				makeslideactive(currentslide);			
			}
			// check for finite show and if controls should be hidden
			checkendcontrols();
			// show captions
			if(options.captions){
				showcaptions();
			}
			// perform the callback function
			options.onafterslide(currentslide, $children.length, $children.eq(currentslide));
		}
		
		/**
		 * destroy the current slideshow
		 */		
		this.destroyshow = function(){			
			// stop the auto show
			clearinterval(interval);
			// remove any controls / pagers that have been appended
			$outerwrapper.children('.bx-next, .bx-prev, .bx-pager, .bx-auto').remove();
			// unwrap all bx-wrappers
			$parent.unwrap().unwrap().removeattr('style');
			// remove any styles that were appended
			$parent.children(options.childselector).removeattr('style').not('.bx-child').remove();
			// remove any childrent that were appended
			$children.removeclass('bx-child');
			
		}
		
		/**
		 * reload the current slideshow
		 */		
		this.reloadshow = function(){
			base.destroyshow();
			base.initshow();
		}
		
		// private functions
		
		/**
		 * creates all neccessary styling for the slideshow
		 */		
		function initcss(){
			// layout the children
			setchildrenlayout(options.startingslide);
			// css for horizontal mode
			if(options.mode == 'horizontal'){
				// wrap the <ul> in div that acts as a window and make the <ul> uber wide
				$parent
				.wrap('<div class="'+options.wrapperclass+'" style="width:'+wrapperwidth+'px; position:relative;"></div>')
				.wrap('<div class="bx-window" style="position:relative; overflow:hidden; width:'+wrapperwidth+'px;"></div>')
				.css({
				  width: '999999px',
				  position: 'relative',
					left: '-'+(options.infiniteloop ? origleft : 0)+'px'
				});
				$parent.children(options.childselector).css({
					width: childrenwidth,
				  'float': 'left',
				  liststyle: 'none'
				});					
				$outerwrapper = $parent.parent().parent();
				$children.addclass('bx-child');
			// css for vertical mode
			}else if(options.mode == 'vertical'){
				// wrap the <ul> in div that acts as a window and make the <ul> uber tall
				$parent
				.wrap('<div class="'+options.wrapperclass+'" style="width:'+childrenmaxwidth+'px; position:relative;"></div>')
				.wrap('<div class="bx-window" style="width:'+childrenmaxwidth+'px; height:'+wrapperheight+'px; position:relative; overflow:hidden;"></div>')
				.css({
				  height: '999999px',
				  position: 'relative',
					top: '-'+(origtop)+'px'
				});
				$parent.children(options.childselector).css({
				  liststyle: 'none',
					height: childrenmaxheight
				});					
				$outerwrapper = $parent.parent().parent();
				$children.addclass('bx-child');
			// css for fade mode
			}else if(options.mode == 'fade'){
				// wrap the <ul> in div that acts as a window
				$parent
				.wrap('<div class="'+options.wrapperclass+'" style="width:'+childrenmaxwidth+'px; position:relative;"></div>')
				.wrap('<div class="bx-window" style="height:'+childrenmaxheight+'px; width:'+childrenmaxwidth+'px; position:relative; overflow:hidden;"></div>');
				$parent.children(options.childselector).css({
				  liststyle: 'none',
				  position: 'absolute',
					top: 0,
					left: 0,
					zindex: 98
				});					
				$outerwrapper = $parent.parent().parent();
				$children.not(':eq('+currentslide+')').fadeto(0, 0,function(){$(this).hide();});
				$children.eq(currentslide).css({'zindex':99,display: 'list-item'});
			}
			// if captions = true setup a div placeholder
			if(options.captions && options.captionsselector == null){
				$outerwrapper.append('<div class="bx-captions"></div>');
			}			
		}
		
		/**
		 * depending on mode, lays out children in the proper setup
		 */		
		function setchildrenlayout(){			
			// lays out children for horizontal or vertical modes
			if( (options.mode == 'horizontal' || options.mode == 'vertical') && options.infiniteloop) {
				// get the children behind
				var $prependedchildren = getarraysample($children, 0, options.moveslideqty, 'backward');
				
				// add each prepended child to the back of the original element
				$.each($prependedchildren, function(index) {
					$parent.prepend($(this));
				});			
				
				// total number of slides to be hidden after the window
				var totalnumberafterwindow = ($children.length + options.moveslideqty) - 1;
				// number of original slides hidden after the window
				var pagerexcess = $children.length - options.displayslideqty;
				// number of slides to append to the original hidden slides
				var numbertoappend = totalnumberafterwindow - pagerexcess;
				// get the sample of extra slides to append
				var $appendedchildren = getarraysample($children, 0, numbertoappend, 'forward');
				
				if(options.infiniteloop){
					// add each appended child to the front of the original element
					$.each($appendedchildren, function(index) {
						$parent.append($(this));
					});
				}
			}
		}
		
		/**
		 * sets all variables associated with the controls
		 */		
		function setcontrolsvars(){
			// check if text or images should be used for controls
			// check "next"
			if(options.nextimage != ''){
				nextcontent = options.nextimage;
				nexttype = 'image';
			}else{
				nextcontent = options.nexttext;
				nexttype = 'text';
			}
			// check "prev"
			if(options.previmage != ''){
				prevcontent = options.previmage;
				prevtype = 'image';
			}else{
				prevcontent = options.prevtext;
				prevtype = 'text';
			}
			// show the controls
			showcontrols(nexttype, nextcontent, prevtype, prevcontent);
		}			
		
		/**
		 * puts slideshow into auto mode
		 *
		 * @param int pause number of ms the slideshow will wait between slides 
		 * @param string direction 'forward', 'backward' sets the direction of the slideshow (forward/backward)
		 * @param bool controls determines if start/stop controls will be displayed
		 */		
		function setautointerval(){
			if(options.auto){
				clearinterval(interval); // clear any existing interval
				
				// finite loop
				if(!options.infiniteloop){
					if(options.autodirection == 'next'){
						interval = setinterval(function(){
							currentslide += options.moveslideqty;
							// if currentslide has exceeded total number
							if(currentslide > lastslide){
								currentslide = currentslide % $children.length;
							}
							base.gotoslide(currentslide, false);
						}, options.pause);
					}else if(options.autodirection == 'prev'){
						interval = setinterval(function(){
							currentslide -= options.moveslideqty;
							// if currentslide is smaller than zero
							if(currentslide < 0){
								negativeoffset = (currentslide % $children.length);
								if(negativeoffset == 0){
									currentslide = 0;
								}else{
									currentslide = ($children.length) + negativeoffset; 
								}
							}
							base.gotoslide(currentslide, false);
						}, options.pause);
					}
				// infinite loop
				}else{
					if(options.autodirection == 'next'){
						interval = setinterval(function(){
							base.gotonextslide(false);
						}, options.pause);
					}else if(options.autodirection == 'prev'){
						interval = setinterval(function(){
							base.gotopreviousslide(false);
						}, options.pause);
					}
				}
			
			}else if(options.ticker){
				
				options.tickerspeed *= 10;
												
				// get the total width of the original show
				$('.bx-child', $outerwrapper).each(function(index) {
				  origshowwidth += $(this).width();
					origshowheight += $(this).height();
				});
				
				// if prev start the show from the last slide
				if(options.tickerdirection == 'prev' && options.mode == 'horizontal'){
					$parent.css('left', '-'+(origshowwidth+origleft)+'px');
				}else if(options.tickerdirection == 'prev' && options.mode == 'vertical'){
					$parent.css('top', '-'+(origshowheight+origtop)+'px');
				}
				
				if(options.mode == 'horizontal'){
					// get the starting left position
					tickerleft = parseint($parent.css('left'));
					// start the ticker
					movetheshow(tickerleft, origshowwidth, options.tickerspeed);
				}else if(options.mode == 'vertical'){
					// get the starting top position
					tickertop = parseint($parent.css('top'));
					// start the ticker
					movetheshow(tickertop, origshowheight, options.tickerspeed);
				}												
				
				// check it tickerhover applies
				if(options.tickerhover){
					settickerhover();
				}					
			}			
		}
		
		function movetheshow(leftcss, distance, speed){
			// if horizontal
			if(options.mode == 'horizontal'){
				// if next
				if(options.tickerdirection == 'next'){
					$parent.animate({'left': '-='+distance+'px'}, speed, 'linear', function(){
						$parent.css('left', leftcss);
						movetheshow(leftcss, origshowwidth, options.tickerspeed);
					});
				// if prev
				}else if(options.tickerdirection == 'prev'){
					$parent.animate({'left': '+='+distance+'px'}, speed, 'linear', function(){
						$parent.css('left', leftcss);
						movetheshow(leftcss, origshowwidth, options.tickerspeed);
					});
				}
			// if vertical		
			}else if(options.mode == 'vertical'){
				// if next
				if(options.tickerdirection == 'next'){
					$parent.animate({'top': '-='+distance+'px'}, speed, 'linear', function(){
						$parent.css('top', leftcss);
						movetheshow(leftcss, origshowheight, options.tickerspeed);
					});
				// if prev
				}else if(options.tickerdirection == 'prev'){
					$parent.animate({'top': '+='+distance+'px'}, speed, 'linear', function(){
						$parent.css('top', leftcss);
						movetheshow(leftcss, origshowheight, options.tickerspeed);
					});
				}
			}
		}		
		
		/**
		 * sets all variables associated with the controls
		 */		
		function setautocontrolsvars(){
			// check if text or images should be used for controls
			// check "start"
			if(options.startimage != ''){
				startcontent = options.startimage;
				starttype = 'image';
			}else{
				startcontent = options.starttext;
				starttype = 'text';
			}
			// check "stop"
			if(options.stopimage != ''){
				stopcontent = options.stopimage;
				stoptype = 'image';
			}else{
				stopcontent = options.stoptext;
				stoptype = 'text';
			}
			// show the controls
			showautocontrols(starttype, startcontent, stoptype, stopcontent);
		}
		
		/**
		 * handles hover events for auto shows
		 */		
		function setautohover(){
			// hover over the slider window
			$outerwrapper.children('.bx-window').hover(function() {
				if(autoplaying){
					base.suspendshow(false);
				}
			}, function() {
				if(autoplaying){
					base.restartshow(false);
				}
			});
		}
		
		/**
		 * handles hover events for ticker mode
		 */		
		function settickerhover(){
			// on hover stop the animation
			$parent.hover(function() {
				if(autoplaying){
					base.stopticker(false);
				}
			}, function() {
				if(autoplaying){
					base.startticker(false);
				}
			});
		}		
		
		/**
		 * handles fade animation
		 */		
		function setchildrenfade(){
			// fade out any other child besides the current
			$children.not(':eq('+currentslide+')').css('zindex', 98).fadeto(options.speed, 0,function(){ $(this).hide(); });			
			// fade in the current slide
			$children.eq(currentslide).show().css('zindex', 99).fadeto(options.speed, 1, function(){
				isworking = false;
				// ie fade fix
				if(jquery.browser.msie){
					$children.eq(currentslide).get(0).style.removeattribute('filter');
				}
				// perform the callback function
				options.onafterslide(currentslide, $children.length, $children.eq(currentslide));
			});
		};
				
		/**
		 * makes slide active
		 */		
		function makeslideactive(number){
			if(options.pagertype == 'full' && options.pager){
				// remove all active classes
				$('a', $pager).removeclass(options.pageractiveclass);
				// assign active class to appropriate slide
				$('a', $pager).eq(number).addclass(options.pageractiveclass);
			}else if(options.pagertype == 'short' && options.pager){
				$('.bx-pager-current', $pager).html(currentslide+1);
			}
		}
				
		/**
		 * displays next/prev controls
		 *
		 * @param string nexttype 'image', 'text'
		 * @param string nextcontent if type='image', specify a filepath to the image. if type='text', specify text.
		 * @param string prevtype 'image', 'text'
		 * @param string prevcontent if type='image', specify a filepath to the image. if type='text', specify text.
		 */		
		function showcontrols(nexttype, nextcontent, prevtype, prevcontent){
			// create pager html elements
			var $nexthtml = $('<a href="" class="bx-next"></a>');
			var $prevhtml = $('<a href="" class="bx-prev"></a>');
			// check if next is 'text' or 'image'
			if(nexttype == 'text'){
				$nexthtml.html(nextcontent);
			}else{
				$nexthtml.html('<img src="'+nextcontent+'" />');
			}
			// check if prev is 'text' or 'image'
			if(prevtype == 'text'){
				$prevhtml.html(prevcontent);
			}else{
				$prevhtml.html('<img src="'+prevcontent+'" />');
			}
			// check if user supplied a selector to populate next control
			if(options.prevselector){
				$(options.prevselector).append($prevhtml);
			}else{
				$outerwrapper.append($prevhtml);
			}
			// check if user supplied a selector to populate next control
			if(options.nextselector){
				$(options.nextselector).append($nexthtml);
			}else{
				$outerwrapper.append($nexthtml);
			}
			// click next control
			$nexthtml.click(function() {
				base.gotonextslide();
				return false;
			});
			// click prev control
			$prevhtml.click(function() {
				base.gotopreviousslide();
				return false;
			});
		}
		
		/**
		 * displays the pager
		 *
		 * @param string type 'full', 'short'
		 */		
		function showpager(type){
			// sets up logic for finite multi slide shows
			var pagerqty = $children.length;
			// if we are moving more than one at a time and we have a finite loop
			if(options.moveslideqty > 1){
				// if slides create an odd number of pages
				if($children.length % options.moveslideqty != 0){
					// pagerqty = $children.length / options.moveslideqty + 1;
					pagerqty = math.ceil($children.length / options.moveslideqty);
				// if slides create an even number of pages
				}else{
					pagerqty = $children.length / options.moveslideqty;
				}
			}
			var pagerstring = '';
			// check if custom build function was supplied
			if(options.buildpager){
				for(var i=0; i<pagerqty; i++){
					pagerstring += options.buildpager(i, $children.eq(i * options.moveslideqty));
				}
				
			// if not, use default pager
			}else if(type == 'full'){
				// build the full pager
				for(var i=1; i<=pagerqty; i++){
					pagerstring += '<a href="" class="pager-link pager-'+i+'">'+i+'</a>';
				}
			}else if(type == 'short') {
				// build the short pager
				pagerstring = '<span class="bx-pager-current">'+(options.startingslide+1)+'</span> '+options.pagershortseparator+' <span class="bx-pager-total">'+$children.length+'</span>';
			}	
			// check if user supplied a pager selector
			if(options.pagerselector){
				$(options.pagerselector).append(pagerstring);
				$pager = $(options.pagerselector);
			}else{
				var $pagercontainer = $('<div class="bx-pager"></div>');
				$pagercontainer.append(pagerstring);
				// attach the pager to the dom
				if(options.pagerlocation == 'top'){
					$outerwrapper.prepend($pagercontainer);
				}else if(options.pagerlocation == 'bottom'){
					$outerwrapper.append($pagercontainer);
				}
				// cache the pager element
				$pager = $outerwrapper.children('.bx-pager');
			}
			$pager.children().click(function() {
				// only if pager is full mode
				if(options.pagertype == 'full'){
					// get the index from the link
					var slideindex = $pager.children().index(this);
					// accomodate moving more than one slide
					if(options.moveslideqty > 1){
						slideindex *= options.moveslideqty;
					}
					base.gotoslide(slideindex);
				}
				return false;
			});
		}
				
		/**
		 * displays captions
		 */		
		function showcaptions(){
			// get the title from each image
		  var caption = $('img', $children.eq(currentslide)).attr('title');
			// if the caption exists
			if(caption != ''){
				// if user supplied a selector
				if(options.captionsselector){
					$(options.captionsselector).html(caption);
				}else{
					$outerwrapper.children('.bx-captions').html(caption);
				}
			}else{
				// if user supplied a selector
				if(options.captionsselector){
					$(options.captionsselector).html('&nbsp;');
				}else{
					$outerwrapper.children('.bx-captions').html('&nbsp;');
				}				
			}
		}
		
		/**
		 * displays start/stop controls for auto and ticker mode
		 *
		 * @param string type 'image', 'text'
		 * @param string next [optional] if type='image', specify a filepath to the image. if type='text', specify text.
		 * @param string prev [optional] if type='image', specify a filepath to the image. if type='text', specify text.
		 */
		function showautocontrols(starttype, startcontent, stoptype, stopcontent){
			// create pager html elements
			$autocontrols = $('<a href="" class="bx-start"></a>');
			// check if start is 'text' or 'image'
			if(starttype == 'text'){
				$startcontent = startcontent;
			}else{
				$startcontent = '<img src="'+startcontent+'" />';
			}
			// check if stop is 'text' or 'image'
			if(stoptype == 'text'){
				$stopcontent = stopcontent;
			}else{
				$stopcontent = '<img src="'+stopcontent+'" />';
			}
			// check if user supplied a selector to populate next control
			if(options.autocontrolsselector){
				$(options.autocontrolsselector).append($autocontrols);
			}else{
				$outerwrapper.append('<div class="bx-auto"></div>');
				$outerwrapper.children('.bx-auto').html($autocontrols);
			}
						
			// click start control
			$autocontrols.click(function() {
				if(options.ticker){
					if($(this).hasclass('stop')){
						base.stopticker();
					}else if($(this).hasclass('start')){
						base.startticker();
					}
				}else{
					if($(this).hasclass('stop')){
						base.stopshow(true);
					}else if($(this).hasclass('start')){
						base.startshow(true);
					}
				}
				return false;
			});
			
		}
		
		/**
		 * checks if show is in finite mode, and if slide is either first or last, then hides the respective control
		 */		
		function checkendcontrols(){
			if(!options.infiniteloop && options.hidecontrolonend){
				// check previous
				if(currentslide == firstslide){
					$outerwrapper.children('.bx-prev').hide();				
				}else{
					$outerwrapper.children('.bx-prev').show();
				}
				// check next
				var lastpossibleslide = math.floor(lastslide/options.displayslideqty) * options.displayslideqty;
        if(currentslide >= lastpossibleslide){
					$outerwrapper.children('.bx-next').hide();
				}else{
					$outerwrapper.children('.bx-next').show();
				}
			}
		}
		
		/**
		 * returns the left offset of the slide from the parent container
		 */		
		function getslideposition(number, side){			
			var $slideposition = $parent.find(' > .bx-child').eq(number).position();
			return (side == 'left') ? $slideposition.left : $slideposition.top;
		}
		
		/**
		 * returns the width of the wrapper
		 */		
		function getwrapperwidth(){
			var wrapperwidth = $firstchild.outerwidth() * options.displayslideqty;
			return wrapperwidth;
		}
		
		/**
		 * returns the height of the wrapper
		 */		
		function getwrapperheight(){
			// if displaying multiple slides, multiple wrapper width by number of slides to display
			var wrapperheight = $firstchild.outerheight() * options.displayslideqty;
			return wrapperheight;
		}
		
		/**
		 * returns a sample of an arry and loops back on itself if the end of the array is reached
		 *
		 * @param array array original array the sample is derived from
		 * @param int start array index sample will start
		 * @param int length number of items in the sample
		 * @param string direction 'forward', 'backward' direction the loop should travel in the array
		 */		
		function getarraysample(array, start, length, direction){
			// initialize empty array
			var sample = [];
			// clone the length argument
			var looplength = length;
			// determines when the empty array should start being populated
			var startpopulatingarray = false;
			// reverse the array if direction = 'backward'
			if(direction == 'backward'){
				array = $.makearray(array);
				array.reverse();
			}
			// loop through original array until the length argument is met
			while(looplength > 0){				
				// loop through original array
				$.each(array, function(index, val) {
					// check if length has been met
					if(looplength > 0){
						// don't do anything unless first index has been reached
					  if(!startpopulatingarray){
							// start populating empty array
							if(index == start){
								startpopulatingarray = true;
								// add element to array
								sample.push($(this).clone());
								// decrease the length clone variable
								looplength--;
							}
						}else{
							// add element to array
							sample.push($(this).clone());
							// decrease the length clone variable
							looplength--;
						}
					// if length has been met, break loose
					}else{
						return false;
					}			
				});				
			}
			return sample;
		}
												
		this.each(function(){
			// make sure the element has children
			if($(this).children().length > 0){
				base.initshow();
			}
		});
				
		return this;						
	}
	
	jquery.fx.prototype.cur = function(){
		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
			return this.elem[ this.prop ];
		}

		var r = parsefloat( jquery.css( this.elem, this.prop ) );
		// return r && r > -10000 ? r : 0;
		return r;
	}

		
})(jquery);