// 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 WM64PlayerArea.js ----------------------------------------------------------------------->

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

	this.PlayerType = PlayerType.WM64;
	this.EnableVolumeControls = null; // from cs code
	this.PlayerEventManager = new PlayerEventManager(this);

	// Need to add the following line because
	// when you call .prototype this gets executed	
	if (container && containingWindow && ID)
	{
		this.InitializeArea(container, containingWindow, ID);
	}
	
	this.LoadPlayerControl = function()
	{
		var objEmbeddedPlayer = this.GetEmbeddedPlayer();
		this.pci = new PlayerControlWM64(objEmbeddedPlayer);
	}
	
	this.SetupPlayer = function()
	{
		this.LoadPlayerControl();
		
		// initialize PlayerEventManager
		this.PlayerEventManager.AttachEmbeddedPlayerEvents(this.pci.objEmbedded);

 		// create the position slider
		this.PositionTimer = null;

		this.AddEventHandlers();

		this.pci.SetInvokeUrls(false);
		
		this.pci.SetMedia(MainHelper.Presentation.VideoUrl);

		if (this.StartTime != -1)
		{
			this.SetStartTime(Number(this.StartTime));
		}

		this.Debug("Loaded: " + MainHelper.Presentation.VideoUrl + " Duration: " + this.pci.GetMediaDuration());
		this.PostMediaLengthObtainedEvent();
	    
		this.TimedUpdate();
    
		MainHelper.EventPlayerSetupComplete.Post(new SfEventArgs());
		this.Volume = new Volume(this.pci);
		this.Volume.InitializeVolume();
 		this.EnableTransportButtons(PlayState.Playing);
 		
 	}
	
	this.ShowPlayerDivWhenReady = function()
	{
		var embeddedPlayer = this.GetDivToHideWhenNotReady();
		if (embeddedPlayer)
		{
			embeddedPlayer.style.display = '';
		}
		else
		{
			this.Debug("!!EmbeddedPlayer not found");
		}
	}
	
	this.HidePlayerDivWhenNotReady = function()
	{
		var embeddedPlayer = this.GetDivToHideWhenNotReady();
		if (embeddedPlayer)
		{
			embeddedPlayer.style.display = 'none';
		}
		else
		{
			this.Debug("!EmbeddedPlayer not found");
		}
	}
	
	this.GetDivToHideWhenNotReady = function()
	{
		return SfDOM.FindElementFromID(document, "EmbeddedPlayer");
	}

	this.AddEventHandlers = function()
	{
		this.SliderNotifyEventHandler = new SfEventHandler("Player");
		this.SliderNotifyEventHandler.Container = this.Container;
		this.SliderNotifyEventHandler.MethodName = "OnSliderNotifyEvent";
		MainHelper.EventSliderNotify.AddHandler(this.SliderNotifyEventHandler);
    
 		this.ScriptEventHandler = new SfEventHandler("Player");
		this.ScriptEventHandler.MethodName = "OnScriptEvent";
		this.ScriptEventHandler.Container = this.Container;
		MainHelper.EventScript.AddHandler(this.ScriptEventHandler);

 		this.CommandEventHandler = new SfEventHandler("Player");
		this.CommandEventHandler.MethodName = "OnCommandEvent";
		this.CommandEventHandler.Container = this.Container;
		MainHelper.EventCommand.AddHandler(this.CommandEventHandler);
		
		this.EventManagerPlayStateChangeHandler = new SfEventHandler();
		this.EventManagerPlayStateChangeHandler.Container = this.Container;
		this.EventManagerPlayStateChangeHandler.MethodName = "OnEventManagerPlayStateChangeEvent";
		MainHelper.EventPlayerPlayStateChanged.AddHandler(this.EventManagerPlayStateChangeHandler);
    
		this.EventManagerPositionChangeHandler = new SfEventHandler();
		this.EventManagerPositionChangeHandler.MethodName = "OnEventManagerPositionChangeEvent";
		this.EventManagerPositionChangeHandler.Container = this.Container;
		MainHelper.EventPlayerPositionChanged.AddHandler(this.EventManagerPositionChangeHandler);
	}
	
	this.RemoveEventHandlers = function()
	{
		MainHelper.EventSliderNotify.RemoveHandler(this.SliderNotifyEventHandler);
		MainHelper.EventScript.RemoveHandler(this.ScriptEventHandler);
		MainHelper.EventCommand.RemoveHandler(this.CommandEventHandler);
		MainHelper.EventPlayerPlayStateChanged.RemoveHandler(this.EventManagerPlayStateChangeHandler);
		MainHelper.EventPlayerPositionChanged.RemoveHandler(this.EventManagerPositionChangeHandler);
	}
	
	this.OnUnLoad = function()
	{
		this.RemoveEventHandlers();
	}

	this.PostMediaLengthObtainedEvent = function()
	{
		var range = new Object();
		range.Left = 0;
		range.Right = this.pci.GetMediaDuration();
		
		MainHelper.EventPlayerMediaLengthObtained.Post(range);
	}
  
    this.EnableTransportButtons = function(state)
    {
		this.Debug("EnableTransportButtons called, state: " + GetPlayStateName(state));
		MainHelper.EventPlayerStateChanged.Post(state);
    }
    
    
	this.Play = function()
	{
		this.Debug("Play called");
		if (this.pci.GetPlayState() == PlayState.Stopped)
		{
			// reset presentation from stop
			var currentPos = this.pci.GetPosition();
			this.Debug('currentPosition: ' + currentPos);
			if (currentPos == 0)
			{
				MainHelper.CurrentSlideNumber = -1;
				MainHelper.EventPlayBegin.Post(new Object());
			}
		}
		this.pci.Play();
		this.EnableTransportButtons(PlayState.Playing);

		MainHelper.PresentationEnded = false;

		this.PositionTimer = setTimeout(this.Container + ".TimedUpdate()", 500);
	}
	
	this.SetLanguage = function(id)
	{
		this.Debug("SetLanguage(" + id + ")");
		this.pci.SetLanguage(id);
	}

	this.Pause = function()
	{
		this.pci.Pause();
		this.EnableTransportButtons(PlayState.Paused);

		// no need for timedupdate now
		if (this.PositionTimer)
		{
			clearTimeout(this.PositionTimer);
		}
	}

	this.Stop = function()
	{
		this.pci.Stop();
		this.EnableTransportButtons(PlayState.Stopped);

		// no need for timedupdate now
		if (this.PositionTimer)
		{
			clearTimeout(this.PositionTimer);
		}
	}

	this.FullScreen = function()
	{
		if (this.pci.GetPlayState() != PlayState.Stopped)
		{
			this.pci.SetFullScreen(true);
		}
	}

	this.Mute = function()
	{
		this.Debug("Mute called");
		if (this.Volume == null)
		{
			this.Debug("Volume not initialized yet");
			return;
		}
		this.Volume.ToggleMute();
	}
	
	this.SetVolume = function(vol)
	{
		this.Debug("SetVolume()");
		this.Volume.SetVolume(vol);
	}
	
	this.VolumeUp = function()
	{
		this.Debug("VolumeUp called");
		if (this.Volume == null)
		{
			this.Debug("Volume not initialized yet");
			return;
		}
		this.Volume.ChangeVolume(6);
	}

	this.VolumeDown = function()
	{
		this.Debug("VolumeDown called");
		if (this.Volume == null)
		{
			this.Debug("Volume not initialized yet");
			return;
		}
		this.Volume.ChangeVolume(-6);
	}

	this.OnScriptEvent = function(args)
	{
		switch(args.Command)
		{
			case SfScriptCommandType.EndPresentation:
				this.Debug("OnEndPresentation");
				this.pci.Stop();
				this.EnableTransportButtons(PlayState.Stopped);
				MainHelper.PresentationEnded = true;
				break;
		}
	}

	this.OnCommandEvent = function(args)
	{
		switch(args.Command)
		{
			case SfCommandType.NavigateToSlide:
				var slideNumber = args.SlideNumber;
				if (!slideNumber)
				{
					SfDebug.DPF(SfDebug.ErrMsgCritical, "Navigate to Slide no SlideNumber present");
					return;
				}
				this.NavigateToSlide(Number(slideNumber));
				break;
			case SfCommandType.Play:
				this.Play();
				break;
			case SfCommandType.Pause:
				this.Pause();
				break;
			case SfCommandType.Stop:
				this.Stop();
				break;
			case SfCommandType.FullScreen:
				this.FullScreen();
				break;
			case SfCommandType.Mute:
				this.Mute();
				break;
			case SfCommandType.SetVolume:
				this.SetVolume(args.Volume);
				break;
			case SfCommandType.VolumeUp:
				this.VolumeUp();
				break;
			case SfCommandType.VolumeDown:
				this.VolumeDown();
				break;
			case SfCommandType.NavigateToChapter:
				this.NavigateToChapter(Number(args.Number), Number(args.Time));
				break;
		}
	}
	
	this.OnSliderNotifyEvent = function(objNotify)
	{
		switch(objNotify.NotifyType)
		{
			case SfSliderNotifyType.NewPosition:
				this.Debug("OnSliderNotify called: " + objNotify.Position);
				this.pci.SetPosition(objNotify.Position);
				break;
		}
	}
	
	this.OnEventManagerPlayStateChangeEvent = function(args)
	{
		this.Debug("OnEventManagerPlayStateChangeEvent, playState: " + GetPlayStateName(args.PlayState));
		this.EnableTransportButtons(args.PlayState);
		
		switch(args.PlayState)
		{
			case PlayState.Buffering:
				this.PostMediaLengthObtainedEvent();
				break;
					
			case PlayState.Playing:
				// local files won't have duration until now
				this.Debug("Resetting duration: " + this.pci.GetMediaDuration());
				this.PostMediaLengthObtainedEvent();
				break;
		}
	}

	this.OnEventManagerPositionChangeEvent = function(args)
	{
		this.Debug("OnEventManagerPositionChangeEvent called, newPosition: " + args.NewPosition);
		// fire event to change the slide being shown now.
		var slideNumber = this.CalculateSlideNumberToShow(args.NewPosition);
		
		if (slideNumber == 0)
		{
			this.Debug("no need to change slide");
			return;
		}
		
		this.Debug("switching to slide: " + slideNumber);
		var args =  MainHelper.CreateShowSlideEventArgs(slideNumber);
		MainHelper.CurrentSlideNumber = slideNumber;
		MainHelper.EventScript.Post(args);	
	}

	this.TimedUpdate = function()
	{
		// !! don't post when user is sliding
		var pos = this.pci.GetPosition();
		if (typeof(pos) != 'undefined')
		{
			this.PostPlayerTimerUpdatedEvent(pos);
		}

		this.PositionTimer = setTimeout(this.Container + ".TimedUpdate()", 500);
	}
	
	this.PostPlayerTimerUpdatedEvent = function(pos)
	{
		MainHelper.EventPlayerTimerUpdated.Post(pos);
	}
	
	this.SetStartTime = function(startTimeInMilliSeconds)
	{
		var timeCode = startTimeInMilliSeconds/1000;
		this.pci.SetPosition(timeCode);
		this.PostPlayerTimerUpdatedEvent(timeCode);
	}
	
	this.NavigateToTime = function(timeInMilliSeconds)
	{
		this.Debug("NavigateToTime(): " + timeInMilliSeconds);
		this.SetStartTime(timeInMilliSeconds);
		
		MainHelper.EventCommand.Post(new CommandArgs(SfCommandType.Play));
	}

	this.NavigateToSlide = function(slideNumber)
	{
		this.Debug("NavigateToSlide: " + slideNumber + " called");
		if (MainHelper.Presentation.Status != PresentationStatus.ReplayReady)
		{
			this.Debug("can not navigate when presentation is not on demand");
			return;
		}
		
		if (slideNumber < 0)
		{
			this.Debug("SlideNumber is less than 0");
			return;
		}
		if (MainHelper.MaxSlideTimings < slideNumber)
		{
			SfDebug.DPF(SfDebug.ErrMsgCritical, "slidetimings not known for slideNumber: " + slideNumber);
			return;
		}
		
		var slideTiming = MainHelper.Presentation.SlideTimings[slideNumber-1];
	
		var timeCode = (slideNumber == 0) ? 0.00 : slideTiming.Time;
		this.Debug("Navigating to timeCode: " + timeCode);
		
		this.NavigateToTime(timeCode * 1000);
	}
	
	this.NavigateToChapter = function(number, timeInMilliSeconds)
	{
		this.Debug("NavigateToChapter(): " + number);
		
		this.NavigateToTime(timeInMilliSeconds);
	}

}

// ENDFILE WM64PlayerArea.js ------------------------------------------------------------------------->

// BEGINFILE PlayerControlWM64.js -------------------------------------------------------------------->

    var WM6OpenState =
    {
        Closed:     0,
        LoadingASX: 1,
        LoadingNSC: 2,
        Locating:   3,
        Connecting: 4,
        Opening:    5,
        Open:       6
    }
    
    var WM6ReadyState=
    {
		Uninitialized:	0,
		Loading:		1,
		Interactive:	3,
		Complete:		4
	}
    
    var WM6PlayState =
    {
        Stopped:        0,
        Paused:         1,
        Playing:        2,
        Waiting:        3,
        ScanForward:    4,
        ScanReverse:    5,
        SkipForward:    6,
        SkipReverse:    7,
        Closed:         8
    }

    var WM6DisplaySize =
    {
        DefaultSize:        0,
        HalfSize:           1,
        DoubleSize:         2,
        FullScreen:         3,
        FitToSize:          4,
        OneSixteenthScreen: 5,
        OneFourthScreen:    6,
        OneHalfScreen:      7
    }
    

function PlayerControlWM64(objEmbeddedPlayer)
{
	this.objEmbedded = objEmbeddedPlayer;
	
	this.GetVersionInfo = function()
	{
		return "6.4.0.0";
	}

	this.Play = function()
	{
		this.objEmbedded.Play();
	}
	
	this.Stop = function()
	{
		this.objEmbedded.Stop();
	}
	
	this.Pause = function()
	{
		this.objEmbedded.Pause();
	}
	
	this.SetLanguage = function(id)
	{
		try
		{
			this.objEmbedded.Language = id;
		}
		catch(ex)
		{
		}
	}
	
	this.ConvertOpenState = function(WM6State)
	{
		// need to translate this state
		
		switch(WM6State)
		{
		        
            case WM6OpenState.LoadingASX:
                return OpenState.PlaylistLoading;
            
            case WM6OpenState.Locating:
                return OpenState.MediaLocating;
                
            case WM6OpenState.Connecting:
                return OpenState.MediaConnecting;
                
            case WM6OpenState.Opening:
                return OpenState.MediaOpening;
                
            case WM6OpenState.Open:
                return OpenState.MediaOpen;
                
            case WM6OpenState.Closed:
            case WM6OpenState.LoadingNSC:
            default:
                return OpenState.Undefined;
		}

	}
	
	this.ConvertPlayState = function(WM6State)
	{
		// need to translate this state
		
		switch(WM6State)
		{
		
		    case WM6PlayState.Stopped:
		        return PlayState.Stopped;
		        
            case WM6PlayState.Paused:
                return PlayState.Paused;
                
            case WM6PlayState.Playing:
                return PlayState.Playing;
            
            case WM6PlayState.ScanForward:
                return PlayState.ScanForward;
                
            case WM6PlayState.ScanReverse:
                return PlayState.ScanReverse;
                
            case WM6PlayState.Waiting:
                return PlayState.Waiting;
                
            case WM6PlayState.SkipForward:
            case WM6PlayState.SkipReverse:
            case WM6PlayState.Closed:
            default:
                return PlayState.Undefined;
            // wm6 doesn't have Buffering,MediaEnded,Transitioning,Ready
		}

	}
	
	
	this.GetPlayState = function()
	{
		// need to translate this state
		
		var WM6State = this.objEmbedded.playState;
		
		return this.ConvertPlayState(WM6State);

	}
	
	this.SetFullScreen = function(f)
	{
		if (f)
		{
			this.objEmbedded.DisplaySize = WM6DisplaySize.FullScreen;
		}
		else
		{
			this.objEmbedded.DisplaySize = WM6DisplaySize.DefaultSize;
		}

	}
	
	this.SetPosition = function(dPosition)
	{
		this.objEmbedded.CurrentPosition=dPosition;
	}

	this.GetPosition = function()
	{
		return this.objEmbedded.CurrentPosition;
	}
	
	this.GetMediaDuration = function()
	{
		return this.objEmbedded.Duration;
	}

	this.SetMedia = function(sMedia)
	{
		this.objEmbedded.Filename = sMedia;
	}
	
	
	this.GetCurrentMarker = function()
	{
		return this.objEmbedded.CurrentMarker;
	}
	
	this.GetMediaMarkerCount = function()
	{
		return this.objEmbedded.MarkerCount;
	}
	
	this.GetMediaMarkerName = function(nIndex)
	{

		return this.objEmbedded.GetMarkerName(nIndex);
	}
	
	this.GetMediaMarkerTime = function(nIndex)
	{
		return this.objEmbedded.GetMarkerTime(nIndex);
	}
	
	this.GetVolume = function()
	{
		// need to translate
		// convert -1700-0 to 0-100
		//
		
		var nVolume = this.objEmbedded.volume;
		
		
		nVolume/=17;
		nVolume+=100;
		
		if (nVolume<0)
		    nVolume=0;
		    
		if (nVolume>100)
		    nVolume=100;

		return nVolume;
	}
	
	this.SetVolume = function(nVolume)
	{
		// need to translate
		// convert 0-100 to -1700-0
		//
		
		    
		if (nVolume<0)
		    nVolume=0;
		if (nVolume>100)
		    nVolume=100;
		    
		nVolume-=100;
		nVolume*=17;
		
		this.objEmbedded.volume=nVolume;
	}
	
	this.SetMute = function(fMute)
	{
		this.objEmbedded.Mute=fMute;
	}
	
	this.GetMute = function()
	{
		return this.objEmbedded.Mute;
	}
	
	this.PlayNormal = function()
	{
		this.objEmbedded.rate = 1;
	}
	
	this.FastForward = function()
	{
		this.objEmbedded.rate = 2;
	}
	
	this.SlowForward = function()
	{
		this.objEmbedded.rate = 0.5;
	}
	
	this.SetInvokeUrls = function(val)
	{
		// not present
	}
}

// ENDFILE PlayerControlWM64.js ---------------------------------------------------------------------->

// BEGINFILE PlayerEventManager.js ------------------------------------------------------------------>

function PlayerEventManager(playerArea)
{
	this.m_debugLevel = SfDebug.Verbose;
//	this.m_debugLevel = SfDebug.Information;
	
	this.lastPlayState = -1;

	// attachevent loses the object information
	// just the method information 
	// therefore "this" is not used in the class
	this.AttachEmbeddedPlayerEvents = function(objPlayer)
	{
		if (document.attachEvent)
		{
 			objPlayer.attachEvent("ScriptCommand", this.OnScriptCommand);
			objPlayer.attachEvent("PlayStateChange", this.OnPlayStateChange);
			objPlayer.attachEvent("PositionChange", this.OnPositionChange);
			objPlayer.attachEvent("OpenStateChange", this.OnOpenStateChange);
		}
		
		var ver = parseInt(PlayerAreaInstance.pci.GetVersionInfo());

		if (ver<7)
		{	
			if (document.attachEvent)
			{
				objPlayer.attachEvent("Buffering", this.OnBuffering);
				objPlayer.attachEvent("NewStream", this.OnNewStream);
				objPlayer.attachEvent("EndOfStream", this.OnEndOfStream);
			}
		}	
	}

	this.OnScriptCommand = function(sType, sParam)
	{
		PlayerAreaInstance.ScriptParser.ParseScriptFromStream(sType, sParam);
	}

	this.OnPlayStateChange = function(newState)
	{
		
		// normal call passes newstate
		// 6.4 passes oldstate newstate null
		// 7  passes newstate null
		PlayerAreaInstance.PlayerEventManager.Debug("OnPlayStatechanged, newState: " + newState);

		if (arguments.length>2)
		{
			newState = arguments[1];

			if (PlayerAreaInstance.pci.ConvertPlayState)
			{
				newState = PlayerAreaInstance.pci.ConvertPlayState(newState);
			}
		}
		
		PlayerAreaInstance.PlayerEventManager.Debug("PlayStateChange New: " + GetPlayStateName(newState) + "("+newState+")");
		PlayerAreaInstance.PlayerEventManager.UpdateLastPlayState(newState);
		PlayerAreaInstance.PlayerEventManager.NotifyPlayStateChange(newState);
	}


	this.OnPositionChange = function(dblOldPosition, dblNewPosition)
	{
		PlayerAreaInstance.PlayerEventManager.Debug("PositionChange Old: " + dblOldPosition + " New: " + dblNewPosition);
		PlayerAreaInstance.PlayerEventManager.NotifyPositionChange(dblOldPosition, dblNewPosition);
	}

	this.OnOpenStateChange = function(openState)
	{
		
		if (PlayerAreaInstance.pci.ConvertOpenState)
		{
			openState = PlayerAreaInstance.pci.ConvertOpenState(openState);
		}

		PlayerAreaInstance.PlayerEventManager.Debug("OpenState " + openState);

	}

	this.OnBuffering = function(bStart)
	{
		PlayerAreaInstance.PlayerEventManager.Debug("Buffering: " + bStart);
	    
		if (bStart)
		{
			if (PlayerAreaInstance.PlayerEventManager.UpdateLastPlayState(PlayState.Buffering))
			{
				PlayerAreaInstance.PlayerEventManager.OnPlayStateChange(PlayState.Buffering);
			}
		}
		else
		{
			if (PlayerAreaInstance.PlayerEventManager.UpdateLastPlayState(PlayState.Playing))
			{
				PlayerAreaInstance.PlayerEventManager.OnPlayStateChange(PlayState.Playing);
			}
		}
	}

	this.OnEndOfStream = function(lResult)
	{
		PlayerAreaInstance.PlayerEventManager.Debug("EndofStream: " + lResult);
	    
		if (PlayerAreaInstance.PlayerEventManager.UpdateLastPlayState(PlayState.MediaEnded))
		{
			PlayerAreaInstance.PlayerEventManager.OnPlayStateChange(PlayState.MediaEnded);
		}
	}

	this.UpdateLastPlayState = function(newState)
	{
		PlayerAreaInstance.PlayerEventManager.Debug("UpdateLastPlayState: last: " + this.lastPlayState + ", new: " + newState);
		if (newState != this.lastPlayState)
		{
			this.lastPlayState = newState;
			return true;
		}
		return false;
	}

	this.OnNewStream = function()
	{
		PlayerAreaInstance.PlayerEventManager.Debug("NewStream ");
		if (PlayerAreaInstance.PlayerEventManager.UpdateLastPlayState(PlayState.Transitioning))
		{
			PlayerAreaInstance.PlayerEventManager.OnPlayStateChange(PlayState.Transitioning);
		}
	}

	// Notification functions	
	this.NotifyPlayStateChange = function(playState)
	{
		argPost = new SfEventArgs();
		
		argPost.PlayState = playState;
		MainHelper.EventPlayerPlayStateChanged.Post(argPost);
	}
	
	this.NotifyPositionChange = function(oldPosition, newPosition)
	{
		argPost = new SfEventArgs();
		
		argPost.OldPosition = oldPosition;
		argPost.NewPosition = newPosition;
		MainHelper.EventPlayerPositionChanged.Post(argPost);
	
	}
	
	this.Debug = function(str)
	{
		SfDebug.DPF(this.m_debugLevel, "PlayerEventManager: " + str);
	}
}

// ENDFILE PlayerEventManager.js -------------------------------------------------------------------->


// BEGINFILE PlayerPositionArea.js ------------------------------------------------------------------>


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

	this.InitializeArea(container, containingWindow, ID);
	this.IsSliding = false;

	this.Debug = function(msg)
	{
		SfDebug.DPF(this.m_debugLevel, "PlayerPositionArea: " + msg);
	}
	
	this.OnLoad = function()
	{
		this.Debug("OnLoad");
		this.Initialize();
		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.SliderNotifyEventHandler = new SfEventHandler("PlayerPositionArea");
		this.SliderNotifyEventHandler.MethodName = "OnSliderNotify";
		this.SliderNotifyEventHandler.Container = this.Container;
		MainHelper.EventSliderNotify.AddHandler(this.SliderNotifyEventHandler);

		this.PlayerTimerUpdatedEventHandler = new SfEventHandler("PlayerPositionArea");
		this.PlayerTimerUpdatedEventHandler.MethodName = "OnPlayerTimerUpdated";
		this.PlayerTimerUpdatedEventHandler.Container = this.Container;
		MainHelper.EventPlayerTimerUpdated.AddHandler(this.PlayerTimerUpdatedEventHandler);
	}
	
	this.RemoveEventHandlers = function()
	{
		this.Debug("RemoveEventHandlers");
		MainHelper.EventPlayerMediaLengthObtained.RemoveHandler(this.MediaLengthObtainedEventHandler);
		MainHelper.EventSliderNotify.RemoveHandler(this.SliderNotifyEventHandler);
		MainHelper.EventPlayerTimerUpdated.RemoveHandler(this.PlayerTimerUpdatedEventHandler);
	}
	
	this.OnMediaLengthObtained = function(range)
	{
		this.Left = range.Left;
		this.Right = range.Right;
	}
	
	this.OnSliderNotify = function(notifyArgs)
	{
		switch(notifyArgs.NotifyType)
		{
			case SfSliderNotifyType.DragPosition:
				this.UpdatePositionStatus(notifyArgs.Position);
				break;
			case SfSliderNotifyType.BeginDrag:
				this.IsSliding = true;
				break;
			case SfSliderNotifyType.EndDrag:
				this.IsSliding = false;
				break;
		}
	}
	
	this.OnPlayerTimerUpdated = function(position)
	{
		if (this.IsSliding == true)
		{
			return;
		}		
		this.UpdatePositionStatus(position); 
	}
	
	this.UpdatePositionStatus = function(position)
	{
		this.MyDiv.innerHTML = this.FormatPosition(position) + "/" + this.FormatPosition(this.Right);
	}
	
	this.FormatPosition = function(pos)
	{
		var tmp = pos;
		var mm = Math.floor(tmp/60);
		var ss = Math.floor(pos-(mm*60));
		
		var sTime = "";
		
		if (mm < 10)
		{
			sTime += "0"+mm;
		}
		else
		{
			sTime += mm;
		}
			
		sTime += ":";
		
		if (ss < 10)
		{
			sTime += "0" + ss;
		}
		else
		{
			sTime += ss;
 		}
			
		return sTime;
	}

	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad");
		this.RemoveEventHandlers();
	}
	
	this.Initialize = function()
	{
		this.Debug("Initialize called");
		this.Left = 0;
		this.Right = 100;
		this.MyDiv = this.GetDiv();
	}
}

// ENDFILE PlayerPositionArea.js -------------------------------------------------------------------->

// BEGINFILE PlayerStatusArea.js -------------------------------------------------------------------->


PlayerStatusArea.prototype = new AreaBase();
function PlayerStatusArea(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, "PlayerStatusArea: " + msg);
	}
	
	this.OnLoad = function()
	{
		this.Debug("OnLoad");
		this.Initialize();
		this.AddEventHandlers();
	}
	
	this.AddEventHandlers = function()
	{
		this.Debug("AddEventHandlers");
		this.PlayerStateChangedEventHandler = new SfEventHandler("PlayerStatusArea");
		this.PlayerStateChangedEventHandler.MethodName = "OnPlayerStateChangedEvent";
		this.PlayerStateChangedEventHandler.Container = this.Container;
		MainHelper.EventPlayerStateChanged.AddHandler(this.PlayerStateChangedEventHandler);
	}
	
	this.RemoveEventHandlers = function()
	{
		this.Debug("RemoveEventHandlers");
		MainHelper.EventPlayerStateChanged.RemoveHandler(this.PlayerStateChangedEventHandler);
	}
	
	this.OnPlayerStateChangedEvent = function(state)
	{
		this.UpdateStatus(state);
	}
	
	this.UpdateStatus = function(status)
	{
		var name = GetPlayStateName(status);
		this.Debug("Changing status to: " + name);
		this.MyDiv.innerHTML = name;
	}
	
	this.OnUnLoad = function()
	{
		this.Debug("OnUnLoad");
		this.RemoveEventHandlers();
	}
	
	this.Initialize = function()
	{
		this.Debug("Initialize called");
		this.Left = 0;
		this.Right = 100;
		this.MyDiv = this.GetDiv();
	}
}

// ENDFILE PlayerStatusArea.js ---------------------------------------------------------------------->

// BEGINFILE Volume.js ------------------------------------------------------------------------------>


function Volume(pci)
{
	this.IsMuted = false;
	this.PreviousVolume = null;
	this.pci = pci;
	this.m_debugLevel = SfDebug.Verbose;
	

	this.InitializeVolume = function()
	{
		var currentVolume = this.GetVolumeFromPlayer();
		var curIdx = Volume.ToIndex(currentVolume);
		
		this.PostVolumeInitializedEvent(currentVolume);
		this.PostVolumeUpDownEvent(curIdx);
	}
		
	this.GetVolumeFromPlayer = function()
	{
	    if (this.pci == null)
	    {
	        return 0;
	    }
	        
	    return this.pci.GetVolume();
	}
	
	
	this.ToggleMute = function()
	{
	    if (this.IsMuted)
	    {
	    	this.pci.SetMute(false);
	    	
	    	if (this.PreviousVolume != null)
			{
				this.pci.SetVolume(this.PreviousVolume);
	        }
	        
	        this.IsMuted = false;
	        this.PostMuteEvent(SfVolumeChangeType.UnMuted);
	    }
	    else
	    {
			this.PreviousVolume = this.pci.GetVolume();
	    	this.pci.SetMute(true);
	        
	        this.IsMuted=true;
	        this.PostMuteEvent(SfVolumeChangeType.Muted);
	    }
	}
	
	this.SetVolume = function(val)
	{
		if (this.IsMuted)
		{
			if (val > 0)
			{
				this.ToggleMute();
			}
		}
		else
		{
			if (val == 0)
			{
				this.ToggleMute();
			}
		}
		
		this.pci.SetVolume(val);
	}
	
	this.ChangeVolume = function(deltaLevel)
	{
		var currentVolume = this.GetVolumeFromPlayer();
		var curIdx = Volume.ToIndex(currentVolume);
		var newVolume = currentVolume + deltaLevel;
		var newIdx = Volume.ToIndex(newVolume);
	
		var fMute=false;
		
		if (this.IsMuted && (deltaLevel>0 ||(curIdx!=0)))
		{
			this.ToggleMute();
		}
		
		this.Debug("Curridx:"+curIdx+" NewIDX:"+newIdx);
		
		if (deltaLevel<0)
		{
			// if we're already minned
			if (curIdx==0)
			{
				return;
			}
			
			if (newIdx==0)
			{
				fMute=true;
			}
		}
		else
		{
			// if we're already maxed out
			if (curIdx>=(Volume.Positions-1))
			{
				return;
			}
		}
		
		currentVolume += deltaLevel;
		
		this.Debug("Setting Volume: "+currentVolume);
		this.pci.SetVolume(currentVolume);
		
		// must mute after setting volume.. WMP won't let you set the volume
		// while it's muted
		if (fMute)
		{
			if (!this.IsMuted)
			{
				this.ToggleMute();
			}
		}
		
		this.PostVolumeUpDownEvent(newIdx);
		
	}
	
	this.PostVolumeInitializedEvent = function(val)
	{
		args = new Object();
		args.Volume = val;
		MainHelper.EventVolumeInitialized.Post(args);
	}
	
	this.PostVolumeUpDownEvent = function(index)
	{
		var args = new VolumeChangedArgs(SfVolumeChangeType.VolumeUpDown);
		args.VolumeIndex = index;
		MainHelper.EventVolumeChanged.Post(args);
	}
		
	this.PostMuteEvent = function(muteType)
	{
		MainHelper.EventVolumeChanged.Post(new VolumeChangedArgs(muteType));
	}
	
	this.Debug = function(msg)
	{
		SfDebug.DPF(this.m_debugLevel, "Volume: " + msg);
	}	
}


function VolConverter(dbLevel, index)
{
	this.Volume = dbLevel;
	this.BarIndex = index;
}


Volume.Positions=18;

Volume.ConverterArray= new Array(Volume.Positions);
Volume.ConverterArray[17]=(new VolConverter(100,17));
Volume.ConverterArray[16]=(new VolConverter(96,16));
Volume.ConverterArray[15]=(new VolConverter(90,15));
Volume.ConverterArray[14]=(new VolConverter(84,14));
Volume.ConverterArray[13]=(new VolConverter(78,13));
Volume.ConverterArray[12]=(new VolConverter(72,12));
Volume.ConverterArray[11]=(new VolConverter(66,11));
Volume.ConverterArray[10]=(new VolConverter(60,10));
Volume.ConverterArray[9]=(new VolConverter(54,9));
Volume.ConverterArray[8]=(new VolConverter(48,8));
Volume.ConverterArray[7]=(new VolConverter(42,7));
Volume.ConverterArray[6]=(new VolConverter(36,6));
Volume.ConverterArray[5]=(new VolConverter(30,5));
Volume.ConverterArray[4]=(new VolConverter(24,4));
Volume.ConverterArray[3]=(new VolConverter(18,3));
Volume.ConverterArray[2]=(new VolConverter(12,2));
Volume.ConverterArray[1]=(new VolConverter(6,1));
Volume.ConverterArray[0]=(new VolConverter(0,0));


Volume.ToIndex=function(lVolume)
{
	var i;
	
	for (i=0; i<Volume.ConverterArray.length; i++)
	{
		if (lVolume<=Volume.ConverterArray[i].Volume)
		{
			return Volume.ConverterArray[i].BarIndex;
		}
	}
	
	return Volume.ConverterArray.length-1;

}

// ENDFILE Volume.js -------------------------------------------------------------------------------->

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

	this.InitializeArea(container, containingWindow, ID);

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

		this.Show();

		this.ToggleA = SfDOM.FindElementFromID(document, this.ID + "Toggle");
		this.CaptioningContainer = SfDOM.FindElementFromID(document, this.ID + "Container");
		this.ToggleA.onclick = new Function("", this.Container + ".ToggleClosedCaptioning();");
	}

	this.ToggleClosedCaptioning = function() 
	{
		this.Debug("ToggleClosedCaptioning()");
		if ( this.IsClosedCaptioningVisible ) 
		{
			this.CaptioningContainer.style.display = 'none';
			this.ToggleA.innerText = this.ShowCaptioningMessage;
			if (PlaybackSpeedAreaInstance)
			{
				PlaybackSpeedAreaInstance.Show();
			}
		} 
		else 
		{
			this.CaptioningContainer.style.display = '';
			this.ToggleA.innerText = this.HideCaptioningMessage;
			if (PlaybackSpeedAreaInstance)
			{
				PlaybackSpeedAreaInstance.Hide();
			}
		}

		this.IsClosedCaptioningVisible = !this.IsClosedCaptioningVisible;
	}

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

// ENDFILE SamiDropDownArea.js ---------------------------------------------------------------------->
// BEGINFILE LanguageDropDownArea.js ---------------------------------------------------------------------->

LanguageDropDownArea.prototype = new AreaBase();
function LanguageDropDownArea(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, "LanguageDropDownArea: " + msg);
	}
	
	this.OnLoad = function()
	{
		if (this.Enabled == false)
		{
			this.Hide();
			return;
		}
		this.Show();

		var template = new MenuTemplate();
		template.CssPrefix = "LanguageSelectionMenu";
		template.LocationInfo = new LocationInfo(0, 0, 80, 19);
		template.SubMenuSizeInfo = new SizeInfo(150, 20);
		template.BaseBorderWidth = 0;
		template.BaseRightDivWidth = 16;
		template.LeftDivWidth = 16;
		var group = new LeafGroup();
		this.BaseMenuItem = new BaseMenuItem(this.Container + ".BaseMenuItem", this.LanguageText, template);
		
		for (var i=0; i<this.LanguageInfos.length; ++i)
		{
			var func = new Function("", "PlayerAreaInstance.SetLanguage(" + this.LanguageInfos[i].Id + ");");
			var leaf = this.BaseMenuItem.AddLeaf(this.LanguageInfos[i].Display, func);
			group.Add(leaf);
		}

		this.BaseMenuItem.CollapseChildrenNow();
		this.GetDiv().appendChild(this.BaseMenuItem.RootDiv);
	}
	
	this.OnUnLoad = function()
	{
	}
}
// ENDFILE LanguageDropDownArea.js ---------------------------------------------------------------------->

// BEGINFILE VolumeSliderArea.js ----------------------------------------------------------------------------->

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

	this.InitializeArea(container, containingWindow, ID);
	
	this.Slider = null;
	
	this.VolumeInitializedEventHandler = 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, "VolumeSliderArea: " + 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);
		this.Slider.OnLoad();
		this.AddEventHandlers();
	}
	
	this.AddEventHandlers = function()
	{
		this.Debug("AddEventHandlers()");

		this.SliderClickEventHandler = new SfEventHandler("VolumeSliderArea");
		this.SliderClickEventHandler.MethodName = "OnSliderClick";
		this.SliderClickEventHandler.Container = this.Container;
		this.Slider.ClickEvent.AddHandler(this.SliderClickEventHandler);

		this.SliderDragEventHandler = new SfEventHandler("VolumeSliderArea");
		this.SliderDragEventHandler.MethodName = "OnSliderDrag";
		this.SliderDragEventHandler.Container = this.Container;
		this.Slider.DragEvent.AddHandler(this.SliderDragEventHandler);
		
		this.VolumeInitializedEventHandler = new SfEventHandler("VolumeInitialized");
		this.VolumeInitializedEventHandler.MethodName = "OnVolumeInitialized";
		this.VolumeInitializedEventHandler.Container = this.Container;
		MainHelper.EventVolumeInitialized.AddHandler(this.VolumeInitializedEventHandler);
	}
	
	this.RemoveEventHandlers = function()
	{
		this.Debug("RemoveEventHandlers()");
		this.Slider.ClickEvent.RemoveHandler(this.SliderClickEventHandler);
		this.Slider.DragEvent.RemoveHandler(this.SliderDragEventHandler);
		MainHelper.EventVolumeInitialized.RemoveHandler(this.VolumeInitializedEventHandler);
	}
	
	this.OnVolumeInitialized = function(args)
	{
		this.Debug("OnVolumeInitialized(): " + args.Volume);
		this.Slider.SetPosition(args.Volume);
	}
	
	this.OnSliderClick = function(args)
	{
		this.Debug("OnSliderClick(): " + args.Position);

		this.Slider.SetPosition(args.Position);
		this.PostSetVolumeCommand(args.Position);
	}
	
	this.OnSliderDrag = function(dragArgs)
	{
		this.Debug("OnSliderDrag(): , type: " +  dragArgs.DragEventType + ", position: " + dragArgs.Position);

		if (dragArgs.DragEventType == SfSliderDragEventType.DragMove)
		{
			this.Slider.SetPosition(dragArgs.Position);
			this.PostSetVolumeCommand(dragArgs.Position);
		}
		else if (dragArgs.DragEventType == SfSliderDragEventType.BeginDrag)
		{
			this.IsCurrentlyDragging = true;
		}
		else if (dragArgs.DragEventType == SfSliderDragEventType.EndDrag)
		{
			this.IsCurrentlyDragging = false;
		}
	}
	
	this.PostSetVolumeCommand = function(vol)
	{
		var args = new CommandArgs(SfCommandType.SetVolume);
		args.Volume = vol;
		MainHelper.EventCommand.Post(args);
	}
}
// ENDFILE VolumeSliderArea.js ------------------------------------------------------------------------------->
// BEGINFILE PlaybackSpeedArea.js ------------------------------------------------------------------------------->
PlaybackSpeedArea.prototype = new AreaBase();
function PlaybackSpeedArea(container, containingWindow, ID)
{
	var m_debugLevel = SfDebug.Verbose;
//	var m_debugLevel = SfDebug.Information;

	this.InitializeArea(container, containingWindow, ID);
	
	var m_slider = null;
	var m_sliderClickEventHandler = null;
	var m_sliderDragEventHandler = null;
	var m_commandEventHandler = null;
	var m_this = this;
	var m_currentPointNumber = 1;
	var m_sliderInitialized = false;

	this.Orientation = SfSliderOrientation.Vertical;// comes from code
	
	var Debug = function(msg)
	{
		SfDebug.DPF(m_debugLevel, "PlaybackSpeedArea: " + msg);
	}
	
	this.OnLoad = function()
	{
		Debug("OnLoad()");
		if (MainHelper.Presentation.Status != PresentationStatus.ReplayReady)
		{
			this.Hide();
			return;
		}
		Initialize();
	}
	
	this.OnUnLoad = function()
	{
		Debug("OnUnLoad()");
		if (m_sliderInitialized == false)
		{
			return;
		}
		
		m_slider.OnUnLoad();
		RemoveEventHandlers();
	}
	
	var Initialize = function()
	{
		m_slider = new SfDiscreteSlider(m_this.ID, m_this.Orientation, 3);
		m_slider.OnLoad();
		m_slider.SetPointNumber(m_currentPointNumber);
		AddEventHandlers();
		
		m_sliderInitialized = true;
	}
	
	var AddEventHandlers = function()
	{
		Debug("AddEventHandlers()");

		m_sliderClickEventHandler = new SfEventHandler("SliderArea");
		m_sliderClickEventHandler.MethodName = "OnSliderClick";
		m_sliderClickEventHandler.Container = m_this.Container;
		m_slider.ClickEvent.AddHandler(m_sliderClickEventHandler);

		m_sliderDragEventHandler = new SfEventHandler("SliderArea");
		m_sliderDragEventHandler.MethodName = "OnSliderDrag";
		m_sliderDragEventHandler.Container = m_this.Container;
		m_slider.DragEvent.AddHandler(m_sliderDragEventHandler);
	
		m_commandEventHandler = new SfEventHandler("PlaybackSpeedArea");
		m_commandEventHandler.MethodName = "OnCommandEvent";
		m_commandEventHandler.Container = m_this.Container;
		MainHelper.EventCommand.AddHandler(m_commandEventHandler);
	}
	
	var RemoveEventHandlers = function()
	{
		Debug("RemoveEventHandlers()");
		m_slider.ClickEvent.RemoveHandler(m_sliderClickEventHandler);
		m_slider.DragEvent.RemoveHandler(m_sliderDragEventHandler);
		MainHelper.EventCommand.RemoveHandler(m_commandEventHandler);
	}
	
	this.OnSliderClick = function(args)
	{
		Debug("OnSliderClick(): " + args.Position);
		ChooseClosestPoint(args.Position);
	}
	
	this.OnSliderDrag = function(dragArgs)
	{
		Debug("OnSliderDrag(): , type: " +  dragArgs.DragEventType + ", position: " + dragArgs.Position);

		if (dragArgs.DragEventType == SfSliderDragEventType.DragMove)
		{
			m_slider.SetPosition(dragArgs.Position);  
		}
		else if (dragArgs.DragEventType == SfSliderDragEventType.BeginDrag)
		{
		}
		else if (dragArgs.DragEventType == SfSliderDragEventType.EndDrag)
		{
			ChooseClosestPoint(dragArgs.Position);
		}
	}

	this.OnCommandEvent = function(args)
	{
		switch(args.Command)
		{
			case SfCommandType.Play:
				if (m_currentPointNumber != 1)
				{
					ChangePlayerSpeed();
				}
				break;
			default:
				return;
		}
	}
	
	var ChooseClosestPoint = function(pos)
	{
		var closestPoint = m_slider.FindClosestPointNumber(pos);
		ChoosePoint(closestPoint);
	}
	
	var ChoosePoint = function(pointNumber)
	{
		m_slider.SetPointNumber(pointNumber);
		if (pointNumber != m_currentPointNumber)
		{
			m_currentPointNumber = pointNumber;
			ChangePlayerSpeed();
		}
	}
	
	var ChangePlayerSpeed = function()
	{
		if (m_currentPointNumber == 0)
		{
			PlayerAreaInstance.pci.SlowForward();
		}
		else if (m_currentPointNumber == 1)
		{
			PlayerAreaInstance.pci.PlayNormal();
		}
		else if (m_currentPointNumber == 2)
		{
			PlayerAreaInstance.pci.FastForward();
		}
	}
}
// ENDFILE PlaybackSpeedArea.js ------------------------------------------------------------------------------->