text: // SpryPanelSet.js - version 0.4 - Spry Pre-Release 1.7
  //
  // Copyright (c) 2010. Adobe Systems Incorporated.
  // All rights reserved.
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are met:
  //
  //   * Redistributions of source code must retain the above copyright notice,
  //     this list of conditions and the following disclaimer.
  //   * Redistributions in binary form must reproduce the above copyright notice,
  //     this list of conditions and the following disclaimer in the documentation
  //     and/or other materials provided with the distribution.
  //   * Neither the name of Adobe Systems Incorporated nor the names of its
  //     contributors may be used to endorse or promote products derived from this
  //     software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  // POSSIBILITY OF SUCH DAMAGE.
  
  (function() { // BeginSpryComponent
  
  if (typeof Spry == "undefined" || !Spry.Widget || !Spry.Widget.Base)
  {
  	alert("SpryPanelSet.js requires SpryWidget.js!");
  	return;
  }
  
  Spry.Widget.PanelSet = function(elements, opts)
  {
  	Spry.Widget.Base.call(this);
  
  	this.elements = elements ? Spry.$$(elements) : [];
  	this.currentPanel = null;
  
  	// Slide Show Mode properties.
  
  	this.displayTimerID = 0;
  
  	// Initialize the panel set object with the global defaults.
  
  	this.setOptions(this, Spry.Widget.PanelSet.config);
  	
  	// Override the defaults with any options passed into the constructor.
  
  	this.setOptions(this, opts);
  
  	if (typeof (this.defaultPanel) == "number")
  	{
  		if (this.defaultPanel < 0)
  			this.defaultPanel = 0;
  		else
  		{
  			var count = this.getPanelCount();
  			if (this.defaultPanel >= count)
  				this.defaultPanel = (count > 1) ? (count - 1) : 0;
  		}
  
  	}
  
  	this.initialize();
  };
  
  Spry.Widget.PanelSet.prototype = new Spry.Widget.Base();
  Spry.Widget.PanelSet.prototype.constructor = Spry.Widget.PanelSet;
  
  Spry.Widget.PanelSet.config = {
  	defaultPanel:    0,
  	autoPlay:       false,
  	displayInterval: 4000, // msecs
  
  	visibleClass:    "PanelVisible",
  	hiddenClass:     "PanelHidden"
  }
  
  Spry.Widget.PanelSet.prototype.initialize = function()
  {
  	var evt = new Spry.Widget.Event(this);
  	this.notifyObservers("onPreInitialize", evt);
  	if (!evt.performDefaultAction)
  		return;
  
  	this.defaultPanel = this.indexToElement(this.defaultPanel);
  	var panels = this.getPanels();
  
  	for (var i = 0; i < panels.length; i++)
  	{
  		var ele = panels[i];
  		var addClass = this.hiddenClass;
  		var removeClass = this.visibleClass;
  
  		if (ele == this.defaultPanel)
  		{
  			addClass = this.visibleClass;
  			removeClass = this.hiddenClass;
  			this.currentPanel = this.defaultPanel;
  		}
  
  		Spry.Utils.addClassName(ele, addClass);
  		Spry.Utils.removeClassName(ele, removeClass);
  	}
  
  	if (this.autoPlay)
  		this.play();
  
  	this.notifyObservers("onPostInitialize", evt);
  };
  
  Spry.Widget.PanelSet.prototype.getPanels = function()
  {
  	return this.elements.slice(0);
  };
  
  Spry.Widget.PanelSet.prototype.getPanelCount = function()
  {
  	return this.getPanels().length;
  };
  
  Spry.Widget.PanelSet.prototype.getCurrentPanel = function()
  {
  	return this.currentPanel;
  };
  
  Spry.Widget.PanelSet.prototype.getCurrentPanelIndex = function()
  {
  	return this.getPanelIndex(this.getCurrentPanel());
  };
  
  Spry.Widget.PanelSet.prototype.getPanelIndex = function(panel)
  {
  	var panels = this.getPanels();
  	for (var i = 0; i < panels.length; i++)
  	{
  		if (panel == panels[i])
  			return i;
  	}
  	return -1;
  };
  
  Spry.Widget.PanelSet.prototype.getPanel = function(panelIndex)
  {
  	return this.getPanels()[panelIndex];
  };
  
  Spry.Widget.PanelSet.prototype.indexToElement = function(eleOrIndex)
  {
  	if (typeof eleOrIndex == "number")
  		return this.getPanels()[eleOrIndex];
  	return eleOrIndex ? Spry.$$(eleOrIndex)[0] : eleOrIndex;
  };
  
  Spry.Widget.PanelSet.prototype.elementToIndex = function(eleOrIndex)
  {
  	var panels = this.getPanels();
  
  	if (typeof eleOrIndex == "number")
  		return panels[eleOrIndex];
  
  	if (typeof eleOrIndex == "string")
  		eleOrIndex = Spry.$$(eleOrIndex)[0];
  
  	return !eleOrIndex ? -1 : panels.indexOf(eleOrIndex);
  };
  
  Spry.Widget.PanelSet.prototype.createEvent = function(target, opts)
  {
  	var eopts = {
  		target: target,
  		targetIndex: this.getPanelIndex(target)
  	};
  	return new Spry.Widget.Event(this, this.setOptions(eopts, opts));
  };
  
  Spry.Widget.PanelSet.prototype.showPanel = function(eleOrIndex)
  {
  	var ele = this.indexToElement(eleOrIndex);
  	if (ele && ele != this.currentPanel)
  	{
  		var evt = this.createEvent(ele, { currentPanel: this.currentPanel });
  		this.notifyObservers("onPreShowPanel", evt);
  
  		if (evt.performDefaultAction)
  		{
  			if (this.currentPanel)
  				this.hidePanel(this.currentPanel);
  	
  			this.currentPanel = ele;
  	
  			Spry.Utils.addClassName(ele, this.visibleClass);
  			Spry.Utils.removeClassName(ele, this.hiddenClass);
  
  			this.notifyObservers("onPostShowPanel", evt);
  		}
  	}
  };
  
  Spry.Widget.PanelSet.prototype.hidePanel = function(eleOrIndex)
  {
  	var evt = this.createEvent(this.currentPanel);
  	this.notifyObservers("onPreHidePanel", evt);
  
  	if (evt.performDefaultAction)
  	{
  		var ele = this.currentPanel;
  
  		Spry.Utils.addClassName(ele, this.hiddenClass);
  		Spry.Utils.removeClassName(ele, this.visibleClass);
  
  		this.currentPanel = null;
  
  		this.notifyObservers("onPostHidePanel", evt);
  	}
  };
  
  Spry.Widget.PanelSet.prototype.showPreviousPanel = function()
  {
  	var evt = new Spry.Widget.Event(this);
  	this.notifyObservers("onPreShowPreviousPanel", evt);
  	if (!evt.performDefaultAction)
  		return;
  
  	var curIndex = this.getCurrentPanelIndex();
  	this.showPanel(((curIndex < 1) ? this.getPanelCount() : curIndex) - 1);
  
  	this.notifyObservers("onPostShowPreviousPanel", evt);
  };
  
  Spry.Widget.PanelSet.prototype.showNextPanel = function()
  {
  	var evt = new Spry.Widget.Event(this);
  	this.notifyObservers("onPreShowNextPanel", evt);
  	if (!evt.performDefaultAction)
  		return;
  
  	this.showPanel((this.getCurrentPanelIndex()+1) % this.getPanelCount());
  
  	this.notifyObservers("onPostShowNextPanel", evt);
  };
  
  Spry.Widget.PanelSet.prototype.showFirstPanel = function()
  {
  	var evt = new Spry.Widget.Event(this);
  	this.notifyObservers("onPreShowFirstPanel", evt);
  	if (!evt.performDefaultAction)
  		return;
  
  	this.showPanel(0);
  
  	this.notifyObservers("onPostShowFirstPanel", evt);
  };
  
  Spry.Widget.PanelSet.prototype.showLastPanel = function()
  {
  	var evt = new Spry.Widget.Event(this);
  	this.notifyObservers("onPreShowLastPanel", evt);
  	if (!evt.performDefaultAction)
  		return;
  
  	var count = this.getPanelCount();
  	this.showPanel(count > 0 ? count - 1 : 0);
  
  	this.notifyObservers("onPostShowLastPanel", evt);
  };
  
  
  Spry.Widget.PanelSet.prototype.startTimer = function()
  {
  	this.stopTimer();
  	var self = this;
  	this.displayTimerID = setTimeout(function() { self.showNextPanel(); self.startTimer(); }, this.displayInterval);
  };
  
  Spry.Widget.PanelSet.prototype.stopTimer = function()
  {
  	if (this.displayTimerID)
  		clearTimeout(this.displayTimerID);
  	this.displayTimerID = 0;
  };
  
  Spry.Widget.PanelSet.prototype.isPlaying = function()
  {
  	return this.displayTimerID != 0;
  };
  
  Spry.Widget.PanelSet.prototype.play = function()
  {
  	var evt = new Spry.Widget.Event(this);
  	this.notifyObservers("onPreStartSlideShowMode", evt);
  	if (!evt.performDefaultAction)
  		return;
  
  	this.startTimer();
  
  	this.notifyObservers("onPostStartSlideShowMode", evt);
  };
  
  Spry.Widget.PanelSet.prototype.stop = function()
  {
  	var evt = new Spry.Widget.Event(this);
  	this.notifyObservers("onPreStopSlideShowMode", evt);
  	if (!evt.performDefaultAction)
  		return;
  
  	this.stopTimer();
  
  	this.notifyObservers("onPostStopSlideShowMode", evt);
  };
  
  })(); // EndSpryComponent