// 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.ShowDescriptionForAltText = false;

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

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

	function CurrentSlideArea.prototype.RegisterCurrentSlideEvents()
	{
		this.Debug("RegisterCurrentSlideEvents called");
		
		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);
	}

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

		this.LoadDefaultImage();

		this.GetSlideImage().title = '';

		var imageDiv = this.GetDiv();
		imageDiv.onclick = null;
		imageDiv.style.cursor = "default";

		var magnifyDiv = SfDOM.FindElementFromID(document, "magnifyDiv");
		magnifyDiv.style.visibility  = 'hidden';
		
		this.m_clickInitialized = false;
	}
	
	function CurrentSlideArea.prototype.OnScriptEvent(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;
		}
	}

	function CurrentSlideArea.prototype.CurrentSlideOnCommandEvent(args)
	{
		this.Debug("CurrentSlideOnCommandEvent: " + args);
		switch(args.Command)
		{
			case SfCommandType.ShowSlideShow:
				this.Show();
				MainHelper.Presentation.WhatIsShowing = WhatIsShowing.SlideShow;
				break;
			case SfCommandType.ShowSlideList:
				this.Hide();
				break;
		}
	}
	
	function CurrentSlideArea.prototype.CurrentSlideOnDataAvailableEvent(args)
	{
		this.Debug("CurrentSlideOnDataAvailableEvent");
		this.SetCurrentCaptureImage();
	}

	// the following three vars are emitted
	// this.DefaultReplayImage
	// this.NotStartedImage
	// this.EndedImage
	function CurrentSlideArea.prototype.LoadDefaultImage()
	{
		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.Offline:
				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;
			case PresentationStatus.Test:
				this.SetSlideImage(this.NotStartedImage);
				break;
			default:
				SfDebug.DPF(SfDebug.ErrMsgCritical, "CurrentSlideAreaOnLoad: PresentationStatus not known");
				this.SetSlideImage(this.NotStartedImage);
				break;
		}
	}

	function CurrentSlideArea.prototype.SetSlideImage(imageSrc)
	{
		var slideImage = this.GetSlideImage();
		slideImage.src = imageSrc;
		slideImage.style.display = "";
	}
	
	function CurrentSlideArea.prototype.SetCurrentCaptureImage()
	{
		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		
		var slideTiming = slideTimings[max-1];
		if (slideTiming && slideTiming.Normal && slideTiming.FullSize && slideTiming.ThumbNail)
		{
			this.CurrentImage = MainHelper.Presentation.ImageBaseURL + "/" + slideTiming.Normal.Image;
			MainHelper.CurrentFullSizeImage = MainHelper.Presentation.ImageBaseURL + "/" + slideTiming.FullSize.Image;
			this.CurrentThumbNailImage = MainHelper.Presentation.ImageBaseURL + "/" + slideTiming.ThumbNail.Image;
			MainHelper.CurrentSlideNumber = max;
			this.SetSlideImage(this.CurrentImage);
			this.InitializeClick();
		}
		else
		{
			SfDebug.DPF(SfDebug.ErrMsgCritical, "CurrentSlideArea.SetCurrentCaptureImage, slidetimings are not right");
		}
	}
	
	// makes the slide clickable
	// we don't do it until OnShowSlide has happened
	this.m_clickInitialized = false;
	function CurrentSlideArea.prototype.InitializeClick()
	{
		this.Debug("CurrentSlide InitializeClick called");
		if (this.m_clickInitialized)
		{
			return;
		}
		
		var imageDiv = this.GetDiv();
		imageDiv.onclick = new Function("", "CurrentSlideAreaInstance.OpenFullSizeWindow();");
		this.GetSlideImage().title = 'Show Full Size Slide Show';
		imageDiv.style.cursor = 'hand';

		var magnifyDiv = SfDOM.FindElementFromID(document, "magnifyDiv");
		magnifyDiv.style.visibility  = 'visible';

		this.m_clickInitialized = true;
	}
	
	function CurrentSlideArea.prototype.OnShowSlide(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 = MainHelper.Presentation.ImageBaseURL + "/" + args.Image;
		MainHelper.CurrentFullSizeImage = MainHelper.Presentation.ImageBaseURL + "/" + args.FullSizeImage;
		this.CurrentThumbNailImage = MainHelper.Presentation.ImageBaseURL + "/" + args.ThumbNailImage;
		var currentSlideNumber = args.Index;
		MainHelper.CurrentSlideNumber = currentSlideNumber;

		var imageElement = this.GetSlideImage();
		imageElement.src = this.CurrentImage;

		if (this.LoadAltText == true && MainHelper.Presentation.IsStandAlone == false)
		{
			this.CallIFrameToLoadAltText(currentSlideNumber);
		}
		else
		{
			imageElement.alt = "";
		}
		
		if (this.ShowSlideEffect == true)
		{
			this.Slide();
		}
		
		// now try to load one image ahead
		var nextImage = MainHelper.GetNormalImageName(MainHelper.CurrentSlideNumber + 1);
		this.Debug("Putting " + nextImage + " in cache");
		this.m_imageCache.AddImage(nextImage, true);
		
		this.UpdateFullSizeWindow(this.CurrentImage);
		
		if (!this.m_clickInitialized)
		{
			this.InitializeClick();
		}
		
	}
	
	function CurrentSlideArea.prototype.SetAltText(text)
	{
		this.Debug("Setting alt text: " + text);
		
		var imageElement = this.GetSlideImage();
		if (!imageElement)
		{
			this.Debug("could not get imageElement");
			return;
		}

		if (this.ShowNoImage == true)
		{
			imageElement.src = "";
		}
		imageElement.alt = text;
		
	}
	
	function CurrentSlideArea.prototype.CallIFrameToLoadAltText(slideNumber)
	{
		this.Debug("CallIFrameToLoadAltText called: slideNumber: " + slideNumber);
		
		var frame = window.frames["AltTextLoader"];
		if (!frame)
		{
			this.Debug("Frame not found");
			return;
		}
		
		var href = "AltText/AltTextLoader.aspx?imageBaseURL=" + MainHelper.Presentation.ImageBaseURL + 
			"&showDescription=" + this.ShowDescriptionForAltText + 
			"&slideNumber=" + slideNumber;
		this.Debug("Calling href: " + href);
		
		frame.location.href = href;
	}

	function CurrentSlideArea.prototype.GetSlideImage()
	{
		var slideImage = SfDOM.FindElementFromID(document, this.SLIDE_IMAGE_ID);
		return slideImage;
	}

	function CurrentSlideArea.prototype.Debug(str)
	{
		SfDebug.DPF(this.m_debugLevel, "CurrentSlideArea: " + str);
	}
	
	// If FullSizeArea is not open then opens it
	function CurrentSlideArea.prototype.OpenFullSizeWindow()
	{
		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);
	}

	function CurrentSlideArea.prototype.UpdateFullSizeWindow()
	{
		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);
		}
	}
	
	function CurrentSlideArea.prototype.OnEndPresentation(args)
	{
		this.Debug("OnEndPresentation called");
		this.GetSlideImage().src = this.EndedImage;

		this.GetSlideImage().title = '';

		var imageDiv = this.GetDiv();
		imageDiv.onclick = null;
		imageDiv.style.cursor = "default";

		var magnifyDiv = SfDOM.FindElementFromID(document, "magnifyDiv");
		magnifyDiv.style.visibility  = 'hidden';
		
		this.m_clickInitialized = false;
	}

	this.AnimFinished = true;
	this.CancelAnim = false;
	function CurrentSlideArea.prototype.Slide()
	{
		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);
	}
	
	function CurrentSlideArea.prototype.SlideOneStep()
	{
		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 --------------------------------------------------------------------->

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

	this.InitializeArea(container, containingWindow, ID);

	function PresentationCardArea.prototype.OnLoad()
	{
		this.Debug("PresentationCardAreaOnLoad called");
		this.RegisterPresentationCardEvents();
	}

	function PresentationCardArea.prototype.OnUnLoad()
	{
		this.Debug("OnUnLoad called");
		if (MainHelper && MainHelper.EventCommand)
		{
			MainHelper.EventCommand.RemoveHandler(this.CommandEventHandler);
		}
	}

	function PresentationCardArea.prototype.RegisterPresentationCardEvents()
	{
		this.CommandEventHandler = new SfEventHandler(this.Container);
		this.CommandEventHandler.Container = "PresentationCardAreaInstance";
		this.CommandEventHandler.MethodName = "PresentationCardOnCommandEvent";
		
		MainHelper.EventCommand.AddHandler(this.CommandEventHandler);
		
	}

	function PresentationCardArea.prototype.PresentationCardOnCommandEvent(args)
	{
		this.Debug("PresentationCardOnCommandEvent: " + args);
		switch(args.Command)
		{
			case SfCommandType.ShowInfo:
				this.Show();
				break;
			case SfCommandType.ShowTextSlideList:
				this.Hide();
				break;
		}
	}

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

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

// BEGINFILE SlideLabelArea.js ------------------------------------------------------------------------->

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

	this.InitializeArea(container, containingWindow, ID);

	function SlideLabelArea.prototype.OnLoad()
	{
		this.RegisterSlideLabelEvents();
	}

	function SlideLabelArea.prototype.OnUnLoad()
	{
		this.Debug("OnUnLoad called");
		if (MainHelper && MainHelper.EventCommand)
		{
			MainHelper.EventCommand.RemoveHandler(this.CommandEventHandler);
		}
	}

	function SlideLabelArea.prototype.RegisterSlideLabelEvents()
	{
		this.CommandEventHandler = new SfEventHandler(this.Container);
		this.CommandEventHandler.Container = this.Container;
		this.CommandEventHandler.MethodName = "SlideLabelOnCommandEvent";
		
		MainHelper.EventCommand.AddHandler(this.CommandEventHandler);
	}

	function SlideLabelArea.prototype.SlideLabelOnCommandEvent(args)
	{
		this.Debug("SlideLabelOnCommandEvent: " + args);
		switch(args.Command)
		{
			case SfCommandType.ShowSlideShow:
				this.Show();
				MainHelper.Presentation.WhatIsShowing = WhatIsShowing.SlideShow;
				break;
			case SfCommandType.ShowSlideList:
				this.Hide();
				break;
		}
	}
	
	function SlideLabelArea.prototype.Debug(str)
	{
		SfDebug.DPF(this.m_debugLevel, "SlideLabelArea: " + str);
	}
}

// ENDFILE SlideLabelArea.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.IsEnabled = true;
	this.ThumbWidth = -1;
	this.RangeLeft = -1;
	this.RangeRight = -1;
	this.PhysicalLeft = -1;
	this.PhysicalRight = -1;
	
	function SliderArea.prototype.Debug(msg)
	{
		SfDebug.DPF(this.m_debugLevel, "Slider: " + msg);
	}
	
	function SliderArea.prototype.OnLoad()
	{
		this.Debug("OnLoad");
		this.Initialize();
		this.AddEventHandlers();
	}
	
	function SliderArea.prototype.AddEventHandlers()
	{
		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);
	}
	
	function SliderArea.prototype.RemoveEventHandlers()
	{
		this.Debug("RemoveEventHandlers");
		MainHelper.EventPlayerMediaLengthObtained.RemoveHandler(this.MediaLengthObtainedEventHandler);
		MainHelper.EventPlayerTimerUpdated.RemoveHandler(this.PlayerTimerUpdatedEventHandler);
	}
	
	function SliderArea.prototype.OnPlayerTimerUpdated(position)
	{
		this.SetPosition(position);
	}
	
	function SliderArea.prototype.OnMediaLengthObtained(range)
	{
		this.Debug("OnMediaLengthObtained called: left: " + range.Left + ", right: " + range.Right);
		this.SetRange(range.Left, range.Right);
	}
	
	function SliderArea.prototype.OnUnLoad()
	{
		this.Debug("OnUnLoad");
		this.RemoveEventHandlers();
	}
	
	function SliderArea.prototype.Initialize()
	{
		this.Debug("Initialize called");
		
		
		this.ElementThumb = SfDOM.FindElementFromID(document, this.ID + "_thumb");
		this.ElementGuide =  SfDOM.FindElementFromID(document, this.ID + "_positionGuide");
		
		this.ThumbWidth = this.ElementThumb.offsetWidth;
		this.PhysicalLeft = this.GetPhysicalLeft();
		this.PhysicalRight = this.PhysicalLeft + this.ElementGuide.offsetWidth;
		this.Debug("PhysicalLeft: " + this.PhysicalLeft);
		this.Debug("PhysicalRight: " + this.PhysicalRight);

		if (MainHelper.Presentation.Status == PresentationStatus.ReplayReady)
		{
			this.ElementThumb.onmousedown = new Function("", this.Container + ".BeginDrag();");
			this.ElementGuide.onclick = new Function("", this.Container + ".GuideOnClick();");
		}
	}
	
	function SliderArea.prototype.GetPhysicalLeft()
	{
		var physicalLeft = this.ElementGuide.offsetLeft;
		var par = this.ElementGuide.offsetParent;
		while (par)
		{
			this.Debug("parentOffset: " + par.offsetLeft);
			physicalLeft += par.offsetLeft;
			par = par.offsetParent;
		}
		return physicalLeft;
	}
	
	function SliderArea.prototype.SetRange(left,right)
	{
		this.RangeLeft=left;
		this.RangeRight=right;
	}
	
	
	function SliderArea.prototype.LogToPhys(LogicalX)
	{
		var PhysX,LogicalWidth,PhysWidth;
		
		LogicalWidth = this.RangeRight-this.RangeLeft;
		PhysWidth = this.PhysicalRight-this.PhysicalLeft;
		
		if (LogicalWidth==0)
		{
			PhysX=0;
		}
		else
		{
			
			PhysX = (PhysWidth) * LogicalX;
			PhysX = PhysX/(LogicalWidth);
		}
		
		PhysX += this.PhysicalLeft;
		
		return PhysX;
	}
	
	function SliderArea.prototype.PhysToLog(PhysX)
	{
		var LogX,LogicalWidth,PhysWidth;
		
		LogicalWidth = this.RangeRight-this.RangeLeft;
		PhysWidth = this.PhysicalRight-this.PhysicalLeft;
		
		if (LogicalWidth==0 || PhysWidth==0)
		{
			LogX=0;
		}
		else if (PhysX < this.PhysicalLeft)
		{
			LogX = 0;
		}
		else if (PhysX > this.PhysicalRight)
		{
			LogX = LogicalWidth;
		}
		else
		{
		    PhysX -= this.PhysicalLeft;
			LogX = (LogicalWidth) * PhysX;
			LogX = LogX/(PhysWidth);
		}
		
		return LogX;
	}
	
	function SliderArea.prototype.SetPhysicalPosition(x)
	{
	    if (x<this.PhysicalLeft)
	    {
			x=this.PhysicalLeft;
		}
	    if (x>this.PhysicalRight)
	    {
			x=this.PhysicalRight;
		}
		
		this.ElementThumb.style.left = x - this.PhysicalLeft - this.ThumbWidth/2;
	}
	
	function SliderArea.prototype.SetPosition(x)
	{
		if (MainHelper.UserIsSliding)
		{
			return;
		}
			
		if (x < this.RangeLeft)
		{
			x = this.RangeLeft;
		}
		if (x > this.RangeRight)
		{
			x = this.RangeRight;
		}
		
		this.SetPhysicalPosition(this.LogToPhys(x));
	}
	
	function SliderArea.prototype.GuideOnClick(Event)
	{
		Event = SfBrowserEvent.GetEvent(Event);
		this.Debug("Guide OnClick x " + Event.clientX + " y " + Event.clientY);
		
		var Args=new SliderArgs(SfSliderNotifyType.NewPosition);
			
		Args.Position=this.PhysToLog(Event.clientX);

		this.Debug("Notify Guide Click Position:" + Args.Position);
        MainHelper.EventSliderNotify.Post(Args);
	}
	
	function SliderArea.prototype.BeginDrag(Event)
	{
	    if (!this.IsEnabled)
	    {
	        return;
	    }
	
		var SaveThis = this;
		
		MainHelper.UserIsSliding = true;
		
		this.Debug("BeginDrag Called");
		
		Event = SfBrowserEvent.GetEvent(Event);
		
		SfBrowserEvent.Attach("mousemove", OnMove);
		SfBrowserEvent.Attach("mouseup", OnUp);
		SfBrowserEvent.StopPropagation(Event);
		SfBrowserEvent.PreventDefault(Event);
		
		function OnMove(Event)
		{
			SaveThis.Debug("OnMove: Event.clientX " + Event.clientX);
			Event = SfBrowserEvent.GetEvent(Event);

			SfBrowserEvent.StopPropagation(Event);
			SfBrowserEvent.PreventDefault(Event);
			
			if (Event.clientX < SaveThis.PhysicalLeft || Event.clientX > SaveThis.PhysicalRight)
			{
				return;
			}

			SaveThis.SetPhysicalPosition(Event.clientX);
			
			var Args=new SliderArgs(SfSliderNotifyType.DragPosition);
			
			Args.Position=SaveThis.PhysToLog(Event.clientX);

			SaveThis.Debug("Notify Drag Position:" + Args.Position);
			MainHelper.EventSliderNotify.Post(Args);
		}
		
		function OnUp(Event)
		{
			Event = SfBrowserEvent.GetEvent(Event);
			SfBrowserEvent.Detach("mousemove",OnMove);
			SfBrowserEvent.Detach("mouseup",OnUp);
			SfBrowserEvent.StopPropagation(Event);
			SfBrowserEvent.PreventDefault(Event);
			
			var Args = new SliderArgs(SfSliderNotifyType.NewPosition);
			
			Args.Position = SaveThis.PhysToLog(Event.clientX);
			
			SaveThis.Debug("Notify UP Position:"+Args.Position);
			MainHelper.UserIsSliding = false;
	        MainHelper.EventSliderNotify.Post(Args);
		}
		
	}
}

// ENDFILE SliderArea.js ------------------------------------------------------------------------------->

// BEGINFILE SlideSorterArea.js ------------------------------------------------------------------------>

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

	this.InitializeArea(container, containingWindow, ID);

	// kinda private variables
	this.m_numPerPage = 10;
	this.PageLinkContainerClassName = "";
	this.PageLinkNonCurrentPageClassName = "";
	this.PageLinkCurrentPageClassName = "";
	this.PageLinkPageLabelClassName = "";
	this.CurrentPreviewImage = null;
	
	this.m_slides = new Array();
	this.SlidesInitialized = false;
	
	function SlideSorterArea.prototype.OnLoad()
	{
		this.Debug("SlideSorterAreaOnLoad called");
		this.InitializeNumSlidesPerPage();
		this.InitializeSlideTimings();
		this.RegisterSlideSorterAreaEvents();
		this.Debug("SlideSorterArea load finished");
	}

	function SlideSorterArea.prototype.OnUnLoad()
	{
		MainHelper.EventSlideChanged.RemoveHandler(this.SlideChangedEventHandler);
		MainHelper.EventCommand.RemoveHandler(this.CommandEventHandler);
		MainHelper.EventPlayBegin.RemoveHandler(this.PlayBeginEventHandler);
	}

	function SlideSorterArea.prototype.RegisterSlideSorterAreaEvents()
	{
		this.CommandEventHandler = new SfEventHandler(this.Container);
		this.CommandEventHandler.Container = "SlideSorterAreaInstance";
		this.CommandEventHandler.MethodName = "OnCommandEvent";
		MainHelper.EventCommand.AddHandler(this.CommandEventHandler);	

		this.SlideChangedEventHandler = new SfEventHandler(this.Container);
		this.SlideChangedEventHandler.Container = "SlideSorterAreaInstance";
		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);
	}

	function SlideSorterArea.prototype.OnPlayBeginEvent()
	{
		this.Debug("OnPlayBeginEvent");
		if (this.LastHilitedSlideNumber != -1)
		{
			this.UnHiliteSlide(this.LastHilitedSlideNumber);
		}
	}

	function SlideSorterArea.prototype.OnSlideChangedEvent(args)
	{
		this.Debug("OnSlideChangedEvent called: " + args.Index);
		var index = args.Index;
		if (index < 1)
		{
			this.Debug("Resetting");
			if (this.LastHilitedSlideNumber != -1)
			{
				this.UnHiliteSlide(this.LastHilitedSlideNumber);
				this.LastHilitedSlideNumber = -1;
			}
			return;
		}

		if (MainHelper.Presentation.WhatIsShowing != WhatIsShowing.SlideList)
		{
			return;
		}

		var pageNumber = this.CalculateSlidePage(index);
		
		if (this.CurrentPage != pageNumber)
		{
			// the user is probably just skipping around
			if (this.LastHilitedSlideNumber != -1)
			{
				this.UnHiliteSlide(this.LastHilitedSlideNumber);
			}
			return;
		}
		
		if (MainHelper.DynamicAdd == true)
		{
			// always draw page
			this.DrawPage(pageNumber);
		}
		this.HiliteSlide(index);
	}
	
	function SlideSorterArea.prototype.OnCommandEvent(args)
	{
		this.Debug("OnCommandEvent: " + args);
		switch(args.Command)
		{
			case SfCommandType.ShowSlideShow:
				this.Hide();
				break;
			case SfCommandType.ShowSlideList:
				var currentPage = this.CalculateCurrentSlidePage();
				if (currentPage != -1)
				{
					this.Debug("Drawing page: " + currentPage);
					this.DrawPage(currentPage);
				}
				else if (MainHelper.MaxSlideTimings > 0)
				{
					this.Debug("Drawing page: " + 1);
					SlideSorterAreaInstance.DrawPage(1);
				}
				this.Show();
				MainHelper.Presentation.WhatIsShowing = WhatIsShowing.SlideList;
				break;
		}
	}
	
	function SlideSorterArea.prototype.InitializeSlides()
	{
		this.Debug("InitializeSlides called");
		this.ReplaceWaitForVideoElement();
		this.DrawBlankPage();		
		this.SlidesInitialized = true;
	}

	function SlideSorterArea.prototype.InitializeNumSlidesPerPage()
	{
		this.Debug("Initialize NumSlidesPerPage called");
		var cookie = new SfCookie("NumSlidesPerPage");
		var value = cookie.Get();
		this.Debug("cookie Value: " + value);
		if (value)
		{
			this.m_numPerPage = Number(value);
		}
	}

	function SlideSorterArea.prototype.ReplaceWaitForVideoElement()
	{
		this.Debug("ReplaceWaitForVideoElement called");
		var element = this.GetDiv();
		var waitForVideoElement = SfDOM.FindElementFromID(document, "waitForVideoNode");
		if (!waitForVideoElement)
		{
			SfDebug.DPF(SfDebug.ErrMsgCritical, "SlideSorterArea: could not find waitForVideoElement");
			return;
		}
		
		// "slideSorterDiv" is the id of what resides under the div with 
		// ID = "SlideSorterArea"
		// <div id="SlideSorterArea">
		//	<div id="slideSorterDiv">
		//	</div>
		// </div>
		var slideSorterDiv = document.createElement("div");
		slideSorterDiv.setAttribute("id", "slideSorterDiv");
		
		element.replaceChild(slideSorterDiv, waitForVideoElement);

	}
	
	function SlideSorterArea.prototype.InitializeSlideTimings()
	{
		this.Debug("Initializing slidetimings");
		for (i=0; i<MainHelper.MaxSlideTimings; ++i)
		{
			this.m_slides[i] = new SingleSlide(this, this.Container + ".m_slides[" + i + "]", i+1);
		}
		this.Debug("MaxSlideTimings: " + MainHelper.MaxSlideTimings);
	}
	
	function SlideSorterArea.prototype.CalculateSlidePage(slideNumber)
	{
		this.Debug("CalculateSlidePage: " + slideNumber);
		if (slideNumber < 0 || slideNumber > 10000)
		{
			this.Debug("slideNumber < 0 || slideNumber > 10000. returning 1 as slidePage");
			return 1;
		}
		
		var pageNumber = 1;
		while (pageNumber < 1000) // to make sure that there is no infinite loop
		{
			var pageStartSlideNumber = pageNumber * this.m_numPerPage - this.m_numPerPage + 1;
			var pageEndSlideNumber = pageNumber * this.m_numPerPage;
			if (slideNumber >= pageStartSlideNumber && slideNumber <= pageEndSlideNumber)
			{
				return pageNumber;
			}
			++pageNumber;
		}
		alert('Unexpected result. Page number > 999');
	}

	// returns the pagenumber where the current playing slide belongs
	function SlideSorterArea.prototype.CalculateCurrentSlidePage()
	{
		this.Debug("CalculateCurrentSlidePage called");
		var currentSlideNumber = MainHelper.CurrentSlideNumber;
		this.Debug("CurrentSlideNumber: " + currentSlideNumber);
		if (currentSlideNumber == -1)
		{
			return -1;
		}
		return this.CalculateSlidePage(currentSlideNumber);
	}
	
	function SlideSorterArea.prototype.DrawBlankPage()
	{
		this.Debug("DrawBlankPage called");
		var newElement = document.createElement("div");
		newElement.setAttribute("id", "slideSorterDiv");

		this.PageLinkManager = new PageLinkManager(this);
		newElement.appendChild(this.PageLinkManager.CreateTopPageLinks());

		var slidesContainer = document.createElement("div");
		newElement.appendChild(slidesContainer);

		for (i=0; i<this.m_numPerPage; ++i)
		{
			// add the element
			// have to create everytime because of freakin mac
			this.m_slides[i] = new SingleSlide(this, this.Container + ".m_slides[" + i + "]", i+1);
			slidesContainer.appendChild(this.m_slides[i].CreateBlankElement());
		}
		
		newElement.appendChild(this.PageLinkManager.CreateBottomPageLinks());
		
		var oldElement = SfDOM.FindElementFromID(document, "slideSorterDiv");
		this.GetDiv().replaceChild(newElement, oldElement);

		// needs to be sequentially loaded because of IE BUg
		for (i=0; i<this.m_numPerPage; ++i)
		{
			this.m_slides[i].PreviewLinkInstance.ImageElement.setAttribute("src", this.ImageBase + "/preview_slide_n.gif");
			this.m_slides[i].PlayLinkInstance.ImageElement.setAttribute("src", this.ImageBase + "/play_from_slide_n.gif");
			this.m_slides[i].DividerImageElement.setAttribute("src", this.ImageBase + "/slide_list_divider.gif");
		}

		this.Debug("finished drawing blank page");
	}
	
	function SlideSorterArea.prototype.DrawPage(pageNumber)
	{
		this.Debug("Drawpage called: " + pageNumber);
		if (this.SlidesInitialized == false)
		{
			this.InitializeSlides();
		}		

		var slideSorterElement = SfDOM.FindElementFromID(document, "slideSorterDiv");

		this.PageLinkManager.UpdatePageLinks(pageNumber);

		if (this.LastHilitedSlideNumber != -1)
		{
			this.UnHiliteSlide(this.LastHilitedSlideNumber);
		}

		var pageStartIndex = pageNumber * this.m_numPerPage - this.m_numPerPage;
		var pageEndIndex = pageNumber * this.m_numPerPage;
		// i = slidenumber, counter = position in page
		var counter = 0;
		var currentSlideNumber = MainHelper.CurrentSlideNumber;
		for (i=pageStartIndex; i<pageEndIndex && i< MainHelper.MaxSlideTimings; ++i)
		{
			this.m_slides[counter].ImageElement.setAttribute("src", MainHelper.Presentation.ImageBaseURL + "/" + MainHelper.Presentation.SlideTimings[i].ThumbNail.Image);
			this.m_slides[counter].PreviewLinkInstance.ImageElement.onclick = new Function("", this.Container + ".ShowBigSlide(" + (i+1) + ");");			
			this.m_slides[counter].PlayLinkInstance.ImageElement.onclick = new Function("", this.Container + ".NavigateToSlide(" + (i+1) + ");");			
			this.m_slides[counter].Element.style.visibility = 'visible';

			if (i+1 == currentSlideNumber)
			{
				this.HiliteSlide(i+1);
			}
			++counter;
		}
		for (i=counter; i<this.m_numPerPage; ++i)
		{
			this.m_slides[i].Element.style.visibility = 'hidden';
		}
		
		this.CurrentPage = pageNumber;
		this.Debug("finished drawing page: " + pageNumber);
	}

	this.LastHilitedSlideNumber = -1;
	function SlideSorterArea.prototype.HiliteSlide(slideNumber)
	{
		this.Debug("HiliteSlide: " + slideNumber);
		
		var imageElement = this.GetSlideObject(slideNumber).ImageElement;
		if (!imageElement)
		{
			SfDebug.DPF(SfDebug.ErrMsgCritical, 'could not find imageElement');
			return;
		}
		var width = MainHelper.DefaultThumbNailWidth - 20;
		var height = MainHelper.DefaultThumbNailHeight - 20;
		
		imageElement.style.cssText = 'border-style:solid;border-width:10px;border-color:red' +
			';width:' + width +
			';height:' + height;
			
		if (this.LastHilitedSlideNumber != -1 && this.LastHilitedSlideNumber != slideNumber)
		{
			this.UnHiliteSlide(this.LastHilitedSlideNumber);
		}
		this.LastHilitedSlideNumber = slideNumber;
	}
	
	function SlideSorterArea.prototype.UnHiliteSlide(slideNumber)
	{
		var imageElement = this.GetSlideObject(slideNumber).ImageElement;
		if (!imageElement)
		{
			SfDebug.DPF(SfDebug.ErrMsgCritical, 'could not find imageElement');
			return;
		}
		var width = MainHelper.DefaultThumbNailWidth;
		var height = MainHelper.DefaultThumbNailHeight;
		
		imageElement.style.cssText = 
			';border:none' +
			';width:' + width +
			';height:' + height;
		
	}
	
	function SlideSorterArea.prototype.GetSlideObject(slideNumber)
	{
		var position = (slideNumber - 1) % this.m_numPerPage;
		return this.m_slides[position];
	}
	
	function SlideSorterArea.prototype.Debug(str)
	{
		SfDebug.DPF(this.m_debugLevel, "SlideSorterArea: " + str);
	}

	function SlideSorterArea.prototype.ShowBigSlide(slideNumber)
	{
		var captureImageInfo;
		var slideTiming;
		
		slideTiming = MainHelper.Presentation.SlideTimings[slideNumber-1];

		if (slideTiming.FullSize.Image)
		{
			captureImageInfo = slideTiming.FullSize;
		}
		else if (slideTiming.Normal.Image)
		{
			captureImageInfo = slideTiming.Normal;
		}
		else
		{
			SfDebug.DPF(SfDebug.ErrMsgCritical, "no image found for slidenumber: " + slideNumber);
		}
					
		this.CurrentPreviewImage = MainHelper.Presentation.ImageBaseURL + '/' + captureImageInfo.Image;
		
		var areaManager = GetAreaManager();
		if (!areaManager)
		{
			this.Debug("could not find AreaManager");
			return;
		}	
			
		if (WindowHelper.IsOpen(MainHelper.PopupWindows.PreviewSlide) == true)
		{
			var previewSlide = areaManager.GetArea(AreaNames.PreviewSlideArea);
			if (previewSlide)
			{
				previewSlide.ChangeImage(this.CurrentPreviewImage);
			}
		}
		else
		{
			var width = MainHelper.DefaultFullSizeWidth + 2;
			var height = MainHelper.DefaultFullSizeHeight + 2;

			MainHelper.PopupWindows.PreviewSlide =

				WindowHelper.CreateNamedPopup(PopupNames.PreviewSlide, "PreviewSlide", width, height, true, true);
		}
	}

	// remember number is 1 indexed and not 0
	function SlideSorterArea.prototype.NavigateToSlide(slideNumber)
	{
		this.Debug("NavigateToSlide(slideNumber: " + slideNumber + ") called");
		var args = new CommandArgs(SfCommandType.NavigateToSlide);
		args.SlideNumber = slideNumber;
		MainHelper.EventCommand.Post(args);
	}
	
	// A single slide represents one thumbnail
	// It contains a "PreviewLink" and a "PlayLink"
	// ParentArea is the slidesorter area instance
	function SingleSlide(parentArea, container, position)
	{
		this.ParentArea = parentArea;
		this.Container = container;
		this.Position = position;
		this.PreviewLinkInstance = new PreviewLink(this.ParentArea, this.Container + ".PreviewLinkInstance", this.Position);
		this.PlayLinkInstance = new PlayLink(this.ParentArea, this.Container + ".PlayLinkInstance", this.Position);
		this.Hilite = false;

		function SingleSlide.prototype.CreateBlankElement()
		{
			var height = MainHelper.DefaultThumbNailHeight;;
			var width = MainHelper.DefaultThumbNailWidth + 2;// !!! perhaps change this
			
			var cssText = 'float:left;width:' + width;
			
			var singleSlideElement = document.createElement("span");
			singleSlideElement.setAttribute("id", this.ID); 

			var imgContainer = document.createElement("div");
			singleSlideElement.appendChild(imgContainer);
			var imgElement = document.createElement("img");
			imgContainer.appendChild(imgElement);
			imgElement.setAttribute("height", height);
			imgElement.setAttribute("width", width);
			imgElement.style.left = 0;
			this.ImageElement = imgElement;

			var previewLinkElement = this.PreviewLinkInstance.CreateBlankElement();
			previewLinkElement.style.cursor = 'hand';
			singleSlideElement.appendChild(previewLinkElement);
			
			imgElement = this.CreateBlankDividerElement();
			singleSlideElement.appendChild(imgElement);

			var playLinkElement = this.PlayLinkInstance.CreateBlankElement();
			playLinkElement.style.cursor = 'hand';
			singleSlideElement.appendChild(playLinkElement);

			singleSlideElement.style.cssText = cssText;
			singleSlideElement.style.visibility = 'hidden';

			this.Element = singleSlideElement;			
			return singleSlideElement;
		}
		
		function SingleSlide.prototype.CreateBlankDividerElement()
		{
			var imgElement = document.createElement("img");
			imgElement.setAttribute("width", "2");
			imgElement.setAttribute("alt", "");
			imgElement.setAttribute("border", "0");
			this.DividerImageElement = imgElement;
			return imgElement;
		}
		
		function PreviewLink(parentArea, container, position)
		{
			this.ParentArea = parentArea;
			this.Container = container;
			this.Position = position; 
			this.MouseDownImage = "preview_slide_d.gif";
			this.MouseOverImage = "preview_slide_o.gif";
			this.MouseOutImage = "preview_slide_n.gif"
			this.ImageName = "previewImage_" + this.Position;

			function PreviewLink.prototype.CreateBlankElement()
			{
				var imgElement = document.createElement("img");
				imgElement.setAttribute("alt", "Preview Slide");
				imgElement.setAttribute("border", "0");
				imgElement.setAttribute("id", this.ImageName);

				this.AddEvents(imgElement);
				this.ImageElement = imgElement;
				return imgElement;
			}
			
			function PreviewLink.prototype.AddEvents(link)
			{
				link.onmouseover = new Function("", this.Container + ".OnMouseOver();");
				link.onmouseout = new Function("", this.Container + ".OnMouseOut();");
				link.onmousedown = new Function("", this.Container + ".OnMouseDown();");
			}
			
			function PreviewLink.prototype.OnMouseOver()
			{
				var image = SfDOM.FindElementFromID(document, this.ImageName);
				image.src = this.ParentArea.ImageBase + "/" + this.MouseOverImage;
			}

			function PreviewLink.prototype.OnMouseOut()
			{
				var image = SfDOM.FindElementFromID(document, this.ImageName);
				image.src = this.ParentArea.ImageBase + "/" + this.MouseOutImage;
			}

			function PreviewLink.prototype.OnMouseDown()
			{
				var image = SfDOM.FindElementFromID(document, this.ImageName);
				image.src = this.ParentArea.ImageBase + "/" + this.MouseOutImage;
			}
		}
		
		function PlayLink(parentArea, container, position)
		{
			this.ParentArea = parentArea;
			this.Container = container;
			this.Position = position;
			this.MouseDownImage = "play_from_slide_d.gif";
			this.MouseOverImage = "play_from_slide_o.gif";
			this.MouseOutImage = "play_from_slide_n.gif"
			this.ImageName = "playImage_" + this.Position;

			function PlayLink.prototype.CreateBlankElement()
			{
				var imgElement = document.createElement("img");
				imgElement.setAttribute("alt", "Play from this Slide");
				imgElement.setAttribute("id", this.ImageName);
				
				if (MainHelper.Presentation.Status == PresentationStatus.ReplayReady)
				{
					this.AddEvents(imgElement);
				}
				this.ImageElement = imgElement;
				return imgElement;
			}

			function PlayLink.prototype.AddEvents(link)
			{
				link.onmouseover = new Function("", this.Container + ".OnMouseOver();");
				link.onmouseout = new Function("", this.Container + ".OnMouseOut();");
				link.onmousedown = new Function("", this.Container + ".OnMouseDown();");
			}
			
			function PlayLink.prototype.OnMouseOver()
			{
				var image = SfDOM.FindElementFromID(document, this.ImageName);
				image.src = this.ParentArea.ImageBase + "/" + this.MouseOverImage;
			}

			function PlayLink.prototype.OnMouseOut()
			{
				var image = SfDOM.FindElementFromID(document, this.ImageName);
				image.src = this.ParentArea.ImageBase + "/" + this.MouseOutImage;
			}

			function PlayLink.prototype.OnMouseDown()
			{
				var image = SfDOM.FindElementFromID(document, this.ImageName);
				image.src = this.ParentArea.ImageBase + "/" + this.MouseOutImage;
			}
		}
	}

	function PageLinkManager(parentArea)
	{
		this.ParentArea = parentArea;
		this.SelectedPage = -1;
		this.DebugLevel = SfDebug.Verbose;
		
		function PageLinkManager.prototype.Debug(msg)
		{
			SfDebug.DPF(this.DebugLevel, "PageLinkManager: " + msg);
		}
						
		function PageLinkManager.prototype.CreateTopPageLinks()
		{
			this.TopPageLinkChain = new PageLinkChain(this.ParentArea);
			var pageLinkElement = this.TopPageLinkChain.CreateElement();
			pageLinkElement.setAttribute("id", "pageLinkTop");
			pageLinkElement.style.cssText = 'text-align:right; width: 98%';

			return pageLinkElement;
		}
		
		function PageLinkManager.prototype.CreateBottomPageLinks()
		{
			this.BottomPageLinkChain = new PageLinkChain(this.ParentArea);
			var pageLinkElement = this.BottomPageLinkChain.CreateElement();
			pageLinkElement.setAttribute("id", "pageLinkBottom");
			pageLinkElement.style.cssText = 'text-align:right;clear:both; width: 98%';

			return pageLinkElement;
		}

		function PageLinkManager.prototype.UpdatePageLinks(pageNumber)
		{
			this.SelectPage(pageNumber);
		}
		
		function PageLinkManager.prototype.SelectPage(pageNumber)
		{
			this.TopPageLinkChain.SelectPage(pageNumber);
			this.BottomPageLinkChain.SelectPage(pageNumber);
			this.SelectedPage = pageNumber;
		}

		function PageLinkChain(parentArea)
		{
			this.ParentArea = parentArea;
			this.NumLinks = 11;
						
			function PageLinkChain.prototype.CreateElement()
			{
				var pageLinkElement = document.createElement("div");
				pageLinkElement.className = SlideSorterAreaInstance.PageLinkContainerClassName;
				var spanElement = document.createElement("span");
				pageLinkElement.appendChild(spanElement);
				spanElement.className = SlideSorterAreaInstance.PageLinkPageLabelClassName;
				var textNode = document.createTextNode("page: ");
				spanElement.appendChild(textNode);
				
				this.PageLinks = new Array(this.NumLinks + 2);
				var onePageLink = new OnePageLink();
				spanElement.appendChild(onePageLink.CreateElement());
				this.PageLinks[0] = onePageLink;
				for (i=1; i<=this.NumLinks; ++i)
				{
					onePageLink = new OnePageLink();
					spanElement.appendChild(onePageLink.CreateElement());
					this.PageLinks[i] = onePageLink;
				}
				onePageLink = new OnePageLink();
				spanElement.appendChild(onePageLink.CreateElement());
				this.PageLinks[this.NumLinks+1] = onePageLink;
				
				this.Element = pageLinkElement;
				return pageLinkElement;
			}
			
			function PageIndexCalculator(pageNumber, totalPages, toEachSide)
			{
				this.PageNumber = pageNumber;
				this.TotalPages = totalPages;
				this.ToEachSide = toEachSide;
				
				function PageIndexCalculator.prototype.GetLeftOverFromEnd()
				{
					if ((this.TotalPages - this.PageNumber)  >= this.ToEachSide)
					{
						return 0;
					}
					else
					{
						return this.ToEachSide - (this.TotalPages - this.PageNumber);
					}
				}
				
				function PageIndexCalculator.prototype.GetLeftOverFromStart()
				{
					if (this.PageNumber > this.ToEachSide)
					{
						return 0;
					}
					else
					{
						return this.ToEachSide - this.PageNumber + 1;
					} 
				}
				
				function PageIndexCalculator.prototype.GetStartIndex()
				{
					return Math.max(1,  this.PageNumber - this.ToEachSide - this.GetLeftOverFromEnd());	
				}
				
				function PageIndexCalculator.prototype.GetEndIndex()
				{
					return Math.min(this.TotalPages, this.PageNumber + this.ToEachSide + this.GetLeftOverFromStart());
				}
			}
			
			function PageLinkChain.prototype.SelectPage(pageNumber)
			{
				var totalPages = this.GetTotalPages();
				var toEachSide = (this.NumLinks - 1) / 2;
				var pageIndexCalculator = new PageIndexCalculator(pageNumber, totalPages, toEachSide);
				var startIndex = pageIndexCalculator.GetStartIndex();
				var endIndex = pageIndexCalculator.GetEndIndex();

				var counter = 0;
				if (pageNumber > 1)
				{
					this.PageLinks[counter].SetTextAndPageNumber("<Prev", pageNumber-1);
					this.PageLinks[counter].Show();
					this.PageLinks[counter].MakeLinkClickable();
					++counter;
				}
				for (i=startIndex; i<=endIndex; ++i)
				{
					this.PageLinks[counter].SetTextAndPageNumber(i, i);
					this.PageLinks[counter].Show();
					if (i == pageNumber)
					{
						this.PageLinks[counter].MakeLinkUnClickable();
					}
					else
					{
						this.PageLinks[counter].MakeLinkClickable();
					}
					++counter;
				}				
				if (pageNumber < totalPages)
				{
					this.PageLinks[counter].SetTextAndPageNumber("Next>", pageNumber+1);
					this.PageLinks[counter].Show();
					this.PageLinks[counter].MakeLinkClickable();
					++counter;
				}
				
				for (i=counter; i<this.PageLinks.length; ++i)
				{
					this.PageLinks[i].Hide();
				}
			}

			function PageLinkChain.prototype.GetTotalPages()
			{			
				if (MainHelper.MaxSlideTimings <= 0)
				{
					return 0;
				}
				return Math.ceil(MainHelper.MaxSlideTimings / this.ParentArea.m_numPerPage);
			}
			
		}
		
		function OnePageLink()
		{
			function OnePageLink.prototype.CreateElement()
			{
				var spanElement = document.createElement("span");
				spanElement.className = SlideSorterAreaInstance.PageLinkNonCurrentPageClassName;
				var textNode = document.createTextNode("");
				spanElement.appendChild(textNode);
				this.TextNode = textNode;
				this.Element = spanElement;
				return spanElement;
			}
			
			function OnePageLink.prototype.SetTextAndPageNumber(text, pageNumber)
			{
				this.TextNode.nodeValue = text;
				this.Text = text;
				this.PageNumber = pageNumber;
			}

			function OnePageLink.prototype.MakeLinkUnClickable()
			{
				this.Element.className = SlideSorterAreaInstance.PageLinkCurrentPageClassName;
				this.Element.style.textDecoration='none';
				this.Element.style.cursor = 'default';
				this.Element.onclick = '';
			}

			function OnePageLink.prototype.MakeLinkClickable()
			{
				this.Element.className = SlideSorterAreaInstance.PageLinkNonCurrentPageClassName;
				this.Element.style.textDecoration='underline';
				this.Element.style.cursor = 'hand';
				this.Element.onclick = new Function("", "SlideSorterAreaInstance.DrawPage(" + this.PageNumber + ");");
			}
			
			function OnePageLink.prototype.Hide()
			{
				this.Element.style.visibility = 'hidden';
			}
	
			function OnePageLink.prototype.Show()
			{
				this.Element.style.visibility = 'visible';
			}
		}
	}
}

// ENDFILE SlideSorterArea.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);

	function TextSlideSorterArea.prototype.OnLoad()
	{
		this.Debug("TextSlideSorterAreaOnLoad called");
		this.RegisterTextSlideSorterAreaEvents();
		this.SetSlideInitialStatuses();
	}
	
	function TextSlideSorterArea.prototype.RegisterTextSlideSorterAreaEvents()
	{
		this.SlideChangedEventHandler = new SfEventHandler(this.Container);
		this.SlideChangedEventHandler.Container = this.Container;
		this.SlideChangedEventHandler.MethodName = "OnSlideChangedEvent";
		MainHelper.EventSlideChanged.AddHandler(this.SlideChangedEventHandler);	
		
		this.CommandEventHandler = new SfEventHandler(this.Container);
		this.CommandEventHandler.Container = this.Container;
		this.CommandEventHandler.MethodName = "OnCommandEvent";
		
		MainHelper.EventCommand.AddHandler(this.CommandEventHandler);
	
		this.PlayBeginEventHandler = new SfEventHandler(this.ID);
		this.PlayBeginEventHandler.MethodName = "OnPlayBeginEvent";
		this.PlayBeginEventHandler.Container = this.Container;

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

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

	function TextSlideSorterArea.prototype.OnCommandEvent(args)
	{
		this.Debug("OnCommandEvent: " + args);
		switch(args.Command)
		{
			case SfCommandType.ShowInfo:
				this.Hide();
				break;
			case SfCommandType.ShowTextSlideList:
				this.Show();
				break;
		}
	}

	function TextSlideSorterArea.prototype.OnSlideChangedEvent(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);
		
	}
	
	function TextSlideSorterArea.prototype.AddDynamicSlidesIfNeeded()
	{
		this.Debug("AddNeededDynamicSlides called");
		
		var max = MainHelper.MaxSlideTimings;
		if (max == this.NumSlideElements)
		{
			return;
		}
		
		var startIndex = this.NumSlideElements + 1;
		var endIndex = max;
		var i;
		for (i=startIndex; i<=endIndex; ++i)
		{
			this.AddDynamicSlide(i);
		}
		this.NumSlideElements = endIndex;
	}
	
	function TextSlideSorterArea.prototype.SetSlideInitialStatuses()
	{
		this.Debug("SetSlideInitialStatuses called");
		this.NumSlideElements = MainHelper.MaxSlideTimings;
		
		if (MainHelper.Presentation.Status == PresentationStatus.CaptureInProgress)
		{
			this.MakeAllSlidesUnClickable();
		}
		
	}
	
	function TextSlideSorterArea.prototype.MakeAllSlidesClickable()
	{
		var max = MainHelper.MaxSlideTimings;
		for (i=0; i<max; ++i)
		{
			this.MakeSlideClickable(i+1);
		}
	}

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

	function TextSlideSorterArea.prototype.SelectSlide(slideNumber)
	{
		this.Debug("SelectSlide: " + slideNumber + " called");
		if (this.LastSelectedSlideNumber != -1)
		{
			// unselect the last selected slide
			this.UnHiliteSlide(this.LastSelectedSlideNumber);
			if (MainHelper.Presentation.Status == PresentationStatus.ReplayReady)
			{
				this.MakeSlideClickable(this.LastSelectedSlideNumber);
			}
		}
		this.HiliteSlide(slideNumber);
		this.MakeSlideUnClickable(slideNumber);
		this.LastSelectedSlideNumber = slideNumber;
	}
	
	function TextSlideSorterArea.prototype.AddDynamicSlide(slideNumber)
	{
		this.Debug("AddDynamicSlide " + slideNumber + " called");
		
		var divElem = document.createElement("div");
		divElem.setAttribute("id", "textSlideDiv" + slideNumber);
		divElem.style.cssText = this.TextStyle;
		
		var slideNumberElement = document.createElement("span");
		slideNumberElement.appendChild(document.createTextNode(slideNumber + ". "));
		divElem.appendChild(slideNumberElement);
		
		var titleElement = document.createElement("span");
		titleElement.setAttribute("id", "textSlideTitle");
		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);
		}
	}
	
	function TextSlideSorterArea.prototype.Debug(str)
	{
		SfDebug.DPF(this.m_debugLevel, "TextSlideSorterArea: " + str);
	}

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

	function TextSlideSorterArea.prototype.HiliteSlide(slideNumber)
	{
		this.Debug("HiliteSlide called");
		var elem = this.FindDivElementForSlideNumber(slideNumber);
		if (elem == null)
		{
			return;
		}
		elem.style.cssText = this.CurrentSlideTextStyle;
	}
	
	function TextSlideSorterArea.prototype.UnHiliteSlide(slideNumber)
	{
		this.Debug("UnHiliteSlide called");
		var elem = this.FindDivElementForSlideNumber(slideNumber);
		if (elem == null)
		{
			return;
		}
		elem.style.cssText = this.TextStyle;
	}
	
	function TextSlideSorterArea.prototype.MakeSlideClickable(slideNumber)
	{
		this.Debug("MakeSlideClickable called");
		var elem = this.FindTitleElementForSlideNumber(slideNumber);
		if (elem == null)
		{
			return;
		}
		elem.style.textDecoration='underline';
		elem.style.cursor = 'hand';
		elem.onclick = new Function("", this.Container + ".NavigateToSlide(" + slideNumber + ");");
	}
		
	function TextSlideSorterArea.prototype.MakeSlideUnClickable(slideNumber)
	{
		this.Debug("MakeSlideUnClickable called");
		var elem = this.FindTitleElementForSlideNumber(slideNumber);
		if (elem == null)
		{
			return;
		}
		elem.style.textDecoration='none';
		elem.style.cursor = 'default';
		elem.onclick = '';
	}

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

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

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