// Copyright (c) 2003 Sonic Foundry, Inc. and Sonic Foundry 
// Media Systems, Inc. Neither this code nor any portion 
// thereof may be reproduced, altered, or otherwise changed, 
// distributed or copied, without the express written 
// permission of Sonic Foundry.  
// All rights reserved.

// BEGINFILE CurrentSlideArea.js ------------------------------------------------------------------------->

CurrentSlideArea.prototype = new AreaBase();
function CurrentSlideArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	this.InitializeArea(container, containingWindow, ID);

	this.m_imageCache = new ImageCache(this.Container + ".m_imageCache");
	this.CurrentImage;
	this.CurrentThumbNailImage;
		
	this.FullSizeWindowWidth;
	this.FullSizeWindowHeight; 
	
	// Options
	this.ShowSlideEffect = false;
	this.ShowNoImage = false;
	this.LoadAltText = false;

	this.OnLoad = function()
	{
		this.Debug("CurrentSlideAreaOnLoad called");
		this.FullSizeWindowWidth = MainHelper.DefaultFullSizeWindowWidth;
		this.FullSizeWindowHeight = MainHelper.DefaultFullSizeWindowHeight;
		this.LoadDefaultImage();
		this.RegisterCurrentSlideEvents();
	}

	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad called");
		
		MainHelper.EventScript.RemoveHandler(this.ScriptEventHandler);
		MainHelper.EventCommand.RemoveHandler(this.CommandEventHandler);
		MainHelper.EventDataAvailable.RemoveHandler(this.DataAvailableEventHandler);
		MainHelper.EventPlayBegin.RemoveHandler(this.PlayBeginEventHandler);
	}

	this.RegisterCurrentSlideEvents = function()
	{
		this.Debug("RegisterCurrentSlideEvents()");
		
		this.ScriptEventHandler = new SfEventHandler(this.Container);
		this.ScriptEventHandler.Container = this.Container;
		this.ScriptEventHandler.MethodName = "OnScriptEvent";

		MainHelper.EventScript.AddHandler(this.ScriptEventHandler);
		
		this.CommandEventHandler = new SfEventHandler(this.Container);
		this.CommandEventHandler.Container = this.Container;
		this.CommandEventHandler.MethodName = "CurrentSlideOnCommandEvent";
		
		MainHelper.EventCommand.AddHandler(this.CommandEventHandler);
		
		this.DataAvailableEventHandler = new SfEventHandler(this.Container);
		this.DataAvailableEventHandler.Container = this.Container;
		this.DataAvailableEventHandler.MethodName = "CurrentSlideOnDataAvailableEvent";
		
		MainHelper.EventDataAvailable.AddHandler(this.DataAvailableEventHandler);

		this.PlayBeginEventHandler = new SfEventHandler(this.ID);
		this.PlayBeginEventHandler.MethodName = "OnPlayBeginEvent";
		this.PlayBeginEventHandler.Container = this.Container;
		MainHelper.EventPlayBegin.AddHandler(this.PlayBeginEventHandler);
	}

	this.OnPlayBeginEvent = function()
	{
		this.Debug("OnPlayBeginEvent");
		var currentSlideNumber = MainHelper.CurrentSlideNumber;
		this.Debug("CurrentSlideNumber: " + currentSlideNumber);
		if (currentSlideNumber == -1)
		{
			this.Reset();
		}
	}
	
	this.Reset = function()
	{
		this.Debug("Reset called");

		this.LoadDefaultImage();

		this.SetAltText('Default Slide Image');

		if (this.ShowMagnifyButton == true)
		{
			var slideImage = this.GetSlideImage();
			slideImage.onclick = null;
			Util.SetCursor(slideImage, CursorType.Default);

			var magnifyDiv = this.FindMagnifyDiv();
			magnifyDiv.style.visibility  = 'hidden';
		}
		
		this.m_clickInitialized = false;
		return;
	}
	
	this.OnScriptEvent = function(args)
	{
		this.Debug("OnScriptEvent: " + args);
		switch(args.Command)
		{
			case SfScriptCommandType.ShowSlide:
				this.OnShowSlide(args);
				MainHelper.EventSlideChanged.Post(args);
				break;
			case SfScriptCommandType.EndPresentation:
				this.OnEndPresentation(args);
				break;
		}
	}
	
	this.CurrentSlideOnCommandEvent = function(args)
	{
		this.Debug("CurrentSlideOnCommandEvent: " + args.Command);
		switch(args.Command)
		{
			case SfCommandType.Play:
				if (MainHelper.PresentationEnded == true)
				{
					this.GetSlideImage().src = this.DefaultReplayImage;
				}
				break;
		}
	}
	
	this.CurrentSlideOnDataAvailableEvent = function(args)
	{
		this.Debug("CurrentSlideOnDataAvailableEvent");
		this.SetCurrentCaptureImage();
	}

	// the following three vars are emitted
	// this.DefaultReplayImage
	// this.NotStartedImage
	// this.EndedImage
	this.LoadDefaultImage = function()
	{
		this.Debug("LoadDefaultImage called");
		
		var presentationStatus = MainHelper.Presentation.Status;
		var imageSrc;
		switch (presentationStatus)
		{
			case PresentationStatus.CaptureInProgress:
				this.SetCurrentCaptureImage();
				break;
			case PresentationStatus.ReplayReady:
				this.SetSlideImage(this.DefaultReplayImage);
				break;
			case PresentationStatus.Ended:
				if (MainHelper.Presentation.IsStandAlone == true)
				{
					this.SetSlideImage(this.DefaultReplayImage);
				}
				else
				{	 
					this.SetSlideImage(this.EndedImage);
				}
				break;
			case PresentationStatus.NotReady:
			case PresentationStatus.CaptureReady:
				this.SetSlideImage(this.NotStartedImage);
				break;
			default:
				SfDebug.DPF(SfDebug.ErrMsgCritical, "CurrentSlideAreaOnLoad: PresentationStatus not known");
				this.SetSlideImage(this.NotStartedImage);
				break;
		}
	}

	this.SetSlideImage = function(imageSrc)
	{
		var slideImage = this.GetSlideImage();
		slideImage.src = imageSrc;
		slideImage.style.display = "";
	}
	
	this.SetCurrentCaptureImage = function()
	{
		this.Debug("SetCurrentCaptureImage called");
		var slideTimings = MainHelper.Presentation.SlideTimings;
		if (!slideTimings)
		{
			this.SetSlideImage(this.DefaultReplayImage);
			return;
		}
		var max = slideTimings.length;
		this.Debug("Max: " + max);
		if (!max)
		{
			this.SetSlideImage(this.DefaultReplayImage);
			return;
		}
		if (max < 1)
		{
			this.SetSlideImage(this.DefaultReplayImage);
			return;
		}

		// some slides have already been sent at this point		
		this.CurrentImage = MainHelper.GetImageLocation(max, SlideType.Normal);
		MainHelper.CurrentFullSizeImage = MainHelper.GetImageLocation(max, SlideType.FullSize);
		this.CurrentThumbNailImage = MainHelper.GetImageLocation(max, SlideType.ThumbNail);
		MainHelper.CurrentSlideNumber = max;
		this.SetSlideImage(this.CurrentImage);
		this.InitializeClick();
	}
	
	// makes the slide clickable
	// we don't do it until OnShowSlide has happened
	this.m_clickInitialized = false;
	this.InitializeClick = function()
	{
		this.Debug("CurrentSlide InitializeClick called");
		if (this.m_clickInitialized)
		{
			return;
		}
		
		if (this.ShowMagnifyButton == true)
		{
			var imageDiv = this.GetSlideImage();
			imageDiv.onclick = new Function("", "CurrentSlideAreaInstance.OpenFullSizeWindow();");
			imageDiv.title =  this.ShowFullSizeToolTip;
			Util.SetCursor(imageDiv, CursorType.Hand);

			var magnifyDiv = this.FindMagnifyDiv();
			Util.SetCursor(magnifyDiv, CursorType.Hand);

			magnifyDiv.style.visibility  = 'visible';
			
			magnifyDiv.onclick = new Function("", "CurrentSlideAreaInstance.OpenFullSizeWindow();");
			
			var magnifyImage = this.FindMagnifyImage();
			magnifyImage.title = this.ShowFullSizeToolTip;
			magnifyImage.alt = this.ShowFullSizeToolTip;
		}

		this.m_clickInitialized = true;
	}
	
	this.OnShowSlide = function(args)
	{
		this.Debug("OnShowSlide called");
		if (args.Index < 1)
		{
			this.Debug("slideNumber < 1");
			MainHelper.CurrentSlideNumber = -1;
			this.Reset();
			return;
		}
		
		this.Debug("OnShowSlide: " +
			", image: " + args.Image);
		
		this.CurrentImage = args.Image;
		MainHelper.CurrentFullSizeImage = args.FullSizeImage;
		this.CurrentThumbNailImage = args.ThumbNailImage;
		var currentSlideNumber = args.Index;

		var imageElement = this.GetSlideImage();
		if (this.ShowNoImage == false)
		{
			imageElement.src = this.CurrentImage;
		}
		else
		{
			imageElement.src = "";
		}

		this.DoAltTextStuff(imageElement, currentSlideNumber);
		
		if (this.ShowSlideEffect == true)
		{
			this.Slide();
		}
		
		// cache the next image for non-live presentations.
		if ((MainHelper.Presentation.Status != PresentationStatus.CaptureInProgress) && 
			(currentSlideNumber < MainHelper.Presentation.SlideTimings.length))
		{
			var nextImageUrl = MainHelper.GetImageLocation(MainHelper.CurrentSlideNumber + 1, SlideType.Normal);
			this.Debug("Putting " + nextImageUrl + " in cache");
			this.m_imageCache.AddImage(nextImageUrl, true);
		}
		
		this.UpdateFullSizeWindow(this.CurrentImage);
		
		if (!this.m_clickInitialized)
		{
			this.InitializeClick();
		}
		
	}
	
	this.DoAltTextStuff = function(imageElement, currentSlideNumber)
	{
		this.Debug("DoAltTextStuff()");
		
		if (this.LoadAltText == false)
		{
			imageElement.alt = "Slide number: " + currentSlideNumber;
			return;
		}
		
		if (MainHelper.Presentation.Status == PresentationStatus.CaptureInProgress)
		{
			imageElement.alt = "Slide number: " + currentSlideNumber;
		}
		else
		{
			this.SetAltText(this.AltTexts[currentSlideNumber-1]);
		}

	}

	this.SetAltText = function(text)
	{
		this.Debug("Setting alt text: " + text);
		
		var imageElement = this.GetSlideImage();
		if (!imageElement)
		{
			this.Debug("could not get imageElement");
			return;
		}

		imageElement.alt = text;
	}
	
	this.GetSlideImage = function()
	{
		var slideImage = SfDOM.FindElementFromID(document, this.ID + "slideImage");
		return slideImage;
	}

	this.FindMagnifyDiv = function()
	{
		return SfDOM.FindElementFromID(document, this.ID + "magnifyDiv");
	}
	
	this.FindMagnifyImage = function()
	{
		return SfDOM.FindElementFromID(document, this.ID + "magnifyImage");
	}
	
	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "CurrentSlideArea: " + str);
	}
	
	// If FullSizeArea is not open then opens it
	this.OpenFullSizeWindow = function()
	{
		this.Debug("OpenFullSizeWindow called, width: " + this.FullSizeWindowWidth + ", height: " + this.FullSizeWindowHeight);
		if (WindowHelper.IsOpen(MainHelper.PopupWindows.FullSize) == true)
		{
			this.Debug("Is already open");
			return;
		}
		
		MainHelper.PopupWindows.FullSize =
			
			WindowHelper.CreateNamedPopup(
				PopupNames.FullSize,
				"FullSize",
				this.FullSizeWindowWidth,
				this.FullSizeWindowHeight,
				true,
				true);
	}

	this.UpdateFullSizeWindow = function()
	{
		this.Debug("UpdateFullSizeWindow called");
		
		if (WindowHelper.IsOpen(MainHelper.PopupWindows.FullSize) == false)
		{
			this.Debug("window is not open");
			return;
		}
		
		var areaManager = GetAreaManager();
		if (!areaManager)
		{
			this.Debug("could not find AreaManager");
			return;
		}
		var fullSize = areaManager.GetArea(AreaNames.FullSizeSlideArea);
		if (fullSize)
		{
			fullSize.UpdateIfNeeded(MainHelper.CurrentFullSizeImage, MainHelper.CurrentSlideNumber);
		}
	}
	
	this.OnEndPresentation = function(args)
	{
		this.Debug("OnEndPresentation called");
		
		var slideImage = this.GetSlideImage();
		slideImage.src = this.EndedImage;
		slideImage.title = '';
		
		this.SetAltText('Presentation has ended Image');

		if (this.ShowMagnifyButton == true)
		{
			slideImage.onclick = null;
			Util.SetCursor(slideImage, CursorType.Default);

			var magnifyDiv = this.FindMagnifyDiv();
			magnifyDiv.style.visibility  = 'hidden';
		}
		
		this.m_clickInitialized = false;
	}

	this.AnimFinished = true;
	this.CancelAnim = false;
	this.Slide = function()
	{
		if (!this.Position)
		{
			return;
		}
		if (this.AnimFinished == false)
		{
			this.CancelAnim = true;
			return;
		}

		this.CancelAnim = false;
		this.AnimFinished = false;

		this.InitialX = this.Position.X;		
		this.Move(new Point(this.InitialX + this.Width, this.Position.Y));
		
		setTimeout("CurrentSlideAreaInstance.SlideOneStep()", 1);
	}
	
	this.SlideOneStep = function()
	{
		if (this.CancelAnim == true)
		{
			this.Move(new Point(this.InitialX, this.Position.Y));
			this.AnimFinished = true;
			return;
		}
		
		var currentX = this.Position.X;
		if (currentX <= this.InitialX)
		{
			this.Move(new Point(this.InitialX, this.Position.Y));
			this.AnimFinished = true;
			return;
		}
		
		this.Move(new Point(currentX - 100, this.Position.Y));

		setTimeout("CurrentSlideAreaInstance.SlideOneStep()", 1);
	}

}

// ENDFILE CurrentSlideArea.js --------------------------------------------------------------------------->

// BEGINFILE PresentationCardArea.js --------------------------------------------------------------------->
function SfPositioning()
{
	this.Top = null;
	this.Left = null;
	this.Width = null;
	this.Height = null;
}

PresentationCardArea.prototype = new AreaBase();
function PresentationCardArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	this.InitializeArea(container, containingWindow, ID);
	this.InitialDimensions = null;
	this.ExpandCollapseImage = null;
	this.ScrollDiv = null;
	this.Expanded = false;
	
	this.AllowZooming = false;
	this.OnMouseOverDimensions = new SfPositioning();
	this.ToolTipExpand = null;
	this.ToolTipCollapse = null;
	this.ZIndexPrevious = 0;

	this.OnLoad = function()
	{
		this.Debug("PresentationCardAreaOnLoad()");
		this.RegisterPresentationCardEvents();
		this.InitializeZooming();
		this.InitializeDetailsArea();
	}
	
	this.InitializeZooming = function()
	{
		this.Debug("InitializeZooming()");
		if (this.AllowZooming == false)
		{
			this.GetScrollDiv().style.overflow = 'auto';
			return;
		}

		this.ScrollDiv = this.GetScrollDiv();
		this.ExpandCollapseImage = this.GetExpandCollapseImage();

		this.InitialDimensions = new SfPositioning();
		this.InitialDimensions.Top = this.GetDiv().style.top;
		this.InitialDimensions.Left = this.GetDiv().style.left;
		this.InitialDimensions.Width = this.ScrollDiv.style.width;
		this.InitialDimensions.Height = this.ScrollDiv.style.height;

		this.ExpandCollapseImage.onclick = new Function("", this.Container + ".ExpandCollapse();");
		this.ExpandCollapseImage.onmouseover = new Function("", this.Container + ".ExpandCollapseOnMouseOver();");
		this.ExpandCollapseImage.onmouseout = new Function("", this.Container + ".ExpandCollapseOnMouseOut();");
		SfDOM.SetToolTip(this.ExpandCollapseImage, this.ToolTipExpand);
		Util.SetCursor(this.ExpandCollapseImage, CursorType.Hand);
	}
	
	this.GetExpandCollapseImage = function()
	{
		return SfDOM.FindElementFromID(document, this.ID + "ExpandCollapseImage");
	}
	
	this.GetScrollDiv = function()
	{
		return SfDOM.FindElementFromID(document, this.ID + "ScrollDiv");
	}
	
	this.ExpandCollapse = function()
	{
		this.Debug("ExpandCollapse()");
		if (this.Expanded == true)
		{
			this.Collapse();
		}
		else
		{
			this.Expand();
		}
		this.Expanded = !this.Expanded;
	}
	
	this.ExpandCollapseOnMouseOver = function()
	{
		if (this.Expanded)
		{
			this.ExpandCollapseImage.className = 'cardCollapseOver';
		}
		else
		{
			this.ExpandCollapseImage.className = 'cardExpandOver';
		}
	}
	
	this.ExpandCollapseOnMouseOut = function()
	{
		if (this.Expanded)
		{
			this.ExpandCollapseImage.className = 'cardCollapse';
		}
		else
		{
			this.ExpandCollapseImage.className = 'cardExpand';
		}
	}
	
	this.Expand = function()
	{
		this.Debug("Expand()");
		this.GetDiv().style.top = this.OnMouseOverDimensions.Top;
		this.GetDiv().style.left = this.OnMouseOverDimensions.Left;
		this.GetDiv().style.zIndex = ZIndex.Highest;
		this.ScrollDiv.style.width = this.OnMouseOverDimensions.Width;
		this.ScrollDiv.style.height = this.OnMouseOverDimensions.Height;
		this.ScrollDiv.style.overflow = 'auto';
		this.ExpandCollapseImage.className = 'cardCollapse';
		SfDOM.SetToolTip(this.ExpandCollapseImage, this.ToolTipCollapse);
	}
	
	this.Collapse = function()
	{
		this.Debug("Collapse()");
		this.GetDiv().style.top = this.InitialDimensions.Top;
		this.GetDiv().style.left = this.InitialDimensions.Left;
		this.ScrollDiv.style.width = this.InitialDimensions.Width;
		this.ScrollDiv.style.height = this.InitialDimensions.Height;
		this.ScrollDiv.style.overflow = 'hidden';
		this.GetDiv().style.zIndex = ZIndex.Lowest;
		this.ExpandCollapseImage.className = 'cardExpand';
		SfDOM.SetToolTip(this.ExpandCollapseImage, this.ToolTipExpand);
	}
	
	this.InitializeDetailsArea = function()
	{
		this.DetailsSpan = SfDOM.FindElementFromID(document, this.ID + "Details");
		this.DetailsSpan.onmouseover = new Function("", this.Container + ".DetailsOnMouseOver();");
		this.DetailsSpan.onmouseout = new Function("", this.Container + ".DetailsOnMouseOut();");
		this.DetailsSpan.onclick = new Function("", this.Container + ".DetailsOnClick();");
	}
	
	this.DetailsOnMouseOver = function()
	{
		this.DetailsSpan.style.textDecoration = 'underline';
		Util.SetCursor(this.DetailsSpan, CursorType.Hand);
	}
	
	this.DetailsOnMouseOut = function()
	{
		this.DetailsSpan.style.textDecoration = 'none';
		Util.SetCursor(this.DetailsSpan, CursorType.Default);
	}

	this.DetailsOnClick = function()
	{
		this.Debug("DetailsOnClick()");
		window.popupDetails = WindowHelper.CreateNamedPopup(PopupNames.PresentationDetails, 'pd', 650, 300, true, false);
		window.popupDetails.focus();
	}
	
	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad called");
	}

	this.RegisterPresentationCardEvents = function()
	{
	}

	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "PresentationCard: " + str);
	}
}

// ENDFILE PresentationCardArea.js ----------------------------------------------------------------------->

// BEGINFILE ImageArea.js ------------------------------------------------------------------------------>

ImageArea.prototype = new AreaBase();
function ImageArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "ImageArea: " + str);
	}
}

// ENDFILE ImageArea.js ------------------------------------------------------------------------------>

// BEGINFILE LiveIndicatorArea.js ------------------------------------------------------------------------->

LiveIndicatorArea.prototype = new AreaBase();
function LiveIndicatorArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	this.activeToolTip = "";
	this.activeSrc = "";
	this.inactiveToolTip = "";
	this.inactiveSrc = "";

	this.InitializeArea(container, containingWindow, ID);
	
	this.GetImage = function()
	{
		this.Debug("GetImage called");
		var image;
		
		image=SfDOM.FindElementFromName(document,this.ID+"Img");
		
		if (image==null)
			image=SfDOM.FindElementFromName(document,this.ID);
			
		if (image==null)
		{
		    SfDebug.DPF(SfDebug.ErrMsgCritical,"No image for "+this.ID+"Img");
		}
			
		return image;
	}

	this.OnLoad = function()
	{
		this.Debug("OnLoad");
		this.AddEventHandlers();
		
		if (MainHelper.Presentation.Status == PresentationStatus.CaptureInProgress || 
			MainHelper.Presentation.Status == PresentationStatus.CaptureReady ||
			MainHelper.Presentation.Status == PresentationStatus.NotReady)
		{
			this.GetImage().title = this.activeToolTip;
			this.GetImage().alt = this.activeToolTip;
			this.GetImage().src = this.activeSrc;
		}
		else
		{
			this.GetImage().title = this.inactiveToolTip;
			this.GetImage().alt = this.inactiveToolTip;
			this.GetImage().src = this.inactiveSrc;
		}
	}

	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad called");
		this.RemoveEventHandlers();
	}
	
	this.AddEventHandlers = function()
	{
		this.Debug("AddEventHandlers");
		this.ScriptEventHandler = new SfEventHandler("LiveIndicatorArea");
		this.ScriptEventHandler.MethodName = "OnScriptEvent";
		this.ScriptEventHandler.Container = this.Container;
		
		MainHelper.EventScript.AddHandler(this.ScriptEventHandler);
	}

	this.RemoveEventHandlers = function()
	{
		this.Debug("RemoveEventHandler");
		MainHelper.EventScript.RemoveHandler(this.ScriptEventHandler);
	}
	
	this.OnScriptEvent = function(args)
	{
		this.Debug("OnScriptEvent called");
		if (args.Command == SfScriptCommandType.EndPresentation)
		{
			this.GetImage().title = this.inactiveToolTip;
			this.GetImage().alt = this.inactiveToolTip;
			this.GetImage().src = this.inactiveSrc;
		}
	}

	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "LiveIndicatorArea: " + str);
	}
}

// ENDFILE LiveIndicatorArea.js --------------------------------------------------------------------------->

// BEGINFILE ApplicationVersionArea.js ------------------------------------------------------------------------->

ApplicationVersionArea.prototype = new AreaBase();
function ApplicationVersionArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	this.InitializeArea(container, containingWindow, ID);

	this.OnLoad = function()
	{
		this.Debug("OnLoad");
	}

	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad");
	}

	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "ApplicationVersionArea: " + str);
	}
}

// ENDFILE ApplicationVersionArea.js --------------------------------------------------------------------------->

// BEGINFILE SliderArea.js ----------------------------------------------------------------------------->
SliderArea.prototype = new AreaBase();
function SliderArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	this.InitializeArea(container, containingWindow, ID);
	
	this.Slider = null;
	
	this.mediaLengthObtainedEventHandler = null;
	this.playerTimerUpdatedEventHandler = null;
	this.SliderClickEventHandler = null;
	this.SliderDragEventHandler = null;
	
	this.IsCurrentlyDragging = false;
	
	this.Orientation = SfSliderOrientation.Vertical;// comes from code
	
	this.Debug = function(msg)
	{
		SfDebug.DPF(this.m_debugLevel, "SliderArea: " + msg);
	}
	
	this.OnLoad = function()
	{
		this.Debug("OnLoad()");
		this.Initialize();
	}
	
	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad()");
		this.Slider.OnUnLoad();
		this.RemoveEventHandlers();
	}
	
	this.Initialize = function()
	{
		this.Slider = new SfSlider(this.ID, this.Orientation);
		if (MainHelper.Presentation.Status != PresentationStatus.ReplayReady)
		{
			this.Slider.IsEnabled = false;
			return;
		}
		this.Slider.OnLoad();
		this.AddEventHandlers();
	}
	
	this.AddEventHandlers = function()
	{
		this.Debug("AddEventHandlers()");

		this.mediaLengthObtainedEventHandler = new SfEventHandler("SliderArea");
		this.mediaLengthObtainedEventHandler.MethodName = "OnMediaLengthObtained";
		this.mediaLengthObtainedEventHandler.Container = this.Container;
		MainHelper.EventPlayerMediaLengthObtained.AddHandler(this.mediaLengthObtainedEventHandler);

		this.playerTimerUpdatedEventHandler = new SfEventHandler("SliderArea");
		this.playerTimerUpdatedEventHandler.MethodName = "OnPlayerTimerUpdated";
		this.playerTimerUpdatedEventHandler.Container = this.Container;
		MainHelper.EventPlayerTimerUpdated.AddHandler(this.playerTimerUpdatedEventHandler);
		
		this.SliderClickEventHandler = new SfEventHandler("SliderArea");
		this.SliderClickEventHandler.MethodName = "OnSliderClick";
		this.SliderClickEventHandler.Container = this.Container;
		this.Slider.ClickEvent.AddHandler(this.SliderClickEventHandler);

		this.SliderDragEventHandler = new SfEventHandler("SliderArea");
		this.SliderDragEventHandler.MethodName = "OnSliderDrag";
		this.SliderDragEventHandler.Container = this.Container;
		this.Slider.DragEvent.AddHandler(this.SliderDragEventHandler);
	}
	
	this.RemoveEventHandlers = function()
	{
		this.Debug("RemoveEventHandlers()");
		MainHelper.EventPlayerMediaLengthObtained.RemoveHandler(this.mediaLengthObtainedEventHandler);
		MainHelper.EventPlayerTimerUpdated.RemoveHandler(this.playerTimerUpdatedEventHandler);
		if (this.Slider.IsEnabled == true)
		{
			this.Slider.ClickEvent.RemoveHandler(this.SliderClickEventHandler);
			this.Slider.DragEvent.RemoveHandler(this.SliderDragEventHandler);
		}
	}
	
	this.OnMediaLengthObtained = function(range)
	{
		this.Debug("OnMediaLengthObtained(): left: " + range.Left + ", right: " + range.Right);
		this.Slider.SetRange(range.Left, range.Right);
	}

	this.OnPlayerTimerUpdated = function(position)
	{
		this.Debug("OnPlayerTimerUpdated()");
		if (this.IsCurrentlyDragging == true)
		{
			return;
		}
		this.Slider.SetPosition(position);
	}
	
	this.OnSliderClick = function(args)
	{
		this.Debug("OnSliderClick(): " + args.Position);

		this.Slider.SetPosition(args.Position);		
		var sliderArgs = new SliderArgs(SfSliderNotifyType.NewPosition);
		sliderArgs.Position =  args.Position;
        MainHelper.EventSliderNotify.Post(sliderArgs);
	}
	
	this.OnSliderDrag = function(dragArgs)
	{
		this.Debug("OnSliderDrag(): , type: " +  dragArgs.DragEventType + ", position: " + dragArgs.Position);

		if (dragArgs.DragEventType == SfSliderDragEventType.DragMove)
		{
			this.Slider.SetPosition(dragArgs.Position);
			var sliderArgs = new SliderArgs(SfSliderNotifyType.DragPosition);
			sliderArgs.Position = dragArgs.Position;
			MainHelper.EventSliderNotify.Post(sliderArgs);
		}
		else if (dragArgs.DragEventType == SfSliderDragEventType.BeginDrag)
		{
			var sliderArgs = new SliderArgs(SfSliderNotifyType.BeginDrag);
			sliderArgs.Position = dragArgs.Position;
			MainHelper.EventSliderNotify.Post(sliderArgs);
			this.IsCurrentlyDragging = true;
		}
		else if (dragArgs.DragEventType == SfSliderDragEventType.EndDrag)
		{
			var newPositionArgs = new SliderArgs(SfSliderNotifyType.NewPosition);
			newPositionArgs.Position =  dragArgs.Position;
			MainHelper.EventSliderNotify.Post(newPositionArgs);

			var endDragArgs = new SliderArgs(SfSliderNotifyType.EndDrag);
			endDragArgs.Position = dragArgs.Position;
			MainHelper.EventSliderNotify.Post(endDragArgs);
			this.IsCurrentlyDragging = false;
		}
	}
}
// ENDFILE SliderArea.js ------------------------------------------------------------------------------->
// BEGINFILE TextSlideSorterArea.js -------------------------------------------------------------------->
TextSlideSorterArea.prototype = new AreaBase();
function TextSlideSorterArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	this.LastSelectedSlideNumber = -1;
	this.NumSlideElements = -1;
	
	this.InitializeArea(container, containingWindow, ID);

	this.OnLoad = function()
	{
		this.Debug("TextSlideSorterAreaOnLoad called");
		this.RegisterTextSlideSorterAreaEvents();
		this.SetSlideInitialStatuses();
		this.ScrollingDiv = SfDOM.FindElementFromID(document, this.ID + 'Inside');
	}
	
	this.RegisterTextSlideSorterAreaEvents = function()
	{
		this.SlideChangedEventHandler = new SfEventHandler(this.Container);
		this.SlideChangedEventHandler.Container = this.Container;
		this.SlideChangedEventHandler.MethodName = "OnSlideChangedEvent";
		MainHelper.EventSlideChanged.AddHandler(this.SlideChangedEventHandler);	
		
		this.PlayBeginEventHandler = new SfEventHandler(this.ID);
		this.PlayBeginEventHandler.MethodName = "OnPlayBeginEvent";
		this.PlayBeginEventHandler.Container = this.Container;

		MainHelper.EventPlayBegin.AddHandler(this.PlayBeginEventHandler);
	}

	this.OnUnLoad = function()
	{
		MainHelper.EventSlideChanged.RemoveHandler(this.SlideChangedEventHandler);
		MainHelper.EventPlayBegin.RemoveHandler(this.PlayBeginEventHandler);
	}
	
	this.OnPlayBeginEvent = function()
	{
		this.Debug("OnPlayBeginEvent");
		if (this.LastSelectedSlideNumber != -1)
		{
			// unselect the last selected slide
			this.UnHiliteSlide(this.LastSelectedSlideNumber);
			this.LastSelectedSlideNumber = -1;
		}
	}

	this.OnSlideChangedEvent = function(args)
	{
		this.Debug("OnSlideChangedEvent called");
		var index = args.Index;
		
		if (index < 1)
		{
			// resetting
			if (this.LastSelectedSlideNumber != -1)
			{
				// unselect the last selected slide
				this.UnHiliteSlide(this.LastSelectedSlideNumber);
				this.LastSelectedSlideNumber = -1;
			}
			return;
		}
		
		this.AddDynamicSlidesIfNeeded();
		
		this.SelectSlide(index);
		
	}
	
	this.AddDynamicSlidesIfNeeded = function()
	{
		this.Debug("AddNeededDynamicSlides called");
		
		var max = MainHelper.MaxSlideTimings;
		if (max == this.NumSlideElements)
		{
			return;
		}
		
		var startIndex = this.NumSlideElements + 1;
		var endIndex = max;
		for (var i=startIndex; i<=endIndex; ++i)
		{
			this.AddDynamicSlide(i);
		}
		this.NumSlideElements = endIndex;
	}
	
	this.SetSlideInitialStatuses = function()
	{
		this.Debug("SetSlideInitialStatuses called");
		this.NumSlideElements = MainHelper.MaxSlideTimings;
		
		if (MainHelper.Presentation.Status == PresentationStatus.CaptureInProgress)
		{
			this.MakeAllSlidesUnClickable();
		}
		else
		{
			this.MakeAllSlidesClickable();
		}
		
	}
	
	this.MakeAllSlidesClickable = function()
	{
		var max = MainHelper.MaxSlideTimings;
		for (var i=0; i<max; ++i)
		{
			this.MakeSlideClickable(i+1);
		}
	}

	this.MakeAllSlidesUnClickable = function()
	{
		var max = MainHelper.MaxSlideTimings;
		for (var i=0; i<max; ++i)
		{
			this.MakeSlideUnClickable(i+1);
		}
	}

	this.SelectSlide = function(slideNumber)
	{
		this.Debug("SelectSlide: " + slideNumber + " called");
		if (this.LastSelectedSlideNumber != -1)
		{
			// unselect the last selected slide
			this.UnHiliteSlide(this.LastSelectedSlideNumber);
		}

		this.HiliteSlide(slideNumber);
		this.LastSelectedSlideNumber = slideNumber;
		this.ScrollToSlide(slideNumber);
	}
	
	//!!
	this.ScrollToSlide = function(slideNumber)
	{
		this.Debug("ScrollToSlide: " + slideNumber);
		if (slideNumber < 0)
		{
			return;
		}

		if (this.ScrollingDiv.clientHeight >= this.ScrollingDiv.scrollHeight)
		{
			this.Debug("No Scrolling necessary");
			return;
		}
		
		var heightPerLine = Math.floor(this.ScrollingDiv.scrollHeight / MainHelper.MaxSlideTimings);
	
		var linesVisible = Math.floor(this.ScrollingDiv.clientHeight / heightPerLine);
		
		var middleLineNumber = Math.ceil(linesVisible / 2);

		this.Debug("HeightPerLine: " + heightPerLine +
			", linesVisible: " + linesVisible + 
			", middleLineNumber: " + middleLineNumber); 
		
		if (slideNumber <= middleLineNumber)
		{
			this.ScrollingDiv.scrollTop = 0;
			return;
		}
		
		this.ScrollingDiv.scrollTop = (slideNumber-middleLineNumber) * heightPerLine;
	}

	//!!
	this.AddDynamicSlide = function(slideNumber)
	{
		this.Debug("AddDynamicSlide " + slideNumber + " called");
		
		var divElem = document.createElement("div");
		divElem.setAttribute("id", "textSlideListDiv" + slideNumber);
		divElem.className = 'textSlideListItem';
		
		var slideNumberElement = document.createElement("span");
		slideNumberElement.appendChild(document.createTextNode(slideNumber));
		slideNumberElement.className = 'textSlideListNumber';
		divElem.appendChild(slideNumberElement);
		
		var titleElement = document.createElement("span");
		titleElement.setAttribute("id", "textSlideListTitle" + slideNumber);
		titleElement.className = 'textSlideListNormal';
		titleElement.appendChild(document.createTextNode("Slide " + slideNumber));
		divElem.appendChild(titleElement);
		
		var appendPoint = SfDOM.FindElementFromID(document, this.ID + "Inside");
		if (!appendPoint)
		{
			alert('appendPoint not found parent');
			return;
		}
		appendPoint.appendChild(divElem);
		if (MainHelper.Presentation.Status == PresentationStatus.ReplayReady)
		{
			this.MakeSlideClickable(slideNumber);
		}
	}
	
	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "TextSlideSorterArea: " + str);
	}

	// remember number is 1 indexed and not 0
	this.NavigateToSlide = function(slideNumber)
	{
		this.Debug("NavigateToSlide(slideNumber: " + slideNumber + ") called");
		var args = new CommandArgs(SfCommandType.NavigateToSlide);
		args.SlideNumber = slideNumber;
		MainHelper.EventCommand.Post(args);
	}

	this.HiliteSlide = function(slideNumber)
	{
		this.Debug("HiliteSlide called");
		var elem = this.FindDivElementForSlideNumber(slideNumber);
		elem.className = 'textSlideListItemCurrent';
	}
	
	this.UnHiliteSlide = function(slideNumber)
	{
		this.Debug("UnHiliteSlide called");
		var elem = this.FindDivElementForSlideNumber(slideNumber);
		elem.className = 'textSlideListItem';
	}
	
	this.MakeSlideClickable = function(slideNumber)
	{
		this.Debug("MakeSlideClickable called");
		var elem = this.FindTitleElementForSlideNumber(slideNumber);
		elem.onmouseover = new Function("", this.Container + ".OnSlideMouseOver(" + slideNumber + ");");
		elem.onmouseout = new Function("", this.Container + ".OnSlideMouseOut(" + slideNumber + ");");
		elem.onclick = new Function("", this.Container + ".NavigateToSlide(" + slideNumber + ");");
	}
	
	this.OnSlideMouseOver = function(slideNumber)
	{
		var elem = this.FindTitleElementForSlideNumber(slideNumber);
		elem.className = 'textSlideListOver';
		Util.SetCursor(elem, CursorType.Hand);
	}
		
	this.OnSlideMouseOut = function(slideNumber)
	{
		var elem = this.FindTitleElementForSlideNumber(slideNumber);
		elem.className = 'textSlideListNormal';
		Util.SetCursor(elem, CursorType.Normal);
	}

	this.MakeSlideUnClickable = function(slideNumber)
	{
		this.Debug("MakeSlideUnClickable called");
		var elem = this.FindTitleElementForSlideNumber(slideNumber);
		if (elem == null)
		{
			return;
		}
		elem.style.textDecoration='none';
		Util.SetCursor(elem, CursorType.Default);
		elem.onclick = '';
	}

	this.FindDivElementForSlideNumber = function(slideNumber)
	{
		var elem = SfDOM.FindElementFromID(document, "textSlideListDiv" + slideNumber);
		if (!elem)
		{
			this.Debug("Could not find element for slideNumber: " + slideNumber);
			return null;
		}
		return elem;
	}	

	this.FindTitleElementForSlideNumber = function(slideNumber)
	{
		var elem = SfDOM.FindElementFromID(document, "textSlideListTitle" + slideNumber);
		if (!elem)
		{
			this.Debug("Could not find element for slideNumber: " + slideNumber);
			return null;
		}
		return elem;
	}	
}

// ENDFILE TextSlideSorterArea.js ---------------------------------------------------------------------->

// BEGINFILE SlideNumberArea.js ------------------------------------------------------------------------>

SlideNumberArea.prototype = new AreaBase();
function SlideNumberArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	// injected variables
	this.SlideText = null;
	this.OfText = null;
	
	this.InitializeArea(container, containingWindow, ID);

	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "SlideNumberArea: " + str);
	}

	this.OnLoad = function()
	{
		this.Debug("OnLoad");
		this.AddEventHandlers();
	}

	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad()");
		this.RemoveEventHandlers();
	}

	this.SetText = function(val)
	{
		this.Debug("Setting text: " + val);
		var textNode = document.createTextNode(val);

		var div = this.GetDiv();
		var firstChild = div.childNodes[0];
		if (firstChild)
		{
			div.replaceChild(textNode, firstChild);
		}
		else
		{
			div.appendChild(textNode);
		}

	}
	
	this.AddEventHandlers = function()
	{
		this.Debug("AddEventHandlers()");
		this.SlideChangedEventHandler = new SfEventHandler(this.Container);
		this.SlideChangedEventHandler.Container = this.Container;
		this.SlideChangedEventHandler.MethodName = "OnSlideChangedEvent";
		MainHelper.EventSlideChanged.AddHandler(this.SlideChangedEventHandler);	

		this.ScriptEventHandler = new SfEventHandler(this.Container);
		this.ScriptEventHandler.Container = this.Container;
		this.ScriptEventHandler.MethodName = "OnScriptEvent";
		MainHelper.EventScript.AddHandler(this.ScriptEventHandler);

		this.PlayBeginEventHandler = new SfEventHandler(this.ID);
		this.PlayBeginEventHandler.MethodName = "OnPlayBeginEvent";
		this.PlayBeginEventHandler.Container = this.Container;
		MainHelper.EventPlayBegin.AddHandler(this.PlayBeginEventHandler);
	}

	this.RemoveEventHandlers = function()
	{
		this.Debug("RemoveEventHandlers()");
		MainHelper.EventSlideChanged.RemoveHandler(this.SlideChangedEventHandler);
		MainHelper.EventScript.RemoveHandler(this.ScriptEventHandler);
		MainHelper.EventPlayBegin.RemoveHandler(this.PlayBeginEventHandler);
	}

	this.OnSlideChangedEvent = function(args)
	{
		this.Debug("OnSlideChangedEvent: " + args.Index);
		var index = args.Index;
		if (index < 1)
		{
			this.Debug("Resetting");
			this.SetText("");
			return;
		}

		this.SetText(this.SlideText + " " + index + " " + this.OfText + " " + MainHelper.MaxSlideTimings);
	}

	this.OnScriptEvent = function(args)
	{
		this.Debug("OnScriptEvent()");
		switch(args.Command)
		{
			case SfScriptCommandType.EndPresentation:
				this.SetText("");
				break;
		}
	}
	
	this.OnPlayBeginEvent = function()
	{
		this.Debug("OnPlayBeginEvent()");
		var currentSlideNumber = MainHelper.CurrentSlideNumber;
		this.Debug("CurrentSlideNumber: " + currentSlideNumber);
		if (currentSlideNumber == -1)
		{
			this.SetText("");
		}
	}
}

// ENDFILE SlideNumberArea.js -------------------------------------------------------------------------->

// BEGINFILE ExtraInfoArea.js ------------------------------------------------------------------------>
ExtraInfoArea.prototype = new AreaBase();
function ExtraInfoArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;

	this.InitializeArea(container, containingWindow, ID);

	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "ExtraInfoArea: " + str);
	}

	this.OnLoad = function()
	{
		this.Debug("OnLoad");
		if (this.Enabled == false)
		{
			this.Hide();
			return;
		}
		this.AddEventHandlers();
	}

	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad()");
		this.RemoveEventHandlers();
	}

	this.AddEventHandlers = function()
	{
		this.Debug("AddEventHandlers()");
	}

	this.RemoveEventHandlers = function()
	{
		this.Debug("RemoveEventHandlers()");
	}

}
// ENDFILE ExtraInfoArea.js -------------------------------------------------------------------------->
// BEGINFILE SlideDescriptionArea.js -------------------------------------------------------------------->
SlideDescriptionArea.prototype = new AreaBase();
function SlideDescriptionArea(container, containingWindow, ID)
{
 	var m_debugLevel = SfDebug.Verbose;
//	var m_debugLevel = SfDebug.Information;

	this.InitializeArea(container, containingWindow, ID);

	var m_this = this;
	var m_element = null;
	var m_scriptEventHandler = null;
	
	this.Debug = function(msg)
	{
		SfDebug.DPF(m_debugLevel, "SlideDescriptionArea: " + msg);
	}

	this.OnLoad = function()
	{
		m_element = SfDOM.FindElementFromID(document, this.ID + "SlideDescription");

		m_scriptEventHandler = new SfEventHandler(this.Container);
		m_scriptEventHandler.Container = this.Container;
		m_scriptEventHandler.MethodName = "OnScriptEvent";
		MainHelper.EventScript.AddHandler(m_scriptEventHandler);
	}
	
	this.OnUnLoad = function()
	{
		MainHelper.EventScript.RemoveHandler(m_scriptEventHandler);
	}
	
	this.OnScriptEvent = function(args)
	{
		this.Debug("OnScriptEvent: " + args.Command);
		switch(args.Command)
		{
			case SfScriptCommandType.ShowSlide:
				this.OnShowSlide(args.Index);
				break;
		}
	}

	this.OnShowSlide = function(slideNumber)
	{
		this.Debug("OnShowSlide(): " + slideNumber);
		var text; 
		if (slideNumber > this.SlideDescriptions.length)
		{
			text = "Slide Number: " + slideNumber;
		}
		else
		{
			text = this.SlideDescriptions[slideNumber-1];
		}
		SfDOM.SetText(m_element, text);		
	}

}
// ENDFILE SlideDescriptionArea.js ---------------------------------------------------------------------->
// BEGINFILE ChapterPointsArea.js -------------------------------------------------------------------->
ChapterPointsArea.prototype = new AreaBase();
function ChapterPointsArea(container, containingWindow, ID)
{
	var m_debugLevel = SfDebug.Verbose;
//	var m_debugLevel = SfDebug.Information;

	this.InitializeArea(container, containingWindow, ID);

	var m_this = this;

	this.Debug = function(msg)
	{
		SfDebug.DPF(m_debugLevel, "ChapterPointsArea: " + msg);
	}
	
	this.RegisterEvents = function()
	{
		this.Debug("RegisterEvents()");
	}

	this.OnLoad = function()
	{
		this.Debug("OnLoad()");
		this.SetInitialStatuses();
	}
	
	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad()");
	}
	
	this.SetInitialStatuses = function()
	{
		this.Debug("SetInitialStatuses()");

		if (MainHelper.Presentation.Status == PresentationStatus.CaptureInProgress)
		{
			this.MakeAllChaptersUnClickable();
		}
		else
		{
			this.MakeAllChaptersClickable();
		}
		
	}
	
	this.MakeAllChaptersClickable = function()
	{
		this.Debug("MakeAllChaptersClickable()");
		for (var i=0; i<this.Timings.length; ++i)
		{
			this.MakeChapterClickable(i+1);
		}
	}
	
	this.MakeAllChaptersUnClickable = function()
	{
		this.Debug("MakeAllChaptersUnClickable()");
		for (var i=0; i<this.Timings.length; ++i)
		{
			this.MakeChapterUnClickable(i+1);
		}
	}

	// remember number is 1 indexed and not 0
	this.NavigateToChapter = function(chapterNumber)
	{
		this.Debug("NavigateToChaper(): " + chapterNumber);

		var args = new CommandArgs(SfCommandType.NavigateToChapter);
		args.Number = chapterNumber;
		args.Time = this.Timings[chapterNumber-1];
		MainHelper.EventCommand.Post(args);
	}

	this.MakeChapterClickable = function(chapterNumber)
	{
		this.Debug("MakeChapterClickable(): " + chapterNumber);
		var elem = this.FindTitleElementForChapter(chapterNumber);

		elem.onclick = new Function("", this.Container + ".NavigateToChapter(" + chapterNumber + ");");
		elem.onmouseover = new Function("", this.Container + ".OnMouseOver(" + chapterNumber + ");");
		elem.onmouseout = new Function("", this.Container + ".OnMouseOut(" + chapterNumber + ");");
	}
	
	this.OnMouseOver = function(chapterNumber)
	{
		this.Debug("OnMouseOver(): " + chapterNumber);
					
		var elem = this.FindTitleElementForChapter(chapterNumber);
		elem.className = 'chapterOver';
	}

	this.OnMouseOut = function(chapterNumber)
	{
		this.Debug("OnMouseOut(): " + chapterNumber);
					
		var elem = this.FindTitleElementForChapter(chapterNumber);
		elem.className = 'chapterNormal';
	}

	this.MakeChapterUnClickable = function(chapterNumber)
	{
		this.Debug("MakeChapterUnClickable(): " + chapterNumber);
		var elem = this.FindTitleElementForChapter(chapterNumber);
		
		elem.onclick = new Function("", "");
	}

	this.FindDivElementForChapter = function(chapterNumber)
	{
		this.Debug("FindDivElementForChapter(): " + chapterNumber);
		var elem = SfDOM.FindElementFromID(document, "chapterDiv" + chapterNumber);
		if (!elem)
		{
			this.Debug("Could not find element for chapter: " + chapterNumber);
			return null;
		}
		return elem;
	}	

	this.FindTitleElementForChapter = function(chapterNumber)
	{
		this.Debug("FindTitleElementForChapter(): " + chapterNumber);
		var elem = SfDOM.FindElementFromID(document, "chapterTitleSpan" + chapterNumber);
		if (!elem)
		{
			this.Debug("Could not find element for chapter: " + chapterNumber);
			return null;
		}
		return elem;
	}	
}

// ENDFILE ChapterPointsArea.js ---------------------------------------------------------------------->
// BEGINFILE OptionsArea.js ---------------------------------------------------------------------->
OptionsArea.Inherits(AreaBase);
function OptionsArea(container, containingWindow, ID)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;
	
	this.InitializeArea(container, containingWindow, ID);

	this.Debug = function(msg)
	{
		SfDebug.DPF(this.m_debugLevel, "OptionsArea: " + msg);
	}

	this.OnLoad = function()
	{
		var div = SfDOM.FindElementFromID(document, 'optionsAreaDiv');
		div.appendChild(this.CreateMenu());
		this.OptionsChangeFromAreasEventHandler = new SfEventHandler(this.Container);
		this.OptionsChangeFromAreasEventHandler.MethodName = "OnOptionsChangeFromAreas";
		this.OptionsChangeFromAreasEventHandler.Container = this.Container;
		MainHelper.EventOptionsChangeFromAreas.AddHandler(this.OptionsChangeFromAreasEventHandler);
		
	}

	this.OnUnLoad = function()
	{
		MainHelper.EventOptionsChangeFromAreas.RemoveHandler(this.OptionsChangeFromAreasEventHandler);
	}
	
	this.OnOptionsChangeFromAreas = function(args)
	{
		this.Debug("OnOptionsChangeFromAreas()");
		if (args.OptionType == OptionType.ThumbNailsPerPage)
		{
			this.SelectSlidesPerPageLeaf(args.Val);
		}
		else if (args.OptionType == OptionType.ShowEvery)
		{
			this.SelectShowEveryLeaf(args.Val);
		}
	}
	
	this.CreateMenu = function()
	{
		this.BaseMenuItem = new BaseMenuItem(this.Container + ".BaseMenuItem", this.OptionsText, this.Template);
		this.AddSubMenus();
		
		this.BaseMenuItem.CollapseChildrenNow();
		
		return this.BaseMenuItem.RootDiv;
	}
	
	this.AddSubMenus = function()
	{
		this.AddSlidesPerPageSubMenu();
		this.AddShowEverySubMenu();
		this.AddChangeViewSubMenu();
	}
	
	this.SelectSlidesPerPageLeaf = function(numSlidesPerPage)
	{
		var elem;
		switch(numSlidesPerPage)
		{
			case 5:
				elem = this.BaseMenuItem.GetChildItem(0).GetChildItem(0);
				break;
			case 10:
				elem = this.BaseMenuItem.GetChildItem(0).GetChildItem(1);
				break;
			case 15:
				elem = this.BaseMenuItem.GetChildItem(0).GetChildItem(2);
				break;
			case 20:
				elem = this.BaseMenuItem.GetChildItem(0).GetChildItem(3);
				break;
		}
		if (elem)
		{
			elem.Group.Select(elem);
		}
	}
	
	this.SelectShowEveryLeaf = function(showEvery)
	{
		var elem;
		switch(showEvery)
		{
			case 1:
				elem = this.BaseMenuItem.GetChildItem(1).GetChildItem(0);
				break;
			case 2:
				elem = this.BaseMenuItem.GetChildItem(1).GetChildItem(1);
				break;
			case 5:
				elem = this.BaseMenuItem.GetChildItem(1).GetChildItem(2);
				break;
			case 10:
				elem = this.BaseMenuItem.GetChildItem(1).GetChildItem(3);
				break;
			case 15:
				elem = this.BaseMenuItem.GetChildItem(1).GetChildItem(4);
				break;
			case 20:
				elem = this.BaseMenuItem.GetChildItem(1).GetChildItem(5);
				break;
		}
		if (elem)
		{
			elem.Group.Select(elem);
		}
	}

	this.AddSlidesPerPageSubMenu = function()
	{
		var slidesPerPageElement = this.BaseMenuItem.AddSubMenu(this.ThumbNailsPerPageText, 75, 20);
		var leafGroup = new LeafGroup();
		var leaf1 = slidesPerPageElement.AddLeaf("5", this.GetSetSlidesPerPageFunction(5));
		leafGroup.Add(leaf1);
		var leaf2 = slidesPerPageElement.AddLeaf("10", this.GetSetSlidesPerPageFunction(10));
		leafGroup.Add(leaf2);
		var leaf3 = slidesPerPageElement.AddLeaf("15", this.GetSetSlidesPerPageFunction(15));
		leafGroup.Add(leaf3);
		var leaf4 = slidesPerPageElement.AddLeaf("20", this.GetSetSlidesPerPageFunction(20));
		leafGroup.Add(leaf4);
		
		this.SelectSlidesPerPageLeaf(this.GetInitialNumSlidesPerPage());
	}
	
	this.AddShowEverySubMenu = function()
	{
		var showEveryElement = this.BaseMenuItem.AddSubMenu(this.ShowEveryText, 100, 20);
		var leafGroup = new LeafGroup();
		var slideText = this.SlideText;
		var slidesText = this.SlidesText;
		var leaf1 = showEveryElement.AddLeaf("1 " + slideText, this.GetSetShowEveryFunction(1));
		leafGroup.Add(leaf1);
		var leaf2 = showEveryElement.AddLeaf("2 " + slidesText, this.GetSetShowEveryFunction(2));
		leafGroup.Add(leaf2);
		var leaf3 = showEveryElement.AddLeaf("5 " + slidesText, this.GetSetShowEveryFunction(5));
		leafGroup.Add(leaf3);
		var leaf4 = showEveryElement.AddLeaf("10 " + slidesText, this.GetSetShowEveryFunction(10));
		leafGroup.Add(leaf4);
		var leaf5 = showEveryElement.AddLeaf("15 " + slidesText, this.GetSetShowEveryFunction(15));
		leafGroup.Add(leaf5);
		var leaf6 = showEveryElement.AddLeaf("20 " + slidesText, this.GetSetShowEveryFunction(20));
		leafGroup.Add(leaf6);
		
		this.SelectShowEveryLeaf(this.GetInitialShowEvery());
	}
	
	this.AddChangeViewSubMenu = function()
	{
		var subMenu = this.BaseMenuItem.AddSubMenu(this.ChangeViewText, 120, 20);
		var leaf1 = subMenu.AddLeaf(this.CurrentSlideText, this.GetChangeViewFunction(true));
		var leaf2 = subMenu.AddLeaf(this.NavigateText, this.GetChangeViewFunction(false));

		var leafGroup = new LeafGroup();
		leafGroup.Add(leaf1);
		leafGroup.Add(leaf2);
		
		var shouldChangeView = this.GetInitialChangeView();
		this.SelectChangeViewLeaf(shouldChangeView);
		MainHelper.ShouldChangeView = shouldChangeView;
	}
	
	this.SelectChangeViewLeaf = function(shouldChange)
	{
		var elem;
		if (shouldChange == true)
		{
			elem = this.BaseMenuItem.GetChildItem(2).GetChildItem(0);
		}
		else
		{
			elem = this.BaseMenuItem.GetChildItem(2).GetChildItem(1);
		}

		if (elem)
		{
			elem.Group.Select(elem);
		}
	}
	
	this.GetSetSlidesPerPageFunction = function(numSlidesPerPage)
	{
		return new Function("", this.Container + ".FireUpdateSlidesPerPage(" + numSlidesPerPage + ");");
	}
	
	this.GetSetShowEveryFunction = function(showEvery)
	{
		return new Function("", this.Container + ".FireUpdateShowEvery(" + showEvery + ");");
	}
	
	this.GetChangeViewFunction = function(shouldChange)
	{
		return new Function("", this.Container + ".SetShouldChangeView(" + shouldChange + ");");
	}

	this.FireUpdateSlidesPerPage = function(numSlidesPerPage)
	{
		var args = new Object();
		args.OptionType = OptionType.ThumbNailsPerPage;
		args.Val = numSlidesPerPage;
		MainHelper.EventOptionsChangeToAreas.Post(args);
	}
	
	this.FireUpdateShowEvery = function(showEvery)
	{
		var args = new Object();
		args.OptionType = OptionType.ShowEvery;
		args.Val = showEvery;
		MainHelper.EventOptionsChangeToAreas.Post(args);
	}
	
	this.SetShouldChangeView = function(shouldChange)
	{
		this.SelectChangeViewLeaf(shouldChange);
		
		var cookie = new SfCookie("ChangeView");
		
		cookie.SetBool(shouldChange);
		cookie.Persist();
		
		MainHelper.ShouldChangeView = shouldChange;
	}

	this.GetInitialNumSlidesPerPage = function()
	{
		var cookie = new SfCookie("NumSlidesPerPage");
		var value = cookie.Get();
		if (value == null)
		{
			return 5;
		}
		else
		{
			return Number(value);
		}
	}

	this.GetInitialShowEvery = function()
	{
		this.Debug("InitializeShowEvery()");
		var cookie = new SfCookie("ShowEvery");
		var value = cookie.Get();
		if (value == null)
		{
			return 1;
		}
		else
		{
			return Number(value);
		}
	}
	
	this.GetInitialChangeView = function()
	{
		this.Debug("GetInitialChangeView()");
		var cookie = new SfCookie("ChangeView");
		var value = cookie.Get();
		if (value == null)
		{
			return true;
		}
		if (value == "true")
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}
// ENDFILE OptionsArea.js ---------------------------------------------------------------------->