var nombre_auspicio="normal";
function Verbose(msg)
{
	// Placeholder
}

// ************************************************************************************************
// *** Utility class to read and write cookies
// ************************************************************************************************

// This object manages cookies
function CookieManager(cookieName, expirationDate, domain) {
	// ************************************************************************************************
	// *** Interface
	// ************************************************************************************************	

	// Fields
	// ******
	this.cookieName = cookieName;
	this.expirationDate = expirationDate;
	this.domain = domain;
	
	// Methods
	// *******
	this.getValue = cm_getValue;
	this.setValue = cm_setValue;
	
	// ************************************************************************************************
	// *** Methods
	// ************************************************************************************************	
	
	// Return a cookie value (null if key is not found in the cookie)
	function cm_getValue(key) {
		var i;
		var result;

		result = document.cookie.match(key + '=([^;&]*)'); // value will be in the position 1 (first group)

		return (result != null) ? result[1] : null;
	}
	
	// Set a cookie value (create the key/value pair if it is not found in the cookie)
	function cm_setValue(key, val)
	{
		var result = '';
		var expiration = this.expirationDate == null ? '' : 'expires=' + this.expirationDate.toGMTString() + ';';

		// Read all cookie string (the cookie value will be at array postition 1)
		result = document.cookie.match(this.cookieName + '=([^;]*)');
		if(result == null)
			result = "";
		else
			result = result[1];			

		// if key already exists in the cookie, replace its value
		if(result.indexOf(key) > -1)
			result = result.replace(new RegExp(key + '=[^&]*'), key + '=' + val);
		else // If key does not exist int the cookie, put it
			result += ((result != '') ? '&' : '') + key + '=' + val;
			
		// write the cookie
		document.cookie = this.cookieName + '=' + result + ';domain=' + this.domain + ';path=/;' + expiration;
	}
}
/******************************************************************************
* Global state control 
*******************************************************************************/
var channelID;
var Highlighs;
var pendenceList = new Array();
var backWide;
var total;
var firstSearch = true;

/****************************************************************************
* Cookies
****************************************************************************/
var expirationDate = new Date((new Date()).getTime() + 30*24*60*60*1000); // 30 Days
var cookieManager = new CookieManager("mediacenter_session", null, ckDomain);
var cookieManagerSettings = new CookieManager("mediacenter_settings", expirationDate, ckDomain);

/****************************************************************************
* Related Box
****************************************************************************/
function showBox(id)
{
	var box = document.getElementById("videoBox" + id);
	var header = document.getElementById("videoBoxHeader" + id);
	box.style.display = "";
	header.style.display = "none";
}
function hideBox(id)
{
	var box = document.getElementById("videoBox" + id);
	var header = document.getElementById("videoBoxHeader" + id);
	box.style.display = "none";
	header.style.display = "";
}
/**************************************************************************
* Browsing functions
**************************************************************************/
function UpdateState()
{
	//alert(channelID);
}

function FormatTime(timeString, printHour)
{
	var hour = parseInt(timeString / 3600).toString();
	timeString = timeString % 3600;
	var min = parseInt(timeString / 60).toString();
	timeString = timeString % 60;
	var sec = parseInt(timeString).toString();
	
	if(hour < 10)
	{
		hour = '0' + hour;
	}
	if(min < 10)
	{
		min = '0' + min;
	}
	if(sec < 10)
	{
		sec = '0' + sec;
	}
	
	if(printHour)
	{
		return hour + ":" + min + ":" + sec;
	}
	else
	{
		return min + ":" + sec;
	}
}	

/****************************************************************************
* Comments
****************************************************************************/
function SaveComment(currentContent)
{
	if(logged)
	{
		var commentInput = document.getElementById("txtCommentBody");
		if(commentInput)
		{
			// Checks if the search is within the min/max specified
			var cleanInput = InputCleanup(commentInput.value);
		
			if(inputMin>0 && cleanInput.length<searchMin)
			{
				alert(Translate("INVALID_INPUT"));
				return;
			}

			if(inputMax>0 && cleanInput.length>inputMax)
			{
				alert(Translate("INVALID_INPUT"));
				return;
			}

			var currentContent = 0;
			var currentMedia = playerTerra.getCurrentMedia();
			if(currentMedia) currentContent = currentMedia.id;

			ajaxManager.Add("Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.CommentManager&page=Ajax&p1=SaveComment&p2=" + currentContent + "," + escape(cleanInput), ParseSaveComment, CreateLoading, DestroyLoading, DestroyLoading)
		}
	}
	else
	{
		RunLogged(SaveComment);
	}
}
function ParseSaveComment()
{
	if(this.httpRequest.status == 200)
	{
		alert(this.httpRequest.responseText);
		playlistTerra.drawTab(0);
	}
}

/****************************************************************************
* Send Video
****************************************************************************/
function SendVideo()
{
	var nameInput = document.getElementById("your_name");
	var emailInput = document.getElementById("your_email");
	var fiendInput = document.getElementById("friend_name");
	var fiendMailInput = document.getElementById("friend_email");
	var commentInput = document.getElementById("comment");

	if(nameInput && emailInput && fiendInput && fiendMailInput && commentInput)
	{
		var currentContent = 0;
		var currentMedia = playerTerra.getCurrentMedia();
		if(currentMedia) currentContent = currentMedia.id;
		
		if(currentContent>0)
		{
			var your_name = nameInput.value;
			var your_email = emailInput.value;
			var friend_name = fiendInput.value;
			var friend_email = fiendMailInput.value;
			var comment = commentInput.value;
			
			// Fix to isseu where content after commas was getting "lost" in the post
			comment = new String(comment);
			comment = comment.replace(/,/g,'#comma#');
			comment = escape(comment);
			
			ajaxManager.Add('ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.UserManager&page=ASP.genericAjax_aspx&p1=SendVideoToFriend&p2=' + currentContent + ','+your_name+','+your_email+','+friend_name+','+friend_email+','+comment,ParseSendVideo,null,null,null,null,null); return false
		}
	}
}

function ParseSendVideo()
{
	if(this.httpRequest.status == 200)
	{
		alert(this.httpRequest.responseText);
		playlistTerra.drawTab(0);
	}
}

/***************************************************************************
* Access denied video
***************************************************************************/
function AccessDeniedVideo(video)
{
	// Always use originalid for error messages
	ReloadMyServicesBox(video.originalid);
	//LoadMyServicesAjax("ajax", video.originalid);
}
function ReloadMyServicesBox(contentID)
{
	ajaxManager.Add("Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.MyServicesBoxInternalView&page=Ajax&p1=" + contentID, ParseMyServicesBox, CreateLoading, DestroyLoading, DestroyLoading)
}
function ParseMyServicesBox()
{
	var msBox = document.getElementById("myServicesBox");

	if(this.httpRequest.status == 200 && msBox)
	{
		msBox.innerHTML = this.httpRequest.responseText;
	}
	ShowMyServicesBox();
}
/****************************************************/
/* Function for locating the current mouse position */
/* Must receive an event to work in Mozilla         */
/****************************************************/
var currentMouseX;
var currentMouseY;
function GetMousePosition(e)
{
	var nn6 = document.getElementById && !document.all;
		
	var clientX = document.all ? event.clientX : e.clientX;
	var clientY = document.all ? event.clientY : e.clientY;

	var scrollLeft = nn6 ? window.pageXOffset : document.documentElement.scrollLeft;
	var scrollTop = nn6 ? window.pageYOffset : document.documentElement.scrollTop;

	currentMouseX = clientX + scrollLeft;
	currentMouseY = clientY + scrollTop;
}

/****************************************************
/* Banner Intermediate Function
/***************************************************/
function getAds(adchannel, adtype, adadvertiser, adaction)
{
	if(adchannel && adtype && adadvertiser && adaction)
	{
		if(adchannel!='' && adtype!='' && adadvertiser!='' && adaction!='')
		{
			getAdvertisment(adchannel, adtype, adadvertiser, adaction);
		}
	}
}

/****************************************************
/* Search box
/***************************************************/
function SearchBoxSubmit()
{
	var searchBox = document.getElementById("buscaCampo");
	if(searchBox)
	{
		if(searchBox.value != Translate("SEARCH_FOR_VIDEOS"))
		{
			// Checks if the search is within the min/max specified
			var cleanSearch = SearchCleanup(searchBox.value);
		
			if(searchMin>0 && cleanSearch.length<searchMin)
			{
				alert(Translate("INVALID_SEARCH"));
				return(false);
			}

			if(searchMax>0 && cleanSearch.length>searchMax)
			{
				alert(Translate("INVALID_SEARCH"));
				return(false);
			}

			// Sends the user to the search page
			top.location.href = "searchResult.aspx?keyword=" + escape(cleanSearch);
		}
	}
	return(false);
}
function SearchBoxEnter()
{
	var searchBox = document.getElementById("buscaCampo");
	if(searchBox)
	{
		var searchPhrase = Translate("SEARCH_FOR_VIDEOS");
		if(firstSearch)
		{
			searchBox.value = searchPhrase;
		}else{
			if(searchBox.value.indexOf(searchPhrase) >= 0)
			{
				searchBox.value = searchBox.value.replace(searchPhrase, '');
			}
		}
		firstSearch = false;	
	}
}
function SearchBoxExit()
{
	var searchBox = document.getElementById("buscaCampo");
	if(searchBox)
	{
		if(searchBox.value=='')
		{
			searchBox.value = Translate("SEARCH_FOR_VIDEOS");
		}
	}
}
function SearchBoxKeyDown()
{
	var searchBox = document.getElementById("buscaCampo");
	if(searchBox)
	{
		var searchPhrase = Translate("SEARCH_FOR_VIDEOS");
		if(searchBox.value.indexOf(searchPhrase) >= 0)
		{
			searchBox.value = searchBox.value.replace(searchPhrase, '');
		}
	}
}
/****************************************************
/* Search count
/***************************************************/
function UpdateSearchCount(expression)
{
	var searchCount = document.getElementById('searchCount');
	if(searchCount)
	{
		searchCount.innerHTML = expression;
	}
}
var dictionary = new Array();
function TranslationItem(_key, _value)
{
	this.key = _key;
	this.value = _value;
}
function Translate(key)
{
	for(var i = 0; i < dictionary.length; i++)
	{
		if(key == dictionary[i].key)
		{
			return dictionary[i].value;
		}
	}
	return "";
}

var menuChannels = new Array();
var menuLinks = new Array();
var menuCurrent = 0;
var menuTimer = -1;
var menuDelay = 150;

// Type
// 1 - Channel
// 2 - Link
function showMenu(id,type)
{
	window.clearTimeout(menuTimer);
	menuTimer = window.setTimeout('showMenuTimer(' + id + ',' + type + ')',menuDelay);
}

function showMenuTimer(id,type)
{
	for(var i=0;i<menuChannels.length;i++)
	{
		var menu = document.getElementById('menu_channel_' + menuChannels[i]);
		var sub = document.getElementById('sub_channel_' + menuChannels[i]);
		
		if(menu)
		{
			if(menuChannels[i]==id && type==1)
			{
				if((menuChannels[i]==12 || menuChannels[i]==13) && type==1)
				{menu.className = 'selected2';}
				else{menu.className = 'selected';}
				
			}
			else
			{
				if(menuChannels[i]==12 || menuChannels[i]==13)
				{menu.className = 'menu2';}
				else
				{menu.className = 'menu';}
				
			}
		}
		
		if(sub)
		{
			if(menuChannels[i]==id && type==1)
			{
				sub.style.visibility = 'visible';
			}
			else
			{
				sub.style.visibility = 'hidden';
			}
		}
	}
	
	for(var i=0;i<menuLinks.length;i++)
	{
		var menu = document.getElementById('menu_link_' + menuLinks[i]);
		if(menu)
		{
			if(menuLinks[i]==id && type==2)
			{
				menu.className = 'selected';
			}
			else
			{
				menu.className = '';
			}
		}
	}
}

function showMenuDefault()
{
	showMenu(menuCurrent,1);
}

function showHidden(channel)
{
	var listMenu = document.getElementById("sub_channel_" + channel);
	if(listMenu)
	{
		for(var i = 0; i < listMenu.childNodes.length; i++)
		{
			var child = listMenu.childNodes[i];
			if(child.innerHTML)
			{
				if(child.className.indexOf('itemSelected')<0 && child.className.indexOf('switcher')<0)
				{
					// Swaps items with sub_hidden and items without
					var pos = child.className.indexOf('sub_hidden');
					if(pos>=0)
					{
						var regex = new RegExp("\\bsub_hidden\\b","ig")
						child.className = child.className.replace(regex,'');
					}
					else
					{
						child.className = 'sub_hidden ' + child.className;
					}
				}
			}
		}
	}
}

function showBoxSubMenu(id, obj)
{
	var sub = document.getElementById('browsebox_channel_' + id);
	if (sub != null)
	{
		if (sub.className=="none")
		{
			sub.className = "";
			obj.className = "subMenuOn";
		}
		else
		{
			sub.className = "none";
			obj.className = "subMenu";
		}
	}
}

function showHideBoxSubmenu(obj)
{
	var li = obj.parentNode;
	
	for (var i=0;i<li.childNodes.length;i++)
	{
		if (li.childNodes[i].nodeName == "UL")
		{
			var ul = li.childNodes[i];
			if (ul.className == "none")
			{
				ul.className = "block";
			}
			else
			{
				ul.className = "none";
			}
		}
		if (li.childNodes[i].className == "subMenu" || li.childNodes[i].className == "subMenuOn")
		{
			var a = li.childNodes[i];
			if (a.className == "subMenu")
			{
				a.className = "subMenuOn";
			}
			else
			{
				a.className = "subMenu";
			}
		}
	}
}

function updatePage(newTitle,channelId, obj)
{
	var oldTitle = document.getElementById('changeTitle');
	
	oldTitle.innerHTML = newTitle;
	
	cleanChecked();
	
	obj.className = "selected";
	
	checkBrowseBox(obj);
}

function checkBrowseBox(obj)
{
	var a = obj;
	
	var parentN = a.parentNode.parentNode.parentNode;
	
	if (parentN.className != "browsebox_subMenu")
	{
		for (var i =0; i < parentN.childNodes.length; i++)
		{
			if (parentN.childNodes[i].nodeName == "A" && parentN.childNodes[i].className != "subMenuOn")
			{
				parentN.childNodes[i].className = "selected";
			}
		}
	}
}

function cleanChecked()
{	
	//This function is used to check the first level then call the
	//cleanSubChannels to clean the rest of the levels
	var obj = document.getElementById("browseBox");

	for (var i =0; i < obj.childNodes.length; i++)
	{
		if (obj.childNodes[i].className == "browsebox_subMenu" && obj.childNodes[i].nodeName == "LI")
		{
			var sonObj = obj.childNodes[i];
			
			for (var j = 0; j < sonObj.childNodes.length; j++)
			{
				if (sonObj.childNodes[j].nodeName == "UL")
				{
					var ul = sonObj.childNodes[j];
					cleanSubChannels(ul);
				}
			}
		}	
	}
}

function cleanSubChannels(obj)
{
	for (var i =0; i < obj.childNodes.length; i++)
	{
		if (obj.childNodes[i].nodeName == "LI")
		{
			var sonObj = obj.childNodes[i];
			
			for (var j = 0; j < sonObj.childNodes.length; j++)
			{
				if (sonObj.childNodes[j].nodeName == "A" && sonObj.childNodes[j].className != "subMenuOn" && sonObj.childNodes[j].className != "subMenu")
				{
					sonObj.childNodes[j].className = "";
				}
				if (sonObj.childNodes[j].nodeName == "UL")
				{
					var ul = sonObj.childNodes[j];
					cleanSubChannels(ul);
				}
			}
		}
	}
}

CheckInitializeEnvents();
function CheckInitializeEnvents()
{
	try
	{
		if(document.body)
		{
			InitializeEvents();
			return;
		}
	}
	catch(e){}
	
	setTimeout("CheckInitializeEnvents()", 500);
}

var defaultPageLoadExecuted = false;
function DefaultPageLoad()
{
	// Makes sure this is never run more than once
	if(defaultPageLoadExecuted)
	{
		return;
	}
	else
	{
		defaultPageLoadExecuted = true;
	}

	var searchBox = document.getElementById("buscaCampo");
	if(searchBox)
	{
		searchBox.focus();
	}

	// Only load playlist from here if there's no player in the page
	// Otherwise it'll be loaded from the player initialization
	if(!containsPlayer)
	{
		LoadPlaylistFromCookie();
	}
	
	// Loads the default banner
	DefaultBannerLoad()
}

function DefaultBannerLoad()
{
	var bannerDiv = document.getElementById("publicidade");
	if(bannerDiv)
	{
		Verbose('Banner DIV found, calling script');
		if(bannerScript)
		{
			eval(bannerScript);
		}
	}
	else
	{
		Verbose('Banner DIV not found, DefaultBannerLoad delayed');
		window.setTimeout('DefaultBannerLoad()',100);
	}
}
/******************************************************************************
* Login
*******************************************************************************/
var clearPendences = false;

function ProcessLogin()
{
	logged = true;
	HideLoginBox();
	LoadMyServicesAjax("ajax", 0);
	SendPendences();
	CallPendencesMethods();
	LoadMenuInst("ajax", false);
}
function Logout()
{
	var saveCheck = document.getElementById("savePlaylist");
	ProcessLogout(saveCheck.checked);
}
function ProcessLogout(save)
{
	var logoutUrl = homeUrl + '&logout=1';
	if(save) logoutUrl += '&save=1';
	top.location.href = logoutUrl;
}
function CallPendencesMethods()
{
	for(var i = 0; i < pendenceList.length; i++)
	{
		pendenceList[i]();
	}
}
function SendPendences()
{
	clearPendences = true;
	
	if(privateList.length > 0)
	{
		Add(privateList, privateList[0].mediaType, privateList[0].channel, privateList[0].autoPlay);
	}
}
function ShowLoginBox()
{	
	var loginBox = document.getElementById("loginBox");
	
	if(loginBox)
	{
		if(playerTerra && playerTerra.getCurrentInternalMedia() && playerTerra.getCurrentInternalMedia().isWide && enableUpdateSize)
		{
			loginBox.className = "log wideLog";
		}
		else
		{
			loginBox.className = "log";
		}
		
		loginBox.style.visibility = "visible";
		window.scroll(0,0);
		
		var user = document.getElementById("user");
		if(user)
		{
			user.focus();
		}
	}
	ResizeBanner();
}
function UserHideLoginBox()
{
	privateList = new Array();
	HideLoginBox();
}
function HideLoginBox()
{
	var loginBox = document.getElementById("loginBox");
	
	if(loginBox)
	{
		loginBox.style.visibility = "hidden";
	}
}
function ShowLogoutBox()
{	
	var logoutBox = document.getElementById("logoutBox");
	//var loginButton = document.getElementById("loginButton");
	
	if(logoutBox)
	{
		if(playerTerra && playerTerra.getCurrentInternalMedia() && playerTerra.getCurrentInternalMedia().isWide && enableUpdateSize)
		{
			logoutBox.className = "log out wideLog";
		}
		else
		{
			logoutBox.className = "log out";
		}

		logoutBox.style.visibility = "visible";
		window.scroll(0,0);
	}
	ResizeBanner();
}
function HideLogoutBox()
{
	var logoutBox = document.getElementById("logoutBox");

	if(logoutBox)
	{
		logoutBox.style.visibility = "hidden";
	}
}
function ClearMyServicesBox()
{
	var myServicesBox = document.getElementById("myServicesBox");
	
	if(myServicesBox)
	{
		myServicesBox.innerHTML = '';
	}
}
function ShowMyServicesBox()
{	
	var myServicesBox = document.getElementById("myServicesBox");
	var myServicesButton = document.getElementById("myServicesButton");
	
	if(myServicesBox)
	{
		if(playerTerra && playerTerra.getCurrentInternalMedia() && playerTerra.getCurrentInternalMedia().isWide && enableUpdateSize)
		{
			myServicesBox.className = "log servicos wideLog";
		}
		else
		{
			myServicesBox.className = "log servicos";
		}
	
		myServicesBox.style.visibility = "visible";
		if(myServicesButton)
		{
			myServicesButton.className = "select";
		}
	}
	ResizeBanner();
}
function HideMyServicesBox()
{
	var myServicesBox = document.getElementById("myServicesBox");
	var myServicesButton = document.getElementById("myServicesButton");
	
	if(myServicesBox)
	{
		myServicesBox.style.visibility = "hidden";
		
		if(myServicesButton)
		{
			myServicesButton.className = "";
		}
	}
	CheckWide();
}
function CheckWide()
{
	if(playerTerra && backWide)
	{
		playerTerra.set169();
	}
}
function RunLogged(func)
{
	if(logged)
	{
		func();
	}
	else
	{
		pendenceList.push(func);
		ShowLoginBox();
	}
}
function PostLogin()
{
	var user = document.getElementById("user");
	var pw = document.getElementById("password");
	
	if(user && pw)
	{
		PostLoginAjax("ajax", 2, user.value + "," + pw.value);
	}
}
function ParseLogin()
{
	if(this.httpRequest.status == 200)
	{
		if(this.httpRequest.responseText == "true")
		{
			ProcessLogin();
		}
		else
		{
			alert(Translate("INVALID_LOGIN"));
		}
	}
}
/****************************************************************************
* General
*****************************************************************************/
var currentPlaylist = 0;
var currentPlaylistName = "";

function ResetPlaylist()
{
	cookieManager.setValue("playlist", "");
}

/****************************************************************************
* Playlist Tabs
*****************************************************************************/
var playlistTab;
function DrawPlaylistTab(index)
{
	if(document.getElementById("playlistContent"))
	{
		playlistTab = index;
		switch(index)
		{
			case 0:
				playlistTerra.drawTab(2);
				break;
			case 1:
				getAjaxContentNoCache('playlistContent','Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.OtherPlaylistsView&page=genericAjax_aspx',true, null);
				break;
			case 2:
				getAjaxContentNoCache('playlistContent','Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.SendPlaylistsView&page=genericAjax_aspx&p2=' + currentPlaylist ,true, null);
				break;
			case 3:
				getAjaxContentNoCache('playlistContent','Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.SavePlaylistView&page=genericAjax_aspx&p2=' + currentPlaylist ,true, null);
				break;
			case 4:
				break;
		}
	}
}

/****************************************************************************
* Load Playlist
*****************************************************************************/
function LoadPlaylist(id, mediaType, channel, name)
{
	if(!playerTerra)
	{
		setTimeout("LoadPlaylist(" + id + ", " + mediaType + ", " + channel + ", '" + name + "')", 500);
	}
	else
	{
		LoadPlaylistThread(id, mediaType, channel, name);
	}
}
function LoadPlaylistThread(id, mediaType, channel, name)
{	
	startPlayback = -2;
	cookieManager.setValue("playlist", "");
	currentPlaylist = id;
	currentPlaylistName = name;
	playlistTerra.clear();
	playlistTerra.drawTab(2);
	Add(id, mediaType, channel, -2);
}

/****************************************************************************
* Send Playlist
*****************************************************************************/
function SendPlaylist(id)
{
	var name = document.getElementById("txtTo").value;
	var email = document.getElementById("txtEmail").value;
	var comment = document.getElementById("txtComment").value;
	
	if(name != "")
	{
		if(email != "")
		{
			if(currentPlaylist > 0)
			{
				ajaxManager.Add("Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.UserPlaylistManager&page=Home_aspx&p1=Send&p2=" + id + "," + name + "," + email + "," + comment, ParseSend, CreateLoading, DestroyLoading, DestroyLoading)
			}
		}
		else
		{
			alert("Preencha o campo \"" + document.getElementById("lblEmail").innerHTML + "\" ");
		}
	}
	else
	{
		alert("Preencha o campo \"" + document.getElementById("lblTo").innerHTML + "\" ");
	}
}
function ParseSend()
{
	if(this.httpRequest.status == 200)
	{
		alert(this.httpRequest.responseText);
		
		if(this.httpRequest.responseText == Translate("PLAYLIST_SEND_SUCESSES"))
		{
			DrawPlaylistTab(0);
		}
	}
}
/****************************************************************************
* Edit Playlist
*****************************************************************************/
function EditPlaylist(id, name)
{
	currentPlaylist = id;
	DrawPlaylistTab(3);
}

/****************************************************************************
* Delete Playlist
*****************************************************************************/
function DeletePlaylist(id)
{
	if(confirm(Translate("CONFIRM_PLAYLIST_DELETE")))
	{
		ajaxManager.Add("Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.UserPlaylistManager&page=Home_aspx&p1=Delete&p2=" + id, ParseDelete, CreateLoading, DestroyLoading, DestroyLoading)
	}
}
function ParseDelete()
{
	if(this.httpRequest.status == 200)
	{
		if(this.httpRequest.responseText == "success")
		{
			alert(Translate("PLAYLIST_DELETE_SUCESSES"));
		}
		else
		{
			alert(Translate("PLAYLIST_DELETE_ERROR"));
		}
		DrawPlaylistTab(1);
	}
}
/****************************************************************************
* Save Playlist
*****************************************************************************/
function SavePlaylist(id)
{
	var name = document.getElementById("txtName").value;
	var duration = playlistTerra.getDuration();
	var items = cookieManager.getValue("playlist").replace(/,/g, '@');
	
	if(name.length > 0 && (items.length > 0 || id > 0))
	{
		ajaxManager.Add("Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.UserPlaylistManager&page=Home_aspx&p1=Save&p2=" + name + "," + duration + "," + items + "," + id, ParseSave, CreateLoading, DestroyLoading, DestroyLoading)
	}
	else
	{
		alert("Não é possível salvar uma playlist vazia");
	}
}
function ParseSave()
{
	if(this.httpRequest.status == 200)
	{
		var pl = parseInt(this.httpRequest.responseText, 10);
		if(this.httpRequest.responseText != "error" && pl > 0)
		{
			alert(Translate("PLAYLIST_SAVE_SUCESSES"));
			currentPlaylist = pl;
		}
		else
		{
			alert(Translate("PLAYLIST_SAVE_ERROR"));
		}
		DrawPlaylistTab(1);
	}
}
/****************************************************************************
* Clear Playlist
*****************************************************************************/
function ClearPlaylist()
{
	playerTerra.stop();
	playlistTerra.clear();
	playlistTerra.syncCookie();
	DrawPlaylist();
}

/***************************************************************************
* Shuffle
***************************************************************************/
function Shuffle()
{
	playerTerra.setShuffle(!playerTerra.getShuffle());
	
	var btnShuffle = document.getElementById("btnShuffle");
	if(btnShuffle)
	{
		btnShuffle.className = playerTerra.getShuffle() ?  "active" : "";
	}
}
/***************************************************************************
* Repeat
***************************************************************************/
function Repeat()
{
	playerTerra.setRepeat(!playerTerra.getRepeat());
	
	var btnRepeat = document.getElementById("btnRepeat");
	if(btnRepeat)
	{
		btnRepeat.className = playerTerra.getRepeat() ?  "active" : "";
	}
}

/***************************************************************************
* Notifier
***************************************************************************/
function DrawNotifier()
{
	var notifierText = document.getElementById("notifierText");
	var notifier = document.getElementById("notifier");
	
	if(notifier && notifierText)
	{
		if(notifierText)
		{
			notifierText.innerHTML = Translate("PLAYLIST") + " (" + playlistTerra.getCount() + ")";
		}
		notifier.className = playlistTerra.getCount() > 0 ? "" : "empty";
	}
}
function PlayFromNotifier()
{
	if(playlistTerra.getCount() > 0)
	{
		var playerArea = document.getElementById("playerContent");
		
		if(playerArea && playerArea.className.lenght > 0)
		{
			playerTerra.playItem(0);
		}
		else
		{
			document.location.href = "channelContents.aspx?play=-1&channel=" + playlistTerra.getItem(0).channel;			
		}
	}
}
// ************************************************************************************************
// *** Drag & Drop (slider component)
// ************************************************************************************************

var ddItems = new Array();
var dragObj;
var ddX, ddY;
var nn6 = document.getElementById && !document.all;

// Must be called in "document.onmousedown"
function dd_InitDrag(e) {
	var obj = nn6 ? e.target : event.srcElement;
	var i;
	// Check if the target element is registered for drag & drop
	for(i = 0; i < ddItems.length; i++) {
		if(ddItems[i].obj.id == obj.id) {
			dragObj = ddItems[i];
			dragObj.isDragging = true;
			iniWidth = parseInt(dragObj.resizeObj.style.width);
			iniHeight = parseInt(dragObj.resizeObj.height);
			ddX = nn6 ? e.clientX : event.clientX;
			ddY = nn6 ? e.clientY : event.clientY;
			document.onmousemove = dd_MouseMove;
			
			break;
		}
	}
}

// Called in "document.onmousemove"
function dd_MouseMove(e) {
	var dragDirection = new DragDirection();
	var newPos;
	
	if(dragObj != null && dragObj.isDragging) {
		if(document.all)
			document.selection.empty();
		
		// Horizontal
		if((dragDirection.horizontal & dragObj.dragDirection) != 0) {			
			newPos = iniWidth + ((nn6 ? e.clientX : event.clientX) - ddX);

			if(newPos > dragObj.min && newPos <= dragObj.max)
				dragObj.resizeObj.style.width = newPos + 'px';
		}
			
		// Vertical
		if((dragDirection.vertical & dragObj.dragDirection) != 0) {
			newPos = iniHeight + ((nn6 ? e.clientY : event.clientY) - ddY);
			
			if(newPos > dragObj.min && newPos <= dragObj.max)
				dragObj.resizeObj.style.height = newPos + 'px';
		}
		
		// Tell to drag item that it is being dragged
		dragObj.dragged();
	}

	return(false);
}

// Called in "document.onmouseup"
function dd_FinishDrag(e) {
	document.onmousemove = null;	
	
	// Alert the drag item that its dragging is finished
	if(dragObj != null) {
		dragObj.isDragging = false;
		dragObj.dragFinished();
	}
		
	dragObj = null;
}

document.onmousedown = dd_InitDrag;
document.onmouseup = dd_FinishDrag;
// ************************************************************************************************
// *** Represents a drag item
// ************************************************************************************************

// Constructor
function DragItem(obj, resizeObj, min, max, direction) {
	// ************************************************************************************************
	// *** Interface
	// ************************************************************************************************

	// Fields
	// ******
	this.min = min;
	this.max = max;
	this.obj = obj;
	this.resizeObj = resizeObj;
	this.dragDirection = direction;
	this.isDragging = false;
	
	// Methods
	// *******
	this.dragged = di_Dragged;
	this.dragFinished = di_DragFinished;
	this.getValue = di_getValue;
	this.setValue = di_setValue;
	
	// Events
	// ******
	this.onDrag = new EventManager();
	this.onDragFinish = new EventManager();
	
	// ************************************************************************************************
	// *** Implementation
	// ************************************************************************************************
	
	// Called when the item is being dragged
	function di_Dragged() {
		this.onDrag.exec();
	}
	
	// Called when the drag finishes
	function di_DragFinished() {
		this.onDragFinish.exec();
	}
	
	// Returns a value between 0 and 1 that represents the position of the drag & drop item
	function di_getValue()
	{
		if(this.resizeObj)
		{
			return parseInt(this.resizeObj.style.width) / this.max;
		}
		return 0;
	}
	
	// Receive a value between 0 and 1 that represents the position of the drag & drop item
	function di_setValue(val)
	{
		if(this.resizeObj)
		{
			this.resizeObj.style.width = (parseInt(val * this.max)) + 'px';
		}
	}
}

// Drag direction constants
function DragDirection() {
	this.vertical = 1;
	this.horizontal = 2;
}
// ************************************************************
// Helpers for Ajax Creation/
// ************************************************************
function AjaxTools()
{
	this.CreateXmlHttpRequest = ajaxTools_CreateXmlHttpRequest;
	this.CreateXmlDocument = ajaxTools_CreateXmlDocument;
	this.CreateXmlDocumentFromUrl = ajaxTools_CreateXmlDocumentFromUrl;
	this.CreateXmlDocumentFromContent = ajaxTools_CreateXmlDocumentFromContent;
	this.ApplyTransform = ajaxTools_ApplyTransform;
	this.GetNodeValue2 = ajaxTools_GetNodeValue2;
	this.SetNodeValue2 = ajaxTools_SetNodeValue2;
	this.SelectNodes2 = ajaxTools_SelectNodes2;
	this.SelectSingleNode2 = ajaxTools_SelectSingleNode2;

	// Required for mozilla
	this.NsResolver = ajaxTools_NsResolver;

	// Backwards-compatibility methods
	this.GetNodeValue = ajaxTools_GetNodeValue;
	this.SetNodeValue = ajaxTools_SetNodeValue;
	this.GetFirstNode = ajaxTools_GetFirstNode;
	this.SelectNodes = ajaxTools_SelectNodes;
	this.SelectSingleNode = ajaxTools_SelectSingleNode;

	this.isMozilla = (typeof document.implementation != 'undefined') && 
	                (typeof document.implementation.createDocument != 'undefined');

	// Checks if a context node was specified,
	// if not used the document itself as a context node
	function GetContextNode(doc, node)
	{
		if(node) return(node);
		return(doc);
	}

	// Creation of HTTP Request 
	function ajaxTools_CreateXmlHttpRequest() 
	{
		if(this.isMozilla)
		{
			return(new XMLHttpRequest());
		}
		else
		{
			return(new ActiveXObject("Msxml2.XMLHTTP"));
		}
	}
	
	// Creation of XML Document
	function ajaxTools_CreateXmlDocument()
	{
		if(this.isMozilla)
		{
			return(document.implementation.createDocument("", "doc", null));	
		}
		else
		{
			return(new ActiveXObject("Msxml2.DomDocument"));	
		}	
	}
	
	// Creation of XML Document from a specified URL
	function ajaxTools_CreateXmlDocumentFromUrl(url)
	{
		var xmlDoc = this.CreateXmlDocument();
		xmlDoc.async = false;
		xmlDoc.load(url);
		return(xmlDoc);
	}
	
	// Creation of XML Document from a specified URL
	function ajaxTools_CreateXmlDocumentFromContent(content)
	{
		var xmlDoc = this.CreateXmlDocument();
		
		if(this.isMozilla)
		{
			var parser = new DOMParser();
			var xmlDoc = parser.parseFromString(content, 'application/xml');
			return(xmlDoc);
		}
		else
		{
			var xmlDoc = new ActiveXObject("Msxml2.DomDocument");
			xmlDoc.loadXML(content);
			return(xmlDoc);
		}
	}
	
	// Apply a XSLT transformation to a page and retrieves the processed text context
	function ajaxTools_ApplyTransform(doc, transform)
	{
		if(this.isMozilla)
		{
			var processor = new XSLTProcessor();
			processor.importStylesheet(transform);
			
			var transformedDoc = processor.transformToDocument(doc);
			
			var serializer = new XMLSerializer();
			return(serializer.serializeToString(transformedDoc));
		}
		else
		{
			return(doc.transformNode(transform));	
		}
	}	
	
	// Required for the mozilla "evaluate" method	
	function ajaxTools_NsResolver(prefix) 
	{
		if(prefix == 'xsl') 
		{
			return 'http://www.w3.org/1999/XSL/Transform';
		}
		return null;
	}
	
	// Gets the value of the xml node
	function ajaxTools_GetNodeValue2(doc, path, node)
	{
		var node = this.SelectSingleNode2(doc,path,node);
		if(node)
		{
			if(node.nodeValue)
			{
				return(node.nodeValue);
			}		
		}
		return('');
	}

	// Sets the value of a xml node
	function ajaxTools_SetNodeValue2(doc, path, value, node)
	{
		this.SelectSingleNode2(doc,path,node).nodeValue = value;
	}
	
	// Retrieves a single of xml node
	function ajaxTools_SelectSingleNode2(doc, path, node)
	{
		if(this.isMozilla)
		{
			return(doc.evaluate(path, GetContextNode(doc,node), this.NsResolver, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue);
		}
		else
		{
			return(GetContextNode(doc,node).selectSingleNode(path));
		}
	}
	
	// Retrieves a collection fo xml nodes
	function ajaxTools_SelectNodes2(doc, path, node)
	{
		var ret = new Array();
		if(this.isMozilla)
		{
			var nodeList = doc.evaluate(path, GetContextNode(doc,node), this.NsResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
			for(var i=0; i < nodeList.snapshotLength; i++)
			{ 
				ret[i] = nodeList.snapshotItem(i);
			}
			return(ret);
		}
		else
		{
			var obj = GetContextNode(doc,node).selectNodes(path);
			for(var i=0;i<obj.length;i++)
			{
				ret[i] = obj(i);
			}
			return(ret);
		}
	}

	// ************************************************************
	// Backwards-compatibility methods
	// ************************************************************	

	// Gets the value of the xml node
	function ajaxTools_GetNodeValue(node)
	{
		if(node)
		{
			if(node.firstChild)
			{
				return(node.firstChild.nodeValue);
			}
		}
		return('');
	}
	
	// Sets the value of the xml node
	function ajaxTools_SetNodeValue(node, value)
	{
		if(node)
		{
			if(node.firstChild)
			{
				node.firstChild.nodeValue = value;
			}
		}
	}
	
	// Gets the first node from a xml
	function ajaxTools_GetFirstNode(node, path)
	{
		var nodeList = node.getElementsByTagName(path);
		
		if(nodeList.length > 0)
		{
			return(nodeList[0]);
		}
		
		return(null);
	}

	// Gets a list of nodes with the required tag name (only searches direcly below the current node)
	function ajaxTools_SelectNodes(node, tagname)
	{
		var ret = new Array();
		if(node!=null)
		{
			if(node.childNodes!=null)
			{
				for(var i=0;i<node.childNodes.length;i++)
				{
					if(node.childNodes[i].tagName==tagname) ret[ret.length] = node.childNodes[i];
				}
			}
		}
		return(ret);
	}

	// Gets the first node with the required tag name (only searches direcly below the current node)
	function ajaxTools_SelectSingleNode(node, tagname)
	{
		if(node!=null)
		{
			if(node.childNodes!=null)
			{
				for(var i=0;i<node.childNodes.length;i++)
				{
					if(node.childNodes[i].tagName==tagname) return(node.childNodes[i]);
				}
			}
		}
		return(null);
	}
}
// ************************************************************
// Individual Ajax Item 
// ************************************************************
function AjaxItem(parentName, position, url, parseMethod, requestBegin, requestEnd, requestError, parameters, post)
{
	// Tools for XML parsing
	this.tools = new AjaxTools();
	
	// Properties	
	this.httpRequest = null;
	this.url = url;
	this.parentName = parentName;
	this.position = position;
	this.parameters = parameters;

	// User-created Methods
	this.Parse = parseMethod;
	this.RequestBegin = requestBegin;
	this.RequestEnd = requestEnd;
	this.RequestError = requestError;
	this.PostData = post;

	// Predefined Methods
	this.Load = ajaxItem_Load;
	
	function ajaxItem_Load()
	{
		this.httpRequest = this.tools.CreateXmlHttpRequest();

		if(this.httpRequest)
		{
			try
			{
				if(this.RequestBegin)
				{
					this.RequestBegin();
				}
				
				if(post)
				{
					this.httpRequest.open('POST', this.url, true);
					this.httpRequest.setRequestHeader('Content-Type','application/x-www-form-urlencoded');
					
					this.httpRequest.onreadystatechange = new Function(parentName + '.PreParse(' + this.position + ');');
					this.httpRequest.send(post);
				}
				else
				{
					this.httpRequest.onreadystatechange = new Function(parentName + '.PreParse(' + this.position + ');');
					this.httpRequest.open('GET',this.url);
					this.httpRequest.send(null);
				}
			}
			catch(e)
			{
				if(this.RequestError)
				{
					this.RequestError();
				}
					
				alert('Could not open URL');
				alert(e);
			}
		}
		else
		{
			if(this.RequestError)
			{
				this.RequestError();
			}
				
			alert('XmlHttpRequest object could not be loaded');
		}
	}
}

// ************************************************************
// Ajax Manager Object
// ************************************************************
function AjaxManager(objectName, usecache)
{
	this.name = objectName;

	// Properties
	this.items = new Array();
	this.usecache = usecache;
	
	// Methods
	this.Add = ajaxManager_Add;
	this.PreParse = ajaxManager_PreParse;
	
	function ajaxManager_Add(url, parseMethod, requestBegin, requestEnd, requestError, parameters, post)
	{
		// If client-side caching was enabled for this manager
		if(this.usecache)
		{
			// Looks at the items, and sees if we have one with the same URL
			for(var i = 0 ;i < this.items.length; i++)
			{
				// Found a cached item
				if(this.items[i].url == url && (this.items[i].PostData == post || !this.items[i].PostData))
				{
					if(this.items[i].RequestBegin)
						this.items[i].RequestBegin();
					
					// Creates a parsecache method
					this.items[i].ParseCache = parseMethod;
					
					// Runs the parser
					this.items[i].ParseCache();
					
					if(this.items[i].RequestEnd)
						this.items[i].RequestEnd();

					// Ends the request					
					return;
				}
			}
		}
		
		// Creates a new ajax item
		var newItem = new AjaxItem(this.name, this.items.length, url, parseMethod, requestBegin,
									requestEnd, requestError, parameters, post);
		
		// Adds it to the storage
		this.items[this.items.length] = newItem;

		// Starts the Ajax process
		newItem.Load();

	}

	function ajaxManager_PreParse(pos)
	{
		if (this.items[pos].httpRequest.readyState == 4) // readyState = 4 -> Complete
		{
			this.items[pos].Parse();
			
			if(this.items[pos].RequestEnd != null)
			{
				this.items[pos].RequestEnd();
			}
		}
	}
}
// ************************************************************
// Ajax Manager Object
// ************************************************************
function AjaxManagerGeneric(objName, usecache)
{
	//Properties
	this.manager = new AjaxManager(objName + ".manager", usecache);
	
	//Methods
	this.Add = _AjaxManagerGeneric_Add;
	this.AddDefault = _AjaxManagerGeneric_AddDefault;
	
	function _AjaxManagerGeneric_AddDefault(url, divId, notify, post, trigger)
	{
		if(notify)
		{
			this.manager.Add(url, DefaultParser, CreateLoading, EvalHtmlJavaScript, DestroyLoading, divId, post);
		}
		else
		{
			this.manager.Add(url, DefaultParser, null, EvalHtmlJavaScript, null, divId, post);
		}
		this.Trigger = trigger;
	}
	
	function _AjaxManagerGeneric_Add(url, parseMethod, requestBegin, requestEnd, requestError, trigger)
	{
		this.manager.Add(url, parseMethod, requestBegin, requestEnd, requestError);
		this.Trigger = trigger;
	}
}
/* -------------------------------------------------------------
/ Evaluate JavaScript
/ -------------------------------------------------------------*/
function EvalHtmlJavaScript()
{
	//s&oacute; para n&atilde;o dar pau. est&aacute; incorreto
	if(this.RequestError)
	{
		DestroyLoading();
	}
	
	var html = this.httpRequest.responseText;

	var regex = new RegExp("<script[^>]*>[^/]*//VIEW SCRIPT[^<]*</script>");

	if(html.match(regex) != null)
	{
		var result = html.match(regex)[0].toString();
		if (result != null)
		{
			result = result.replace(/<script[^>]*>/, "").replace("</script>", "");
			eval(result);
		}
	}
}

/* -------------------------------------------------------------
/ Default parser
/ -------------------------------------------------------------*/
/* -------------------------------------------------------------
/ Default parser
/ -------------------------------------------------------------*/
function DefaultParser()
{
	if(this.httpRequest.status == 200)
	{
		var html = this.httpRequest.responseText;
		var divList = this.parameters.split(',');
		
		for(var i = 0; i < divList.length; i++)
		{
			var div = document.getElementById(divList[i]);
			
			if(div != null)
			{
				div.innerHTML = html;
			}
		}
		if(genericManager.Trigger)
		{
			genericManager.Trigger();
		}
		
		//alert("here2");
	}
}
// ************************************************************
// Default AJAX Management
// ************************************************************

//Ajax manager
var ajaxManager = new AjaxManager("ajaxManager", false);
var ajaxManagerCache = new AjaxManager("ajaxManagerCache", true);
var genericManager = new AjaxManagerGeneric("genericManager", false);

function getAjaxContent(divName, contentUrl, showNotify, post, trigger)
{
	genericManager.AddDefault(contentUrl, divName, showNotify, post, trigger);
}

function getAjaxContentNoCache(divName, contentUrl, showNotify, post, trigger)
{
	genericManager.manager.usecache = false;
	genericManager.AddDefault(contentUrl, divName, showNotify, post, trigger);
	genericManager.manager.usecache = true;
}
// ************************************************************
// LOADING NOTIFY METHODS
// ************************************************************
function CreateLoading()
{
	var loadingTop = document.getElementById('loadingTop');
	var loadingBottom = document.getElementById('loadingBottom');
	
	if(loadingTop)
	{
		loadingTop.style.display = '';
	}
	if(loadingBottom)
	{
		loadingBottom.style.display = '';
	}
}
function DestroyLoading()
{
	var loadingTop = document.getElementById('loadingTop');
	var loadingBottom = document.getElementById('loadingBottom');
	
	if(loadingTop)
	{
		loadingTop.style.display = 'none';
	}
	if(loadingBottom)
	{
		loadingBottom.style.display = 'none';
	}
}

// ************************************************************************************************
// *** EventManager holds object names / method names pairs and permforms them when requested.
//	The events will be instances of this object
// ************************************************************************************************

// Constuctor
function EventManager() {
	// ************************************************************************************************
	// *** EventManager interface
	// ************************************************************************************************
	
	this.add = em_Add;
	this.exec = em_Exec;	
	
	// ************************************************************************************************
	// *** Implementation
	// ************************************************************************************************

	this.eventItems = new Array();
	
	// Subscribe an event handler (object name/method name pair)
	function em_Add(obj, method) {
		this.eventItems.push(new EventItem(obj, method));
	}
	
	// Performs all subscribed event handlers
	function em_Exec() {
		var i;
		
		for(i = 0; i < this.eventItems.length; i++)
		{
			if(this.eventItems[i].object)
			{
				eval(this.eventItems[i].object + '.' + this.eventItems[i].method + '()');
			}
			else
			{
				eval(this.eventItems[i].method + '()');
			}
		}
	}
}

function EventItem(object, method) {
	this.object = object;
	this.method = method;
}
// ************************************************************************************************
// *** Constructs a MediaItem object
// ************************************************************************************************
var lastMediaItemId = 0;
var uniqueUrl = true;

function MediaItem(id, title, image, duration, ads) {
	// ************************************************************************************************
	// *** MediaItem interface
	// ************************************************************************************************
	
	// Fields
	this.contentId = id; // Media's content id
	this.title = title; // Media's title
	this.imgUrl = image; // Media's playlist image
	this.duration = duration; // Media's duration
	this.ads = ads; // Array of advertisements media items
	
	// Methods
	this.getUrl = mediaItem_GetUrl;	// Gets url for a quality
	this.setUrl = mediaItem_SetUrl; // Sets url for a quality
	
	// ************************************************************************************************
	// *** MediaItem implementation
	// ************************************************************************************************
	
	// Fields
	// ******
	this.mediaUrls = new Array(); // Holds the urls for all media item qualities
	
	// Methods
	// *******
	
	// Gets the media URL considering the quality
	function mediaItem_GetUrl(quality) {
		return this.mediaUrls[quality];
	}
	
	// Sets the media URL for the specified quality
	function mediaItem_SetUrl(quality, url)
	{
		if(url && url != "")
		{
			if(uniqueUrl)
			{
				// Adds a 'counter' to the media URL, to avoid problems with duplicate items in the playlist
				if(url.indexOf('?') > -1)
				{
					url = url.replace('?', '?' + 'uid=' + (lastMediaItemId++) + '&');
				}
				else
				{
					url += '?' + 'uid=' + (lastMediaItemId++);
				}
			}

			this.mediaUrls[quality] = url;
		}
		else
		{
			this.mediaUrls[quality] = "";
		}
	}
}
// ************************************************************************************************
// *** Holds the player states
// ************************************************************************************************

function PlayState() {
	this.undefined = 0;
	this.stopped = 1;
	this.paused = 2;
	this.playing = 3;
	this.buffering = 4;
	this.forwarding = 5;
	this.rewinding = 6;
}
// ************************************************************************************************
// *** Constructs a Quality object that represents a media quality
// ************************************************************************************************

function Quality() {
	this.low = 0;
	this.high = 1;
}
// ************************************************************************************************
// *** Constructs an object that represents a playlist
// ************************************************************************************************

function Playlist() {
	// ************************************************************************************************
	// *** Interface
	// ************************************************************************************************	
	
	// Fields
	// ******
	this.id = 0;
	this.title = '';
	
	// Advertisements parameters
	this.adsFrequency = 3; // Advertisements frequency
	this.maxAdsFirst = -1; // Maximum number of advertisements before the first item (negative number for all ads)
	this.maxAds = -1; // Maximum number of advertisements before the media items (but the first, negative number for all ads)
	this.adsStartAt = 0; // Position of the first ad (zero-based)
	
	// Methods
	// *******
	this.appendItem = pl_AppendItem;
	this.clear = pl_Clear;
	this.insertItem = pl_InsertItem;
	this.getDuration = pl_GetDuration;
	this.getItem = pl_getItem;
	this.getPlaySequence = pl_GetPlaySequence;
	this.getPlaySequenceIndex = pl_GetPlaySequenceIndex;
	this.getPlayIndex = pl_GetPlayIndex;
	this.indexOf = pl_IndexOf;
	this.indexOfPlaySequence = pl_IndexOfPlaySequence;
	this.count = pl_Count;
	this.moveItem = pl_moveItem;
	this.removeAt = pl_RemoveAt;
	this.setShuffle = pl_setShuffle;
	this.getShuffle = pl_GetShuffle;
	
	// Events
	this.onChange = new EventManager(); // Occurs when the number of items or them order changes
	
	// ************************************************************************************************
	// *** Implementation
	// ************************************************************************************************
	
	// Fields
	// ******
	
	this.curMediaIndex = null; // Used for shuffle
	this.mediaItems = new Array(); // The playlist items
	this.plItemsOrder = new Array();
	this.playSequence;
	this.shuffle = false;
	
	this.plIndexToPlaySequenceIndex = new Array();
	
	// Methods
	// *******
	this.genPlaySequence = genPlaySequence;
	
	// Methods implementation
	// **********************
	
	// Adds a media item to the end of the playlist
	function pl_AppendItem(mediaItem)
	{
		this.mediaItems.push(mediaItem);
		//alert(mediaItem.id + " - " + this.mediaItems.length);
		
		// Generate the play sequence
		this.genPlaySequence();
	}
	
	// Clears the playlist
	function pl_Clear() {
		this.mediaItems = new Array();
		
		// Generate the play sequence
		this.genPlaySequence();
	}
	
	// Returns the number of items of playlist
	function pl_Count() {
		return this.mediaItems.length;
	}
	
	// Returns the playlist duration 
	function pl_GetDuration()
	{
		var sum = 0, i;
		
		// Iterate over media items
		for(i = 0; i < this.mediaItems.length; i++)
			sum += this.mediaItems[i].duration;
			
		return sum;
	}
	
	// Returns the media index at passed index
	function pl_getItem(index) {
		return this.mediaItems[index];
	}
	
	// Receives a playlist index and returns the related play sequence index
	function pl_GetPlaySequenceIndex(plIndex)
	{
		return this.plIndexToPlaySequenceIndex[this.plItemsOrder[plIndex]];
	}
	
	// Receives a playlist index and returns the related original play sequence index
	function pl_GetPlayIndex(plIndex)
	{
		return this.indexOfPlaySequence(this.mediaItems[plIndex]);
	}
	
	// Returns the index of passed media item in the playlist (not play sequence)
	function pl_IndexOf(mediaItem)
	{
		var i, j;
		
		// Search for the passed media item
		for(i = 0; i < this.mediaItems.length; i++)
		{
			if(mediaItem == this.mediaItems[i]) // Check if the wanted item is the current
			{
				return i;
			}
			else if(this.mediaItems[i].ads != null) // Search for the item in ads
			{
				for(j = 0; j < this.mediaItems[i].ads.length; j++)
				{
					if(this.mediaItems[i].ads[j] == mediaItem)
					{
						return i;
					}
				}
			}
		}
		
		return -1;
	}
	
	// Returns the index of passed media item in the play sequence
	function pl_IndexOfPlaySequence(mediaItem)
	{
		var i, j;
		
		// Search for the passed media item
		for(i = 0; i < this.playSequence.length; i++)
		{
			if(mediaItem == this.playSequence[i]) // Check if the wanted item is the current
			{
				return i;
			}
			else if(this.playSequence[i].ads != null) // Search for the item in ads
			{
				for(j = 0; j < this.playSequence[i].ads.length; j++)
				{
					if(this.playSequence[i].ads[j] == mediaItem)
					{
						return i;
					}
				}
			}
		}
		return -1;
	}
	
	// Returns an array containing the media items of playlist sequence
	function pl_GetPlaySequence()
	{
		return this.playSequence;
	}
	
	// Inserts a media item into playlist at specified location
	function pl_InsertItem(index, mediaItem) {
		this.mediaItems.splice(index, 0, mediaItem);
		
		// Generate the play sequence
		this.genPlaySequence();
	}
	
	// Changes the location of an item in the playlist
	function pl_moveItem(oldIndex, newIndex)
	{
		var temp;
		
		if(oldIndex == newIndex) return; // Do not exchange the same position
		
		// Removes from old position and save in a temporary variable
		temp = this.mediaItems.splice(oldIndex, 1)[0];
		
		// Insert in the new position
		this.mediaItems.splice(newIndex, 0, temp);
		
		// Generate the play sequence
		this.genPlaySequence();
	}
	
	// Removes a media item at the specified position
	function pl_RemoveAt(index)
	{
		this.mediaItems.splice(index, 1);
		
		// Generate the play sequence
		this.genPlaySequence();
	}
	
	// Sets a flag indicating whether we need to suffle the play sequence or not
	function pl_setShuffle(shuffle, curItem)
	{
		this.shuffle = shuffle;
		this.curMediaIndex = curItem;
		
		// Generate the play sequence
		this.genPlaySequence();

	}
	function pl_GetShuffle()
	{
		return this.shuffle;
	}
	
	// Internal methods
	// ******************
	
	// Generates the playing sequence from playlist
	function genPlaySequence()
	{
		var i, j, plItem;
		this.plItemsOrder = new Array();
		this.playSequence = new Array();
		this.plIndexToPlaySequenceIndex = new Array();
		
		// Construct order array
		for(i = 0; i < this.mediaItems.length; i++)
		{
			this.plItemsOrder.push(i);
		}
		
		
		// Shuffle order array
		if(this.shuffle)
		{
			mixArray(this.plItemsOrder, this.curMediaIndex);
		}

		// Controls if this is the first ad item (may have more or less ads)
		var firstAdItem = true;
		
		// Constructs the playing sequence (considering ads)
		for(i = 0; i < this.plItemsOrder.length; i++)
		{
			plItem = this.mediaItems[this.plItemsOrder[i]];
			this.plIndexToPlaySequenceIndex.push(this.playSequence.length);
			
			// Checks if ads should be applied to this item
			var hasAds = false;
			
			// Checks if we've reached the "start at" point
			if(i>=this.adsStartAt)
			{
				// Checks if we're in a valid ad position
				hasAds = ((i-this.adsStartAt)%this.adsFrequency)==0;
			}

			if(hasAds)
			{
				// Checks how many ads in this position
				var adCount = this.maxAds;
				if(firstAdItem)
				{
					adCount = this.maxAdsFirst; // First position may have more ads
					firstAdItem = false;        // Following items will have less ads
				}
				
				// Mix ads array
				mixArray2(plItem.ads);

				// Inserts the ads
				for(j = 0; j < plItem.ads.length && (j < adCount || adCount == -1); j++)
				{
					if(plItem.ads[j])
					{
						this.playSequence.push(plItem.ads[j]);
					}
				}
			}

			// Add the media item
			this.playSequence.push(plItem);
		}
		
		// Trigger "onChange" event
		this.onChange.exec();
	}
	
	// Mix an array, used on shuffle 
	// array: array to mix
	// cur: index of array item that will be the first item in the mixed array
	function mixArray(array, cur)
	{
		var i, j, temp;
		
		// Exchange itens
		if(cur > 0)
		{
			temp = array[0];
			array[0] = array[cur];
			array[cur] = temp;
		}
		
		for(i = 1; i < array.length - 1; i++)
		{
			j = Math.round(Math.random() * (array.length - i - 2)) + i + 1;
			temp = array[i];
			array[i] = null;
			array[i] = array[j];
			array[j] = temp;
		}
	}
	function mixArray2(array)
	{
		for(var i = 0, rand, temp; i < array.length; i++)
		{
			rand = Random(0, array.length -1);
			temp = array[i];
			
			array[i] = array[rand];
			array[rand] = temp;
		}
	}
	function Random(min, max)
	{
		var seed = Math.random();
		return Math.round(seed * (max - min)) + min;
	}
}
// ************************************************************************************************
// *** Constructs a player object that wraps the Windows Media player (No internal playlist)
// ************************************************************************************************

function PlayerWmSimple(objName, playerObject) {
	// ************************************************************************************************
	// *** Interface
	// ************************************************************************************************
	
	// Control methods
	this.getCurrentMediaDuration = wm_GetCurrentMediaDuration;
	this.getPosition = wm_GetPosition;
	this.setPosition = wm_SetPosition;

	this.next = wm_Next;
	this.pause = wm_Pause;
	this.play = wm_Play;
	this.playItem = wm_PlayItem;
	this.playUrl = wm_PlayUrl;
	this.previous = wm_Previous;
	this.stop = wm_Stop;
	this.fastForward = wm_FastForward;
	this.rewind = wm_Rewind;
	
	// Settings methods
	this.getMute = wm_GetMute;
	this.setMute = wm_SetMute;	
	this.getRepeat = wm_GetRepeat;
	this.setRepeat = wm_SetRepeat;

	this.getVolume = wm_GetVolume;
	this.setVolume = wm_SetVolume;
	
	// Media quality methods
	this.getQuality = wm_GetQuality;
	this.setQuality = wm_SetQuality;
	
	// Playlist related methods
	this.getCurrentPlaylist = wm_GetCurrentPlaylist;
	this.setCurrentPlaylist = wm_SetCurrentPlaylist;
	
	// Play state
	this.getPlayState = wm_GetPlayState;
	
	// Player general methods
	this.getCurrentMedia = wm_GetCurrentMedia;
	this.getStatus = wm_GetStatus;
	this.getBitrate = wm_GetBitrate;
	this.fullScreen = wm_FullScreen;
	this.resize = wm_Resize;
	
	// Events
	this.onCurrentMediaChange = new EventManager(); // Occurs when the current media changes
	this.onCurrentPositionChange = new EventManager(); // Occurs when the current position in the media item changes
	this.onMuteChange = new EventManager(); // Occurs when the mute state changes
	this.onPlayerStateStringChange = new EventManager(); // Occurs when the player state string changes	
	this.onPlayStateChange = new EventManager(); // Occurs when the play state changes

	// ************************************************************************************************
	// *** Implementation
	// ************************************************************************************************
	
	// Fields
	// ******
	this.currentPlaylist = null;	
	this.objName = objName;
	this.playerObject = playerObject;
	this.playState = new PlayState();
	this.quality = new Quality().low;
	this.repeat = false;
		
	// Tick fields
	this.lastCurrentPosition = 0;
	this.lastMediaUrl = '';
	this.lastMute = false;
	this.lastPlayState = this.playState.undefined;
	this.lastStateStr = '';	
	
	// Methods
	// *******
	this.sync = wm_Sync;
	this.createInternalPlaylist = wm_CreateInternalPlaylist;
	this.getCurrentPlaySequenceIndex = wm_GetCurrentPlaySequenceIndex;
	this.getCurrentIndex = wm_GetCurrentIndex;
	this.tick = wm_Tick;
	
	// Create internal playlist
	this.createInternalPlaylist();
	
	// Differentiates manual stop from natural stop
	this.manualStop = true;
	
	// Start tick
	setTimeout(this.objName +'.tick();', 500);
	
	// Control methods implementation 
	// ******************************
	
	// Sets the current item to the next item in the playlist
	function wm_Next() {
		if(this.getCurrentIndex()<this.currentPlaylist.count()-1)
		{
			this.playItem(this.getCurrentIndex()+1);
		}
		else
		{
			// Loops around
			this.playItem(0);
		}
	}	
	
	// Pauses the playing of media item
	function wm_Pause() {
		this.playerObject.controls.pause();
	}
	
	// Plays the current media item
	function wm_Play() {
		if(this.getPlayState()!=this.playState.paused && this.getPlayState()!=this.playState.playing)
		{
			// Starting
			this.playItem(0);
		}
		else
		{
			// Resuming
			this.playerObject.controls.play();
		}
		this.currentPlayState = this.playState.playing;
	}
	
	// Plays the specified media item
	function wm_PlayItem(index)
	{
		if(this.currentPlaylist.count() > 0 && index < this.currentPlaylist.count())
		{
			// Gets the play sequence
			var playSequence = this.currentPlaylist.getPlaySequence();

			// Get the play sequence index for the requested index
			var psIndex = this.currentPlaylist.getPlaySequenceIndex(index);
						
			// Plays the item
			this.playerObject.URL = playSequence[psIndex].mediaUrls[this.quality];	
			this.playerObject.controls.play();
			this.manualStop = false;
		}
	}
	
	// Plays the specified url
	function wm_PlayUrl(url) {
		// Do NOT use this when working with playlists

		// Sets the URL and plays
		this.playerObject.URL = url;	
		this.playerObject.controls.play();
		
		this.manualStop = false;
	}

	// Sets the current item to the previous in the playlist
	function wm_Previous() {
		if(this.getCurrentIndex()>0)
		{
			this.playItem(this.getCurrentIndex()-1);
		}
		else
		{
			// Loops around
			this.playItem(this.currentPlaylist.count()-1);			
		}
	}
	
	// Stops the playing of media item
	function wm_Stop() {
		this.playerObject.controls.stop();
		this.manualStop = true;
	}

	// Fast forwards the playing of media item
	function wm_FastForward() {
		this.playerObject.controls.fastForward();
	}
	
	// Rewinds the playing of media item
	function wm_Rewind() {
		this.playerObject.controls.fastReverse();
	}
	
	// Returns the duration (in seconds) of the current media
	function wm_GetCurrentMediaDuration() {
		if(this.playerObject.currentMedia != null)
			return this.playerObject.currentMedia.duration;
		return 0;
	}
	
	// Gets the current position in the media item in seconds from the beginning
	function wm_GetPosition() {
		if(this.playerObject)
			if(this.playerObject.controls)
				return parseInt(this.playerObject.controls.currentPosition);
		return 0;
	}
	
	// Sets the current position in the media item in seconds from de beginning
	function wm_SetPosition(position) {
		this.playerObject.controls.currentPosition = position;
	}
	
	// Settings methods implementation
	// *******************************
	
	// Sets the player volume
	function wm_SetVolume(val)
	{
		if(this.playerObject.settings)
		{
			this.playerObject.settings.volume = val;
		}
	}
	
	// Retrieves the player volume
	function wm_GetVolume()
	{
		if(this.playerObject.settings)
		{
			return this.playerObject.settings.volume;
		}
	}
	
	// Sets the player's mute state
	function wm_SetMute(mute)
	{
		if(this.playerObject.settings)
		{
			this.playerObject.settings.mute = mute;
		}
	}
	
	// Gets the player's mute state
	function wm_GetMute()
	{
		if(this.playerObject)
			if(this.playerObject.settings)
				return this.playerObject.settings.mute;
				
		return(false);
	}
	
	// Gets the repeat flag
	function wm_GetRepeat() 
	{
		return(this.repeat);
	}
	
	// Sets the repeat flag
	function wm_SetRepeat(state)
	{
		this.repeat = state;		
	}
	
	// Playlist related methods implementation
	// ***************************************

	// Gets the current player's playlist
	function wm_GetCurrentPlaylist() {
		return(this.currentPlaylist);
	}
	
	// Sets the current player's playlist
	function wm_SetCurrentPlaylist(playlist) {
		this.currentPlaylist = playlist;
	}
	
	// Syncronize external and internal playlist
	function wm_Sync() {
		// Compatibility only
	}
	
	// Media quality methods
	// *********************
	
	// Get the current media quality
	function wm_GetQuality() {
		return this.quality;
	}

	// Set the current media quality	
	function wm_SetQuality(quality) {
		this.quality = quality;
	}
	
	// Play state
	// **********
	
	// Gets the play state
	function wm_GetPlayState() {
		var playerState;
		
		// Get the play state from player object
		playerState = (this.playerObject) ? this.playerObject.playState : 0;
		
		switch(playerState) {
			case 1 : // Stopped
			case 10 : // Ready
				return this.playState.stopped;
			case 2 : // Paused
				return this.playState.paused;
			case 7 : // Waiting
				this.next(); // End of live, go to next and return 'playing'
			case 4 : // ScanForward
				return this.playState.forwarding;
			case 5 : // ScanReverse
				return this.playState.rewinding;
			case 3 : // Playing
			case 8 : // MediaEnded
				return this.playState.playing;
			case 6 : // Buffering
			case 9 : // Transitioning
			case 11 : // Reconnecting
				return this.playState.buffering;
			default :
				return this.playState.undefined;
		}
	}

	// General methods implementation
	// *******************************
	
	// Gets the current media item
	function wm_GetCurrentMedia() {
		if(this.currentPlaylist == null)
			return null;
			
		var playSequence = this.currentPlaylist.getPlaySequence();
		var index = this.getCurrentPlaySequenceIndex();
		
		return (index >= 0) ? playSequence[index] : null;
	}
	
	// Gets the status string from player
	function wm_GetStatus() {
		return this.playerObject.status;
	}

	// Get the bitrate of the video
	function wm_GetBitrate()
	{
		if(this.playerObject)
			if(this.playerObject.currentMedia != null)
				return this.playerObject.currentMedia.getItemInfo("Bitrate");
		return 0;
	}
	
	// Puts the player in full screen mode
	function wm_FullScreen() {
		// the activex player version for firefox works only with string values
		try {
			this.playerObject.fullScreen = 'true';
		} catch(e) {}
		// the others versions works with bool
		try {
			this.playerObject.fullScreen = true;
		} catch(e) {}
	}
	
	// Resizes the player
	function wm_Resize(width, height)
	{
		this.playerObject.width = width;
		this.playerObject.height = height;

		// Workaround for Mozilla
		// Usually it doesn't redraw the player correctly after resizing
		// Setting the body height and returning it to auto forces a redraw
		if(window.GeckoActiveXObject)
		{
			document.getElementsByTagName("body")[0].style.height = '1px';
			window.setTimeout('document.getElementsByTagName("body")[0].style.height = \'auto\';',100); // Apparently a small delay is required
		}
	}
	
	// Creates the internal playlist
	function wm_CreateInternalPlaylist() {
		// Compatibility-only
	}

	// Returns the index of current media item index (play sequence) (-1 if it is not found)
	function wm_GetCurrentIndex() {

		// Determine the current index
		for(var i = 0; i < this.currentPlaylist.mediaItems.length; i++)
		{
			// Strips protocol information
			var url = this.currentPlaylist.mediaItems[i].mediaUrls[this.quality];
			url = url.substring(url.indexOf("://") + 3);

			if(this.playerObject.URL.indexOf(url)>0)
			{
				return i;
			}
			else
			{
				for(var j = 0; j < this.currentPlaylist.mediaItems[i].ads.length;j++)
				{
					// Strips protocol information
					var urlAd = this.currentPlaylist.mediaItems[i].ads[j].mediaUrls[this.quality];
					urlAd = urlAd.substring(urlAd.indexOf("://") + 3);
					if(this.playerObject.URL.indexOf(urlAd)>0)
					{
						return i;
					}
				}
			}
		}
		
		return -1;
	}

	// Returns the index of current media item index (play sequence) (-1 if it is not found)
	function wm_GetCurrentPlaySequenceIndex() {
		var playSequence = this.currentPlaylist.getPlaySequence();

		// Determine the current index
		if(playSequence!=null && this.playerObject!=null)
		{
			for(i = 0; i < playSequence.length; i++)
			{
				// Must strip url from protocol to allow comparison
				var url = playSequence[i].mediaUrls[this.quality];
				url = url.substring(url.indexOf("://") + 3);
				
				if(this.playerObject.URL!=null)
				{
					if(this.playerObject.URL.indexOf(url)>0)
						return i;
				}
			}
		}
		
		return -1;
	}
	
	// Function to check for changes in the player state
	function wm_Tick() {
		var currentMedia = this.getCurrentMedia();
		var currentMediaUrl = currentMedia != null ? currentMedia.mediaUrls[this.quality] : '';
		
		// Detects change and manually sets the next media
		if(this.getPlayState()==this.playState.stopped && !this.manualStop)
		{
			if(this.currentPlaylist)
			{
				var playSequence = this.currentPlaylist.getPlaySequence();
				var currentIndex = this.getCurrentPlaySequenceIndex();
					
				// Goes to the next playlist index
				if(playSequence!=null)
				{
					if(currentIndex<playSequence.length-1)
					{
						this.playerObject.URL = playSequence[currentIndex+1].mediaUrls[this.quality];	
						this.playerObject.controls.play();
					}
					else 
					{
						if(this.repeat)
						{
							this.playItem(0);
						}
						else
						{
							this.manualStop = true;
						}
					}
				}
			}
		}
		
		// State string
		if(this.getStatus() != this.lastStateStr) {
			// Trigger event
			this.onPlayerStateStringChange.exec();
			
			this.lastStateStr = this.getStatus();
		}
		
		// Media change
		if(currentMediaUrl != this.lastMediaUrl && this.getPlayState()!=this.playState.stopped) {
			this.onCurrentMediaChange.exec();
			
			this.lastMediaUrl = currentMediaUrl;
		}
		
		// Current position
		if(this.lastCurrentPosition != this.getPosition()) {
			this.onCurrentPositionChange.exec()
			
			this.lastCurrentPosition = this.getPosition();
		}
		
		// Mute change
		if(this.lastMute != this.getMute()) {
			this.onMuteChange.exec();
			
			this.lastMute = this.getMute();
		}
		
		// Play state change
		if(this.lastPlayState != this.getPlayState()) {
			this.onPlayStateChange.exec();
			
			this.lastPlayState = this.getPlayState();
		}
		
		setTimeout(this.objName +'.tick();', 500);
	}
}
// ************************************************************************************************
// *** Constructs a player object that wraps the QuickTime for Mach
// ************************************************************************************************

function PlayerMac(objName, playerObject)
{
	// ************************************************************************************************
	// *** Interface
	// ************************************************************************************************

	// Control methods
	this.getCurrentMediaDuration = mac_GetCurrentMediaDuration;
	this.getPosition = mac_GetPosition;
	this.setPosition = mac_SetPosition;

	this.next = mac_Next;
	this.pause = mac_Pause;
	this.play = mac_Play;
	this.playItem = mac_PlayItem;
	this.playUrl = mac_PlayUrl;
	this.previous = mac_Previous;
	this.stop = mac_Stop;
	this.fastForward = mac_FastForward;
	this.rewind = mac_Rewind;
		
	// Settings methods
	this.getMute = mac_GetMute;
	this.setMute = mac_SetMute;	
	this.getRepeat = mac_GetRepeat;
	this.setRepeat = mac_SetRepeat;

	this.getVolume = mac_GetVolume;
	this.setVolume = mac_SetVolume;
	
	// Media quality methods
	this.getQuality = mac_GetQuality;
	this.setQuality = mac_SetQuality;
	
	// Playlist related methods
	this.getCurrentPlaylist = mac_GetCurrentPlaylist;
	this.setCurrentPlaylist = mac_SetCurrentPlaylist;
	
	// Play state
	this.getPlayState = mac_GetPlayState;
	
	// Player general methods
	this.getCurrentMedia = mac_GetCurrentMedia;
	this.getStatus = mac_GetStatus;
	this.getBitrate = mac_GetBitrate;
	this.fullScreen = mac_FullScreen;
	this.resize = mac_Resize;
	
	// Events
	this.onCurrentMediaChange = new EventManager(); // Occurs when the current media changes
	this.onCurrentPositionChange = new EventManager(); // Occurs when the current position in the media item changes
	this.onMuteChange = new EventManager(); // Occurs when the mute state changes
	this.onPlayerStateStringChange = new EventManager(); // Occurs when the player state string changes	
	this.onPlayStateChange = new EventManager(); // Occurs when the play state changes

	// ************************************************************************************************
	// *** Implementation
	// ************************************************************************************************
	
	// Fields
	// ******
	this.currentPlaylist = null;	
	this.objName = objName;
	this.playerObject = playerObject;
	this.playState = new PlayState();
	this.quality = new Quality().low;
	this.repeat = false;
	this.paused = false;
	
	// Tick fields
	this.lastCurrentPosition = 0;
	this.lastMediaUrl = '';
	this.lastMute = false;
	this.lastPlayState = this.playState.undefined;
	this.lastStateStr = '';	
	
	// Methods
	// *******
	this.sync = mac_Sync;
	this.createInternalPlaylist = mac_CreateInternalPlaylist;
	this.getCurrentPlaySequenceIndex = mac_GetCurrentPlaySequenceIndex;
	this.getCurrentIndex = mac_GetCurrentIndex;
	this.tick = mac_Tick;
	
	// Create internal playlist
	this.createInternalPlaylist();
	
	// Differentiates manual stop from natural stop
	this.manualStop = true;
	
	// Start tick
	setTimeout(this.objName +'.tick();', 1000);
	
	// Control methods implementation 
	// ******************************
	
	// Sets the current item to the next item in the playlist
	function mac_Next() {
		if(this.getCurrentIndex()<this.currentPlaylist.count()-1)
		{
			this.playItem(this.getCurrentIndex()+1);
		}
		else
		{
			// Loops around
			this.playItem(0);
		}
	}	

	
	// Pauses the playing of media item
	function mac_Pause()
	{
		try
		{
			this.playerObject.Stop();
			this.paused = true;
		}catch(e){}
	}
	
	// Plays the current media item
	function mac_Play(wait)
	{
		if(this.getPlayState()!=this.playState.paused && this.getPlayState()!=this.playState.playing)
		{
			// Starting
			this.playItem(0);
		}
		else
		{
			// Resuming
			try
			{
				this.playerObject.Play();
				this.paused = false;
			}catch(e){}
		}
	}
	
	// Plays the specified media item
	function mac_PlayItem(index, wait)
	{
		if(this.currentPlaylist.count() > 0 && index < this.currentPlaylist.count())
		{
			// Gets the play sequence
			var playSequence = this.currentPlaylist.getPlaySequence();

			// Get the play sequence index for the requested index
			var psIndex = this.currentPlaylist.getPlaySequenceIndex(index);
						
			// Plays the item
			this.playerObject.SetResetPropertiesOnReload(false);
			this.playerObject.SetURL(playSequence[psIndex].mediaUrls[this.quality]);
			this.playerObject.Play();
			
			this.paused = false;
			this.manualStop = false;
		}
	}
	
	// Plays the specified url
	function mac_PlayUrl(url)
	{
		// Plays the item
		this.playerObject.SetResetPropertiesOnReload(false);
		this.playerObject.SetURL(url);
		this.playerObject.Play();
		
		this.paused = false;
		this.manualStop = false;
	}

	// Sets the current item to the previous in the playlist
	function mac_Previous()
	{
		if(this.getCurrentIndex()>0)
		{
			this.playItem(this.getCurrentIndex()-1);
		}
		else
		{
			// Loops around
			this.playItem(this.currentPlaylist.count()-1);			
		}
	}
	
	// Stops the playing of media item
	function mac_Stop()
	{
		try
		{
			this.playerObject.Stop();
			this.paused = false;
			this.manualStop = true;
		}
		catch(e){}
	}
	
	// Fast forwards the playing of media item
	function mac_FastForward()
	{
		// Not supported
	}
	
	// Rewinds the playing of media item
	function mac_Rewind()
	{
		// Not supported
	}
	
	// Returns the duration (in seconds) of the current media
	function mac_GetCurrentMediaDuration()
	{
		try
		{
			return(this.playerObject.GetDuration() / this.playerObject.GetTimeScale());
		}
		catch(e)
		{
			return(0);
		}
	}
	
	// Gets the current position in the media item in seconds from the beginning
	function mac_GetPosition()
	{
		try
		{
			return(this.playerObject.GetTime() / this.playerObject.GetTimeScale());
		}
		catch(e)
		{
			return(0);			
		}
	}
	
	// Sets the current position in the media item in seconds from de beginning
	function mac_SetPosition(position)
	{
		if(this.playerObject)
			this.playerObject.SetTime(position * this.playerObject.GetTimeScale());
	}
	
	// Settings methods implementation
	// *******************************
	
	// Sets the player volume
	function mac_SetVolume(val)
	{
		try
		{
			this.playerObject.SetVolume(val * 2.56);
		}
		catch(e){}
	}
	
	// Retrieves the player volume
	function mac_GetVolume() 
	{
		try
		{
			return this.playerObject.GetVolume() / 2.56;
		}
		catch(e)
		{
			return(0);
		}
	}
	
	// Sets the player's mute state
	function mac_SetMute(mute)
	{
		this.playerObject.SetMute(mute);
	}
	
	// Gets the player's mute state
	function mac_GetMute() 
	{
		return this.playerObject.GetMute();
	}
	
	// Gets the repeat flag
	function mac_GetRepeat() 
	{
		return(this.repeat);
	}
	
	// Sets the repeat flag
	function mac_SetRepeat(state)
	{
		this.repeat = state;
	}
	
	// Playlist related methods implementation
	// ***************************************

	// Gets the current player's playlist
	function mac_GetCurrentPlaylist()
	{
		return(this.currentPlaylist);
	}
	
	// Sets the current player's playlist
	function mac_SetCurrentPlaylist(playlist)
	{
		this.currentPlaylist = playlist;
	}
	
	// Syncronize external and internal playlist
	function mac_Sync()
	{
		// Windows-media compatibility only
	}
	
	// Media quality methods
	// *********************
	
	// Get the current media quality
	function mac_GetQuality()
	{
		return this.quality;
	}

	// Set the current media quality	
	function mac_SetQuality(quality)
	{
		this.quality = quality;
	}
	
	// Play state
	// **********
	
	// Gets the play state
	function mac_GetPlayState()
	{
		// Buffering 
		var playerState = this.playerObject.GetPluginStatus();
		if(playerState=="Waiting" || playerState=="Loading")
		{
			return this.playState.buffering;
		}
		
		// Manual stop
		if(this.manualStop)
		{
			return(this.playState.stopped);
		}
		
		// Automatic stop at end of media
		try
		{
			// At the end of the media
			var duration = this.playerObject.GetDuration();
			var time = this.playerObject.GetTime();
			
			if(time>0 && duration>0 && Math.abs(duration-time)<100)
			{
				return(this.playState.stopped)
			}
		}
		catch(e)
		{
		}
		
		// Playing or paused
		if(this.paused)
		{
			return(this.playState.paused);
		}
		else
		{
			return this.playState.playing;
		}
	}

	// General methods implementation
	// *******************************
	
	// Gets the current media item
	function mac_GetCurrentMedia()
	{
		if(this.currentPlaylist == null)
			return null;
			
		var playSequence = this.currentPlaylist.getPlaySequence();
		var index = this.getCurrentPlaySequenceIndex();
		
		return (index >= 0) ? playSequence[index] : null;
	}
	
	// Gets the status string from player
	function mac_GetStatus()
	{
		var status = '';
		try
		{
			status = this.playerObject.GetPluginStatus();
		}
		catch(e){}
		return(status);
	}
	
	// Get the bitrate of the video
	function mac_GetBitrate()
	{
		return -1; // Not implemented
	}
	
	// Puts the player in fullscreen mode
	// QuickTime not supports fullscreem mode
	function mac_FullScreen() 
	{
	}

	// Resizes the player
	function mac_Resize(width, height)
	{
		this.playerObject.width = width;
		this.playerObject.height = height;
	}	
	
	// Creates the internal playlist
	function mac_CreateInternalPlaylist() {
		// Windows-media compatibility only
	}
	
	// Returns the index of current media item index (not play sequence) (-1 if it is not found)
	function mac_GetCurrentIndex() {

		// Determine the current index
		for(var i = 0; i < this.currentPlaylist.mediaItems.length; i++)
		{
			// Strips protocol information
			var url = this.currentPlaylist.mediaItems[i].mediaUrls[this.quality];
			url = url.substring(url.indexOf("://") + 3);

			if(this.playerObject.GetURL().indexOf(url)>0)
			{
				return i;
			}
			else
			{
				for(var j = 0; j < this.currentPlaylist.mediaItems[i].ads.length;j++)
				{
					// Strips protocol information
					var urlAd = this.currentPlaylist.mediaItems[i].ads[j].mediaUrls[this.quality];
					urlAd = urlAd.substring(urlAd.indexOf("://") + 3);
					if(this.playerObject.GetURL().indexOf(urlAd)>0)
					{
						return i;
					}
				}
			}
		}
		
		return -1;
	}

	// Returns the index of current media item index (play sequence) (-1 if it is not found)
	function mac_GetCurrentPlaySequenceIndex()
	{
		var playSequence = this.currentPlaylist.getPlaySequence();
		
		try
		{
			// Determine the current index
			if(playSequence!=null)
			{
				for(i = 0; i < playSequence.length; i++)
				{
					// Must strip url from protocol to allow comparison
					var url = playSequence[i].mediaUrls[this.quality];
					url = url.substring(url.indexOf("://") + 3);
					
					if(this.playerObject.GetURL().indexOf(url)>0)
						return i;
				}
			}
		}
		catch(e)
		{
			return -1;
		}
	}
	
	// Function to check for changes in the player state
	function mac_Tick()
	{
		var currentMedia = this.getCurrentMedia();
		var currentMediaUrl = currentMedia != null ? currentMedia.mediaUrls[this.quality] : '';

		// Detects change and manually sets the next media
		if(this.getPlayState()==this.playState.stopped && !this.manualStop)
		{
			if(this.currentPlaylist)
			{
				var playSequence = this.currentPlaylist.getPlaySequence();
				var currentIndex = this.getCurrentPlaySequenceIndex();
					
				// Goes to the next playlist index
				if(playSequence!=null)
				{
					if(currentIndex<playSequence.length-1)
					{
						this.playerObject.SetURL(playSequence[currentIndex+1].mediaUrls[this.quality]);
						this.playerObject.Play();
					}
					else
					{
						if(this.repeat)
						{
							this.playItem(0);
						}
						else
						{
							this.manualStop = true;
							this.paused = false;
						}
					}
				}
			}
		}
		
		
		// State string
		if(this.playerObject)
		{
			if(this.getStatus() != this.lastStateStr)
			{
				// Trigger event
				this.onPlayerStateStringChange.exec();
				
				this.lastStateStr = this.getStatus();
			}
		}
		
		// Media change
		if(currentMediaUrl != this.lastMediaUrl)
		{
			this.onCurrentMediaChange.exec();
			this.lastMediaUrl = currentMediaUrl;
		}
		
		// Current position
		if(this.lastCurrentPosition != this.getPosition())
		{
			this.onCurrentPositionChange.exec();
			this.lastCurrentPosition = this.getPosition();
		}
				
		// Mute change
		if(this.lastMute != this.getMute())
		{
			this.onMuteChange.exec();			
			this.lastMute = this.getMute();
		}
		
		// Play state change
		if(this.lastPlayState != this.getPlayState())
		{
			this.onPlayStateChange.exec();			
			this.lastPlayState = this.getPlayState();
		}
		
		setTimeout(this.objName +'.tick();', 1000);
	}
}

// Disables uniqueUrl for player
uniqueUrl = false;

function PlayerTerra(playerObjName, type)
{
	// ************************************************************************************************
	// *** Initialization
	// ************************************************************************************************

	// Fields
	// ******
	this.currentPlaylist = null;
	this.type = type;
	switch(type)
	{
		// Windows Media Player
		case 1:
		case 4: 
			this.player = new PlayerWmSimple('playerTerra.player', document.getElementById(playerObjName));
			break;
		// Mac + QuickTime + Flip4Mac
		case 2:
			this.player = new PlayerMac('playerTerra.player', document.getElementById(playerObjName));
			break;
		// Silverlight + Mac or Windows
		case 3:
			this.player = new PlayerSilverlight('playerTerra.player', document.getElementById(playerObjName));
			break;
	}
	
	// ************************************************************************************************
	// *** Interface
	// ************************************************************************************************	
	 
	// Methods
	this.reset = player_Reset;
	this.getCurrentIndex = player_GetCurrentIndex;
	this.getCurrentMedia = player_GetCurrentMedia;
	this.getCurrentInternalMedia = player_GetCurrentInternalMedia;
	this.playItem = player_PlayItem;
	this.previous = player_Previous;
	this.next = player_Next;
	this.play = player_Play;
	this.playUrl = player_PlayUrl;
	this.stop = player_Stop;
	this.mute = player_Mute;
	this.getBitrate = player_GetBitrate;
	this.getRepeat = player_GetRepeat;
	this.setRepeat = player_SetRepeat;
	this.getShuffle = player_GetShuffle;
	this.setShuffle = player_SetShuffle;
	this.setVolume = player_SetVolume;
	this.syncVolume = player_SyncVolume;
	this.increaseVolume = player_IncreaseVolume;
	this.decreaseVolume = player_DecreaseVolume;
	this.maxVolume = player_MaxVolume;
	this.sliderVolume = player_SliderVolume;
	this.fullScreen = player_FullScreen;
	this.getPlayState = player_GetPlayState;
	this.setCurrentPlaylist = player_SetCurrentPlaylist;
	this.setPosition = player_SetPosition;
	this.syncPosition = player_SyncPosition;
	this.resize = player_Resize;
	this.adPost = player_AdPost;
	this.adCallback = player_AdCallback;
	this.adMonitor = player_AdMonitor;
	this.printNextMedia = player_PrintNextMedia;
	
	// Ad frequency controls
	this.getPlayedVideoCount = player_GetPlayedVideoCount;
	this.resetPlayedVideoCount = player_ResetPlayedVideoCount;
	this.incrementPlayedVideoCount = player_IncrementPlayedVideoCount;

	// Adult content methods
	this.adultContent = player_AdultContent;
	this.adultAccept = player_AdultAccept;
	this.adultRefuse = player_AdultRefuse;

	// Event Handlers
	this.updateTimeInfo = player_UpdateTimeInfo;
	this.updatePositionSlider = player_UpdatePositionSlider;
	this.updatePlayPauseButton = player_updatePlayPauseButton;
	this.updateState = player_UpdateState;
	this.currentMediaChange = player_CurrentMediaChange;
	this.moveToNextMedia = player_MoveToNextMedia;

	// Bind player event handlers
	this.player.onCurrentPositionChange.add('playerTerra', 'updateTimeInfo');
	this.player.onCurrentPositionChange.add('playerTerra', 'updatePositionSlider');
	this.player.onPlayStateChange.add('playerTerra', 'updatePlayPauseButton');
	this.player.onPlayStateChange.add('playerTerra', 'updateState');
	this.player.onPlayStateChange.add('playerTerra', 'moveToNextMedia');
	
	this.playState = new PlayState();
	
	// Stores information for the current media
	this.currentPosition = -1;
	
	// Informs if the current stop was a manual or not
	this.manualStop = true;
	
	// Informs if the currently playing video is an ad
	this.playingAd = false;
	this.currentAdObject = null;
	
	// Management to handle problems in the adserver
	this.adLoadStart = null;
	this.adMonitorTimer = null;
	
	// Informs if the currently playing video is a related
	this.playingRelated = false;
	this.currentRelated = -1;
	
	// Informs if repeat is enabled or not
	this.repeat = false;
	
	// Adult video settings
	this.beforeDiscContent = -1;
	
	// Buffering controls
	this.bufferingTimes = new Array();
	this.bufferingLimitReached = false;
	this.bufferingNotified = false;
	this.bufferingIgnoreNext = true;
	
	// Current mute mode
	this.muteMode = false;
	
	// Current vote state
	this.alreadyVote = false;
	
	// ************************************************************************************************
	// *** Implementation
	// ************************************************************************************************

	// Resets player to "stopped" state
	function player_Reset()
	{
		this.manualStop = true;
		this.playingAd = false;
		this.playingRelated = false;
		this.currentPosition = -1;
		this.currentRelated = -1;
		this.currentAd = -1;
	}

	// Gets the current media index
	function player_GetCurrentIndex()
	{
		if(this.playingRelated)
		{
			return(-1);
		}
		else
		{
			return (this.currentPosition);
		}
	}

	// Gets the current media ("visible", doesn't include ads)
	function player_GetCurrentMedia()
	{
		if(this.playingRelated)
		{
			return (this.currentPlaylist.getItem(this.currentPosition).relateds[this.currentRelated]);
		}
		else
		{
			return (this.currentPlaylist.getItem(this.currentPosition));
		}
	}

	// Gets the current media ("internal", include ads)
	function player_GetCurrentInternalMedia()
	{
		if(this.playingRelated)
		{
			if(this.playingAd)
			{
				return (this.currentAdObject);
			}
			else
			{
				return (this.currentPlaylist.getItem(this.currentPosition).relateds[this.currentRelated]);
			}
		}
		else
		{
			if(this.playingAd)
			{
				return (this.currentAdObject);
			}
			else
			{
				return (this.currentPlaylist.getItem(this.currentPosition));
			}
		}
	}

	// Plays a specific playlist item
	function player_PlayItem(index, relatedIndex)
	{
		Verbose('Called playItem ' + index + ',' + relatedIndex);
	
		// Only proceeeds if script allows
		if(index==this.currentPosition || !this.playingAd)
		{
			// If it was playing an item, calls the "end" scripts
			if(this.player.getPlayState()==this.playState.playing)
			{
				var currentMedia = this.getCurrentInternalMedia();
				if(currentMedia && currentMedia.endScript && currentMedia.endScript!='')
				{
					Verbose("End of video script: " + currentMedia.endScript);
					eval(currentMedia.endScript);
				}
			}
					
			if(index>=0 && index<playlistTerra.getCount())
			{
				var item = this.currentPlaylist.getItem(index);
				if(item)
				{
					// Plays a related, if specified
					if(relatedIndex>=0 && relatedIndex<=item.relateds.length)
					{
						this.playingRelated = true;
						item = item.relateds[relatedIndex];
					}
					else
					{
						this.playingRelated = false;
					}
					
					// Updates the random value for the banners
					if(!this.playingAd)
					{
						UpdateRandom();
					}
				
					// Gets the number of videos played since the last ad
					var videoCount = this.getPlayedVideoCount();

					// Checks if it's time to play an ad
					if(allowVideoAd)
					{
						if(item.adFrequency>0 && !this.playingAd && !lcEnabled)
						{
							if(videoCount % item.adFrequency == 0)
							{
								this.currentPosition = index;
								this.currentRelated = relatedIndex;
								this.resetPlayedVideoCount(); // Resets the frequency counter
								this.manualStop = true; // Deals as if the video was stopped while waiting
								this.player.pause();

								this.adPost(item);
								return;
							}
						}
					}

					// Plays the video
					var url = item.getUrl(0);
					if(url)
					{
						this.currentPosition = index;
						this.currentRelated = relatedIndex;
						this.incrementPlayedVideoCount(); // Increments the frequency counter
						this.playingAd = false;
						this.alreadyVote = false;
						this.playUrl(url);
					}
				}
			}
			else
			{
				// Fallback, start from the beginning
				this.playItem(0,-1);
			}
		}
	}
	
	function player_PlayUrl(url)
	{
		this.manualStop = true;
		this.player.pause(); // For aesthetic reasons only
		
		if(sbrEnabled && playerTester.currentBandwidth<=0)
		{
			playerTester.bandwidthTestFinishedUrl = url;
			playerTester.bandwidthTest();
			return;
		}
		else
		{
			// Clears the buffering counts on a video change
			this.bufferingTimes = new Array();
			this.bufferingLimitReached = false;
			this.bufferingNotified = false;
		
			Verbose("Playing URL " + url);
			window.setTimeout("playerTerra.player.playUrl('" + url + "');playerTerra.manualStop = false;playerTerra.currentMediaChange();",500);
		}
	}

	// Plays the previous playlist item
	function player_Previous()
	{
		if(!this.playingRelated)
		{
			if(this.shuffle)
			{
				var shufflePos = this.currentPosition;
				do
				{
					shufflePos = Math.floor(Math.random() * this.currentPlaylist.getCount()),-1;
				}while(shufflePos==this.currentPosition);
				this.playItem(shufflePos,-1);
			}
			else
			{
				var newItem = this.getCurrentIndex()-1;
				if(newItem>=0)
				{
					this.playItem(newItem,-1);
				}
				else
				{
					if(this.repeat)
					{
						this.playItem(playlistTerra.getCount()-1,-1);
					}
				}
			}
		}
	}
	
	// Plays the next playlist item
	function player_Next()
	{
		if(!this.playingRelated)
		{
			if(this.shuffle)
			{
				var shufflePos = this.currentPosition;
				do
				{
					shufflePos = Math.floor(Math.random() * this.currentPlaylist.getCount()),-1;
				}while(shufflePos==this.currentPosition);
				this.playItem(shufflePos,-1);
			}
			else
			{
				var newItem = this.getCurrentIndex()+1;
				if(newItem<playlistTerra.getCount())
				{
					this.playItem(newItem,-1);
				}
				else
				{
					if(this.repeat)
					{
						this.playItem(0,-1);
					}
				}
			}
		}
	}
	
	// Plays the current media item
	function player_Play()
	{
		var state = this.player.getPlayState();
		if(state == this.playState.playing)
		{
			var currentMedia = this.getCurrentMedia();
			if(currentMedia.isLive)
			{
				this.player.stop();
			}
			else
			{
				this.player.pause();
			}
		}
		else
		{
			if(state == this.playState.paused)
			{
				this.player.play();
			}
			else
			{
				this.playItem(0,-1);
			}
		}
		
		// Updates state now instead of relying on timed update
		this.updatePlayPauseButton();
	}
	
	// Stops player
	function player_Stop() 
	{
		this.player.stop();
		this.reset();
	}	
	
	// Mute
	function player_Mute()
	{
		this.muteMode = !this.player.getMute();
		this.player.setMute(this.muteMode);
		var btnMute = document.getElementById("btnMute");
		if(btnMute)
		{
			if(this.player.getMute())
			{
				btnMute.className = "mute selected";
			}
			else
			{
				btnMute.className = "mute";
			}
		}
	}	
	
	// Gets the current bitrate in kbps
	function player_GetBitrate()
	{
		var bitrate = this.player.getBitrate();
		if(bitrate>0) bitrate = bitrate/1000; // In KBps
		return(bitrate);
	}

	// Gets repeat flag
	function player_GetRepeat()
	{
		return(this.repeat);
	}

	// Sets repeat flag	
	function player_SetRepeat(repeat)
	{
		this.repeat = repeat;
		playlistTerra.syncPlaylistTab();
	}
	
	// Gets shuffle flag
	function player_GetShuffle()
	{
		return(this.shuffle);
	}

	// Sets repeat flag	
	function player_SetShuffle(shuffle)
	{
		this.shuffle = shuffle;
		playlistTerra.syncPlaylistTab();
	}
	
	// Sets the player's volume
	function player_SetVolume(volume)
	{
		this.volumeSlider.setValue(volume / 100);
		this.syncVolume();
		this.player.setVolume(volume);
	}
		
	// Increases player volume by 10
	function player_IncreaseVolume()
	{
		var volume = this.player.getVolume();
		volume = Math.min(volume + 10, 100);
		this.setVolume(volume);
	}
	
	// Decreases player volume by 10
	function player_DecreaseVolume()
	{
		var volume = this.player.getVolume();
		volume = Math.max(volume - 10, 0);
		this.setVolume(volume);
	}	

	// Sets the volume to max
	function player_MaxVolume()
	{
		this.setVolume(100);
	}

	// Sets the volume to the slider volume
	function player_SliderVolume()
	{
		if(!this.player.getMute())
		{
			this.player.setVolume(this.volumeSlider.getValue() * 100);
		}
	}
	
	// Syncs the player slider with the slider bar
	function player_SyncVolume()
	{
		// Keeps button and bar sync'ed
		var pointerObj = document.getElementById('volumePointer');
		var barObj = document.getElementById('volumeResize');
		if(pointerObj && barObj)
		{
			if(pointerObj.style.left!=barObj.style.width)
			{
				pointerObj.style.left=barObj.style.width;
			}
		}
	}
	
	// Full screen	
	function player_FullScreen()
	{
		this.player.fullScreen();
	}

	// Retrieves the current player playstate	
	function player_GetPlayState()
	{
		return(this.player.getPlayState());	
	}
	
	// Sets current playlist
	function player_SetCurrentPlaylist(pl) 
	{
		this.currentPlaylist = pl;
	}

	// Sets the current position
	function player_SetPosition()
	{
		if(this.getCurrentMedia())
		{
			if(!this.playingAd)
			{
				this.bufferingIgnoreNext = true;
				var pos = this.positionSlider.getValue() * this.player.getCurrentMediaDuration();
				this.player.setPosition(pos);
			}
		}
	}
	
	// Syncs the player slider with the slider bar
	function player_SyncPosition()
	{
		// Keeps button and bar sync'ed
		var pointerObj = document.getElementById('positionPointer');
		var barObj = document.getElementById('positionResize');
		if(pointerObj && barObj)
		{
			if(pointerObj.style.left!=barObj.style.width)
			{
				pointerObj.style.left=barObj.style.width;
			}
		}
	}
	
	// Resizes the player
	function player_Resize(width, height)
	{
		this.player.resize(width, height);
	}

	//
	// AD FREQUENCY CONTROLS
	//
	function player_IncrementPlayedVideoCount()
	{
		cookieManager.setValue("playedVideoCount", this.getPlayedVideoCount()+1);
	}

	function player_ResetPlayedVideoCount()
	{
		cookieManager.setValue("playedVideoCount", "0");
	}

	function player_GetPlayedVideoCount()
	{
		var value = cookieManager.getValue("playedVideoCount");
		if(value!=null && value!='')
		{
			value = parseInt(value);	
		}
		else
		{
			value = 0;
		}
		return(value);
	}

	//
	// EVENT HANDLERS
	//
	
	// Updates time info	
	function player_UpdateTimeInfo()
	{
		var div = document.getElementById('currentTime');
		
		if(div)
		{
			var state = this.getPlayState();
			var text;
			
			if((state == (new PlayState()).buffering))
			{
				text = Translate("LOADING") + "...";
			}		
			else
			{
				var duration = this.player.getCurrentMediaDuration();
				var currentPosition = this.player.getPosition();

				var currentMedia = this.getCurrentMedia()
				if(currentMedia)
				{
					if(currentMedia.isLive)
					{
						text = FormatTime(currentPosition);
					}
					else
					{
						text = FormatTime(currentPosition) + ' / ' + FormatTime(duration);
					}
				}
				else
				{
					text = FormatTime(currentPosition) + ' / ' + FormatTime(duration);
				}
			}
			
			div.innerHTML = text;
			if(this.getBitrate() > 0)
			{
				div.innerHTML += "&nbsp;&nbsp;" + parseInt(this.getBitrate(), 10) + "kbps";
			}
		}
	}
	
	// Update position slider
	function player_UpdatePositionSlider()
	{
		var currentMediaDuration;
		
		if(this.positionSlider)
		{			
			// Move the position slider only if it is not being dragged
			if(!this.positionSlider.isDragging)
			{
				currentMediaDuration = this.player.getCurrentMediaDuration();
				this.positionSlider.setValue((currentMediaDuration > 0) ? this.player.getPosition() / currentMediaDuration : 0);
				this.syncPosition();
			}
		}
	}
	
	// Updates the play/pause button
	function player_updatePlayPauseButton()
	{
		var state = this.getPlayState();
		var btnPlay = document.getElementById("btnPlay");
		
		if(btnPlay)
		{
			if(state == 3)
			{
				var currentMedia = this.getCurrentMedia();
				if(currentMedia)
				{
					if(currentMedia.isLive)
					{
						btnPlay.className = "bts stop";
					}
					else
					{
						btnPlay.className = "bts pause";
					}
				}
			}
			else
			{
				btnPlay.className = "bts play";
			}
		}
	}
		
	// Event handler for playstate
	function player_UpdateState()
	{
		// Updates the time info
		this.updateTimeInfo();
		
		// Hides the banner if we're stopped
		if(this.player.getPlayState() < 2)
		{
			this.bufferingIgnoreNext = true;
			ResizeBanner();
		}
		
		// Increments buffering count if the new state is "buffering"
		if(this.getPlayState()==this.playState.buffering && sbrEnabled)
		{
			if(this.bufferingIgnoreNext)
			{
				Verbose('Player is buffering, count not incremented');
			}
			else
			{
				Verbose('Player is buffering');

				// Stores the buffering
				this.bufferingTimes[this.bufferingTimes.length]=new Date();
				
				// Checks if the buffering count has reached the limit
				var bufferingCount = 0;
				var startDate = new Date((new Date().getTime())-sbrBufferingLimitTime*1000);
				for(var i=0;i<this.bufferingTimes.length;i++)
				{
					if(this.bufferingTimes[i]>startDate)
					{
						bufferingCount++;
					}
				}
				
				if(bufferingCount>=sbrBufferingLimit)
				{
					this.bufferingLimitReached = true;
				}
			}
		}
		
		// Clears the ignore buffering flag if the playback started
		if(this.getPlayState()==this.playState.playing)
		{
			this.bufferingIgnoreNext = false;
		}
		
		// After reaching the limit and finished buffering, shows alert
		if(this.getPlayState()==this.playState.playing && this.bufferingLimitReached)
		{
			playerTester.bandwidthBufferLimit();
		}
	}
	
	// Function to be called on media change
	function player_CurrentMediaChange()
	{
		// Loads medias
		var current = playerTerra.getCurrentMedia();
		var currentInternal = this.getCurrentInternalMedia();

		if(current && currentInternal)
		{
			// Syncs the information in the playlist tab
			playlistTerra.syncPlaylistTab();

			// Keeps the mute, in case the player removes it on transition
			this.player.setMute(this.muteMode);

			// Custom start script
			if(currentInternal && currentInternal.startScript && currentInternal.startScript!='')
			{
				Verbose("Start of video script: " + currentInternal.startScript);
				eval(currentInternal.startScript);
			}

			// Don't reload tab if it's in the playlist
			if(playlistTerra.tabCurrent!=2)
			{
				playlistTerra.drawTab(0);
			}

			// Adult popup
			if(current.isAdult)
			{
				this.adultContent();
			}

			// fix the channel title
			ChangeChannelTitle(current.channelTitle);

			// Next item ticker
			this.printNextMedia();

			// Hides timeline for live contents
			var divTimeline = document.getElementById('divTimeline');
			if(currentInternal.isLive)
			{
				// Hides timeline for live signals
				if(divTimeline)
				{
					divTimeline.style.visibility = 'hidden';
				}
			}
			else
			{
				// Shows timeline for ondemand signals
				if(divTimeline)
				{
					divTimeline.style.visibility = 'visible';
				}
			}

			// Shows the "error" page when required
			if(current.showmyservices)
			{
				AccessDeniedVideo(media);
			}

			// Updates player to regular/wide mode
			if(enableUpdateSize)
			{
				var holderObj = document.getElementById('playerHolder');
				if(holderObj)
				{
					if(currentInternal.isWide)
					{
						holderObj.className = 'videoContent wide';
						this.resize(550,310);
					}
					else
					{
						holderObj.className = 'videoContent';
						this.resize(480,360);
					}
				}
			}

			// Updates time display
			this.updateTimeInfo();
		}
	}

	// Moves to the next media when the current one stops	
	function player_MoveToNextMedia()
	{
		var state = this.getPlayState();
		if(state == this.playState.stopped && !this.manualStop)
		{
			var currentMedia = this.getCurrentInternalMedia();
			if(currentMedia && currentMedia.endScript && currentMedia.endScript!='')
			{
				Verbose("End of video script: " + currentMedia.endScript);
				eval(currentMedia.endScript);
			}
		
			if(this.playingAd)
			{
				// Currently playing ad, call playItem on the same media to start the actual video
				this.playItem(this.currentPosition,this.currentRelated);
			}
			else
			{
				// If it's the last video, check for relateds
				var lastPosition = this.currentPlaylist.getCount()-1;
				if(this.currentPosition==lastPosition && !this.repeat)
				{
					var lastMedia = this.currentPlaylist.getItem(lastPosition);
					if(lastMedia.relateds.length>0 && lastMedia.relateds.length>(this.currentRelated+1))
					{
						this.playItem(this.currentPosition,this.currentRelated+1);					
					}
					else
					{
						this.reset();
					}
				}
				else
				{
					// Goes to the next video
					this.next();
				}
			}
		}
	}
	
	function player_AdPost(media)
	{
		// Creates the iframe
		var iframe = document.getElementById('videoAdFrame');
		if(!iframe)
		{
			iframe = document.createElement('iframe');
			iframe.id = 'videoAdFrame';
			iframe.frameBorder = 0;
			iframe.height = 0;
			iframe.width = 0;
			document.body.appendChild(iframe);
		}
		
		// Replaces the "random part in the url"
		var postUrl = new String(media.videoadurl);
		postUrl = postUrl.replace("#random#",currentRandom);
		postUrl = postUrl.replace("%23random%23",currentRandom); // Escaped
		
		// Logs information
		Verbose("Requesting Ad using URL: " + postUrl);
		
		// Posts to the iframe
		iframe = (iframe.frameElement) ? iframe.frameElement : iframe;
		iframe.setAttribute("src", postUrl);
		
		// Starts the monitor
		this.adLoadStart = (new Date()).getTime();
		this.adMonitor();
	}
	
	function player_AdCallback(mi)
	{
		// Clears the monitor timer
		window.clearTimeout(this.adMonitorTimer);

		var playbackUrl = mi.getUrl(0);
		this.playingAd = true;
		
		// Logs callbacl information
		Verbose("Ad received, playback URL: " + playbackUrl);

		if(playbackUrl && playbackUrl!='')
		{
			// Starts playback of the ad
			this.currentAdObject = mi;
			this.playUrl(playbackUrl);
		}
		else
		{
			// No ad, goes straight to the video
			this.playItem(this.currentPosition,this.currentRelated);
		}
	}
	
	function player_AdMonitor()
	{
		if((new Date()).getTime()-this.adLoadStart > externalAdTimeout * 1000)
		{
			// Prevents the iframe from proceeding
			var iframe = document.getElementById('videoAdFrame');
			if(iframe)
			{
				iframe = (iframe.frameElement) ? iframe.frameElement : iframe;
				iframe.setAttribute("src","");
			}
			
			Verbose("Ad timeout, proceeding to video playback");
			
			// Proceeds to the video itself
			this.playingAd = true;
			this.playItem(this.currentPosition,this.currentRelated);
		}
		else
		{
			this.adMonitorTimer = window.setTimeout('playerTerra.adMonitor()',1000)
		}
	}
	
	function player_AdultContent()
	{
		if(!cookieManager.getValue("adult"))
		{
			var playerObject = document.getElementById("playerHtml");
			var alertBox = document.getElementById("playerWarning");
			var adultBox = document.getElementById("adultWarning");
			
			if(playerObject && alertBox && adultBox)
			{
				playerObject.style.visibility = "hidden";
				alertBox.className = "aviso";
				adultBox.className = "adulto";
			}
			
			// Grabs the current player ID
			this.beforeDiscContent = playerTerra.getCurrentMedia().id;
			this.manualStop = true;
			this.player.stop();
		}
	}

	function player_AdultAccept()
	{
		// Stores values in cookie
		cookieManager.setValue("adult", true);
		
		// Displays back the player
		var playerObject = document.getElementById("playerHtml");
		var alertBox = document.getElementById("playerWarning");
		var adultBox = document.getElementById("adultWarning");
		
		if(playerObject && alertBox && adultBox)
		{
			playerObject.style.visibility = "visible";
			alertBox.className = "aviso none";
			adultBox.className = "adulto none";
		}
		
		// Locates the previously playing item
		for(var i = 0; i < playlistTerra.getCount(); i++)
		{
			var tempItem = playlistTerra.getItem(i);
			if(tempItem.id==this.beforeDiscContent)
			{
				this.playItem(i,-1);
				return;
			}
		}
	}
	
	function player_AdultRefuse()
	{
		// Gets only the "regular" items
		var temp = new Array();
		for(var i = 0; i < playlistTerra.getCount(); i++)
		{
			var tempItem = playlistTerra.getItem(i);
			if(!tempItem.isAdult)
			{
				temp.push(tempItem);
			}
		}
		
		// Clears the playlist
		playlistTerra.clear();
		
		// Readds the "regular" items
		for(var i = 0;i < temp.length; i++)
		{
			playlistTerra.add(temp[i]);
		}
		
		// Displays back the player
		var playerObject = document.getElementById("playerHtml");
		var alertBox = document.getElementById("playerWarning");
		var adultBox = document.getElementById("adultWarning");
		
		if(playerObject && alertBox && adultBox)
		{
			playerObject.style.visibility = "visible";
			alertBox.className = "aviso none";
			adultBox.className = "adulto none";
		}
	}
	
		
	function player_PrintNextMedia()
	{
		// Prints the "next video" display
		var obj = document.getElementById('nextVideoTicker');
		if(obj)
		{
			if(playerTerra && this.currentPosition>=0)
			{
				var nextItem;
				var nextPos = -1;
				var nextRelated = -1;
				var maxPos = this.currentPlaylist.getCount() - 1;
				var maxRelated = this.currentPlaylist.getItem(this.currentPosition).relateds.length - 1;
				if(maxPos>=0)
				{
					// Checks if it's playing a regular item
					if(this.currentPosition<maxPos)
					{
						nextPos = this.currentPosition+1;
						nextItem = playlistTerra.getItem(nextPos);
					}
					else
					{
						// Checks if it's a related item
						if(this.currentPosition==maxPos && this.currentRelated<maxRelated)
						{
							nextPos = this.currentPosition;
							nextRelated = this.currentRelated+1;
							nextItem = this.currentPlaylist.getItem(nextPos).relateds[nextRelated];
						}
					}
				}
				
				if(nextItem)
				{
					obj.innerHTML = '<a href="#" onclick="playerTerra.playItem(' + nextPos + ',' + nextRelated + ')"><strong>' + Translate('NEXT_ITEM') + '</strong>' + ': ' + nextItem.title + '</a>';
				}
				else
				{
					obj.innerHTML = '';
				}
			}
		}
	}
}
// Object for bandwidth testing
function SpeedTester(objectName, numTests, fileUrl, fileSize)
{
	// Object name
	this.objectName = objectName;

	// Number of tests to be run
	this.numTests = numTests;

	// Data of the test file
	this.fileUrl = fileUrl;
	this.fileSize = fileSize;

	// Speed for each attempt will be stored here
	this.connectionSpeed = new Array();

	// Image used in the current test
	this.imageTest = null;

	// Stores the start and end times of each test
	this.startTest = null;
	this.endTest = null;
	
	// Stores the callback to be used on testing
	this.finishedCallback = null;
	this.statusUpdateCallback = null;

	// Methods
	this.test = speedTester_Test;
	this.testCallback = speedTester_TestCallback;

	function speedTester_Test(finishedCallback, statusUpdateCallback)
	{
		// Stores the callback method
		if(finishedCallback) this.finishedCallback = finishedCallback;
		if(statusUpdateCallback) this.statusUpdateCallback = statusUpdateCallback;
	
		// Stores the start time
		this.startTest = (new Date()).getTime();

		// Appens a timestamp to make sure the file won't be cached
		var url = this.fileUrl + '?ts=' + escape(this.startTest);
		
		// Loads the test image
		this.imageTest = new Image();
		this.imageTest.onload = new Function(this.objectName + '.testCallback();');
		this.imageTest.src = url;
	}

	function speedTester_TestCallback()
	{
		// Gets the end date
		this.endTest = (new Date()).getTime();
		
		// Gets the connection speed
		var bits = this.fileSize * 8;
		var seconds = (this.endTest - this.startTest) / 1000;
		this.connectionSpeed[this.connectionSpeed.length] = Math.floor((bits/seconds)/1024);

		// Executes the required number of tests
		if(this.connectionSpeed.length<this.numTests)
		{
			// call status update
			this.statusUpdateCallback(((this.numTests/100)*this.connectionSpeed.length)*1000);
			this.test();
		}
		else
		{
			// Gets the average speed of the tests
			var total = 0;
			for(var i=0;i<this.connectionSpeed.length;i++)
			{
				total += this.connectionSpeed[i];
			}
			var averageSpeed = Math.floor(total/this.connectionSpeed.length);
			
			// Calls the post-test action
			if(this.finishedCallback)
			{
				this.finishedCallback(averageSpeed);
			}
			
			// Clears test data
			this.connectionSpeed = new Array();
			this.imageTest = null;
			this.startTes = null;
			this.endTest = null;
			this.finishedCallback = null;
		}
	}
}
function PlayerTester()
{
	// Bandwidth test methods
	this.bandwidthTest = player_BandwidthTest;
	this.bandwidthTestStatusUpdate = player_BandwidthTestStatusUpdate;
	this.bandwidthTestFinished = player_BandwidthTestFinished;
	this.bandwidthBufferLimit = player_BandwidthBufferLimit;

	this.bandwidthTester = new SpeedTester('playerTester.bandwidthTester',sbrTestCount,sbrTestImage,sbrTestImageSize);

	// Bandwidth test settings
	this.currentBandwidth = 0;
	this.bandwidthTestFinishedUrl = null;

	// Loads bandwidth
	var bandwidth = cookieManagerSettings.getValue('bandwidth');
	if(bandwidth)
	{
		Verbose('Bandwidth loaded from cookie: ' + bandwidth);
		this.currentBandwidth = parseInt(bandwidth,10);
	}
		
	function player_BandwidthTest(forceTest)
	{
		// Attempts to load from cookie
		var bandwidth = cookieManagerSettings.getValue('bandwidth');
		if(bandwidth && !forceTest)
		{
			// Loaded from cookie
			Verbose('Bandwidth loaded from cookie: ' + bandwidth);
			this.currentBandwidth = parseInt(bandwidth,10);
		}
		else
		{
			// Changes layout
			var oDvConfigBox = document.getElementById('dvConfigBox');
			if(!oDvConfigBox) return;
			oDvConfigBox.style.display='block';

			var cHtml = '';
			
			cHtml += '	<div class="ico"></div>';
			cHtml += '	<a href="#" onclick="javascript:HideConfigBox()" title="' + Translate('CLOSE') + '" class=close>' + Translate('CLOSE') + '</a>';
			cHtml += '	<h3>' + Translate('CONFIG_TEST_TITLE') + '</h3>';
			cHtml += '	<h4>' + Translate('CONFIG_TEST_DESCRIPTION') + '</h4>';
			cHtml += '	<div class="loadBar">';
			cHtml += '		<span>';
			cHtml += '			<img src="../imagesES/spacer.gif" alt="' + Translate('LOADING') + '" style="width:1px;" id="imgLoadBarSpacer" />';
			cHtml += '		</span>';
			cHtml += '	</div>';

			oDvConfigBox.innerHTML = cHtml;

			// Execute test
			Verbose('Starting bandwidth test');
			this.bandwidthTester.test(new Function('bandwidth','playerTester.bandwidthTestFinished(bandwidth)'), new Function('bandwidthstatusupdate','playerTester.bandwidthTestStatusUpdate(bandwidthstatusupdate)'));
		}
	}
	
	function player_BandwidthTestStatusUpdate(percentCompleted)
	{
		var oImgLoadBar = document.getElementById('imgLoadBarSpacer');
		if(!oImgLoadBar) return;

		oImgLoadBar.style.width = (percentCompleted * 2) + 'px';
	}

	function player_BandwidthTestFinished(bandwidth)
	{
		Verbose('Bandwidth test result: ' + bandwidth + 'kbps');

		// Restores layout
		var oDvConfigBox = document.getElementById('dvConfigBox');
		if(!oDvConfigBox) return;
		oDvConfigBox.style.display='block';

		var cHtml = '<div class="ico"></div>';
		cHtml += '<a href="#" onclick="javascript:HideConfigBox()" title="' + Translate("CLOSE") + '" class="close">' + Translate("CLOSE") + '</a>';
		cHtml += '<h3>' + Translate('CONFIG_RESULT_TITLE') +  ' ' + bandwidth + 'Kbps.</h3>';
		cHtml += '<p>' + Translate('CONFIG_RESULT_DESCRIPTION') + '</p>';
		cHtml += '<ul>';
		cHtml += '<form name="frmVelocidades">';
		for(var i=0;i<sbrSpeeds.length;i++)
		{
			cHtml += '	<li><input name="rbVelocidade" type="radio" value="' + sbrSpeeds[i] + '" /><label>' + sbrSpeeds[i] + 'Kbps</label></li>';
		}
		cHtml += '</form>';
		cHtml += '</ul>';
		cHtml += '<a href="#" onclick="javascript:ConfirmConfigBox()" title="' + Translate('CONFIG_RESULT_CONFIRM') + '" class="btn"><strong>' + Translate('CONFIG_RESULT_CONFIRM') + '</strong></a>';
		cHtml += '<a href="#" onclick="javascript:ShowConfigBox(true)" title="' + Translate('CONFIG_RESULT_AUTOCONFIG') + '" class="btn">' + Translate('CONFIG_RESULT_AUTOCONFIG') + '</a>';

		oDvConfigBox.innerHTML = cHtml;

		cookieManagerSettings.setValue('bandwidth',bandwidth);
		this.currentBandwidth = bandwidth;
		PreSelectConfigBox(bandwidth);
		//this.playUrl(this.bandwidthTestFinishedUrl);
	}

	function player_BandwidthBufferLimit()
	{
		if(!playerTerra.bufferingNotified)
		{
			playerTerra.play();

			Verbose('Bandwidth limit reached');
			
			// Marks that we already notified it once
			playerTerra.bufferingNotified = true;

			// Removes control flag	
			playerTerra.bufferingLimitReached = true;

			// pop-up the config window
			var oDvConfigBox = document.getElementById('dvConfigBox');
			if(!oDvConfigBox) return;

			var cHtml = '<div class="ico"></div>';
			cHtml += '<a href="#" onclick="javascript:HideConfigBox()" title=fechar class=close>fechar</a>';
			cHtml += '<h3>' + Translate('CONFIG_ERROR_TITLE') + ' ' + this.currentBandwidth + ' Kbps</h3>';
			cHtml += '<p>' + Translate('CONFIG_ERROR_DESCRIPTION') + '</p>';
			cHtml += '<a href="#" onclick="javascript:ShowConfigBox(true)" title="' + Translate('CONFIG_ERROR_CONFIG') + '" class="btn"><strong>' + Translate('CONFIG_ERROR_CONFIG') + '</strong></a>';
			cHtml += '<a href="#" onclick="javascript:CancelConfigBox()" title="' + Translate('CONFIG_ERROR_CANCEL') + '" class="btn">' + Translate('CONFIG_ERROR_CANCEL') + '</a>';

			oDvConfigBox.innerHTML = cHtml;
			oDvConfigBox.style.display='block';
		}
	}

}

function PlaylistTerra() 
{
	// ************************************************************************************************
	// *** Interface
	// ************************************************************************************************
	
	// Fields
	// ******
	this.playlist = new Playlist();

	// Methods
	// *******	
	this.add = pl_Add;
	this.move = pl_Move;
	this.remove = pl_Remove;
	this.clear = pl_Clear;
	this.getItem = pl_GetItem;
	this.getCount = pl_GetCount;
	this.getDuration = pl_GetDuration;
	this.syncCookie = pl_SyncCookie;
	this.drawTab = pl_DrawTab;
	this.syncPlaylistTab = pl_SyncPlaylistTab;
	this.lockTabs = pl_LockTabs;
	this.unlockTabs = pl_UnlockTabs;
	this.updateTabs = pl_UpdateTabs;
	this.updateTicker = pl_UpdateTicker;
	this.sync = pl_Sync;
	this.checkRedirect = pl_CheckRedirect;
	
	// Informs the current tab state
	this.tabCurrent = 0;
	this.tabLocked = false;

	// Don't use the standard playlist ad management
	this.playlist.adsFrequency = 0;
	this.playlist.maxAdsFirst = 0;
	this.playlist.maxAds = 0;

	// ************************************************************************************************
	// *** Implementation
	// ************************************************************************************************	

	// Adds a mediaitem to the playlist
	function pl_Add(item) 
	{
		// Insert the media item into wrapped playlist
		this.playlist.appendItem(item);
	}
	
	// Moves a mediaitem in the playlist
	function pl_Move(oldIndex, newIndex) 
	{
		// Blocks invalid moving
		if(oldIndex<0 || oldIndex>=this.getCount()) return;
		if(newIndex<0 || newIndex>=this.getCount()) return;
	
		// Insert the media item into wrapped playlist
		this.playlist.moveItem(oldIndex, newIndex);
		
		// Corrects current position if necessary
		if(oldIndex<playerTerra.currentPosition && newIndex>=playerTerra.currentPosition)
		{
			playerTerra.currentPosition--;
		}
		if(oldIndex>playerTerra.currentPosition && newIndex<=playerTerra.currentPosition)
		{
			playerTerra.currentPosition++;
		}
		
		// Syncs layout and information
		this.sync();
	}
	
	// Removes a mediaitem from the playlist
	function pl_Remove(index) 
	{
		// Blocks removing of current item
		if(playerTerra.getCurrentIndex()==index) return;
	
		// Insert the media item into wrapped playlist
		this.playlist.removeAt(index);
		
		// Corrects current position if necessary
		if(playerTerra.currentPosition>=0 && playerTerra.currentPosition>index)
		{
			playerTerra.currentPosition--;
		}
		
		// Syncs layout and information
		this.sync();
	}
	
	// Clears the playlist
	function pl_Clear()
	{
		// Stops player
		playerTerra.stop();
	
		// Clear internal playlist
		this.playlist.clear();
		
		// Syncs layout and information
		this.sync();
	}	
	
	// Gets the media item located at the index position
	function pl_GetItem(index) 
	{
		//Gets the item from the wrapped playlist
		return (this.playlist.getItem(index));
	}
	
	// Returns the size of playlist
	function pl_GetCount() 
	{
		return (this.playlist.count());
	}
	
	// Retuns the duration in seconds of the playlist
	function pl_GetDuration()
	{
		return (this.playlist.getDuration());
	}

	// Stores the current playlist IDs do a cookie
	function pl_SyncCookie()
	{
		var idList = "";
		
		for(var i = 0; i < this.playlist.count(); i++)
		{
			var item = this.getItem(i);
			if(i > 0)
			{
				idList += ",";
			}
			idList += item.id;
		}
		
		cookieManager.setValue("playlist", idList);
	}
	
	// Draws the current playlist tab
	function pl_DrawTab(tab)
	{
		this.tabCurrent = tab;

		// Aborts if player not loaded
		if(!playerTerra) return;
		
		// Aborts if the tabs are locked
		if(this.tabLocked) return;
		
		// Aborts if tabs not visible
		if(!document.getElementById('playlistHolder')) return;
	
		// Gets the current content id
		var currentContent = 0;
		var currentMedia = playerTerra.getCurrentMedia();
		if(currentMedia) currentContent = currentMedia.id;
	
		// Media for related calls may be different, if we're play a related
		var currentContentRelated = 0;
		if(playerTerra.playingRelated)
		{
			var currentMediaRelated = playerTerra.currentPlaylist.getItem(playerTerra.currentPosition)
			if(currentMediaRelated) currentContentRelated = currentMediaRelated.id;
		}
		else
		{
			currentContentRelated = currentContent;
		}
	
		// Gets the current playlist
		var currentPlaylist = '';
		for(var i=0;i<playlistTerra.getCount();i++)
		{
			if(i>0) currentPlaylist += ',';
			currentPlaylist += playlistTerra.getItem(i).id;
		}
	
		switch(tab)
		{
			case 0:
				getAjaxContentNoCache('playlistHolder','Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.PlayerBoxDetailsView&page=genericAjax_aspx&p1=' + currentContent + '&p2=' + currentPlaylist,true, null);
				break;
			case 1:
				getAjaxContentNoCache('playlistHolder','Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.PlayerBoxRelatedsView&page=genericAjax_aspx&p1=' + currentContentRelated + '&p2=' + currentPlaylist, true, null);
				break;
			case 2:
				getAjaxContentNoCache('playlistHolder','Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.PlayerBoxPlaylistView&page=genericAjax_aspx&p1=' + currentContent + '&p2=' + currentPlaylist, true, null);
		}
	}
	
	function pl_SyncPlaylistTab()
	{
		// Updates current display
		var current = playerTerra.getCurrentIndex();
		var count = this.getCount();
		for(var i=0;i<count;i++)
		{
			var obj = document.getElementById('playlistItem_' + i);
			if(obj)
			{
				if(current==i)
				{
					obj.className = 'selected';
				}
				else
				{
					obj.className = '';				
				}
			}
		}
		
		// Updates shuffle and repeat button
		var btnRepeat = document.getElementById("btnRepeat");
		if(btnRepeat)
		{
			if(playerTerra.getRepeat())
			{
				btnRepeat.className = "loop selected";
			}
			else
			{
				btnRepeat.className = "loop";
			}
		}
		
		// Updates shuffle and repeat button
		var btnShuffle = document.getElementById("btnShuffle");
		if(btnShuffle)
		{
			if(playerTerra.getShuffle())
			{
				btnShuffle.className = "shuffle selected";
			}
			else
			{
				btnShuffle.className = "shuffle";
			}
		}
	}
	
	// Locks tabs, to be used before calling login, sendvideos or other blocking screens
	function pl_LockTabs()
	{
		this.tabLocked = true;
	}

	// Returns tabs to previous state
	function pl_UnlockTabs()
	{
		this.tabLocked = false;
		this.UpdateTabs();
	}
	
	// Updates current tab
	function pl_UpdateTabs()
	{
		this.drawTab(this.tabCurrent);
	}
	
	// Updates ticker
	function pl_UpdateTicker()
	{
		var tickerObj = document.getElementById('playlistTicker');
		if(tickerObj)
		{
			var count = this.getCount();
			
			var link;
			if(count>0)
			{
				link = 'if(playlistTerra.checkRedirect(true)) playerTerra.playItem(0,-1); return(false);'
				tickerObj.className = '';
			}
			else
			{
				link = 'return(false)';
				tickerObj.className = 'empty';
			}
			
			var html = '';
			html += Translate("PLAYLIST");
			html += ' <span>(' + count + ')</span>';
			tickerObj.onclick = new Function(link);
			tickerObj.innerHTML = html;
		}
	}
	
	// Updates the layout and cookies to the current information
	function pl_Sync()
	{
		// Clears cookie
		this.syncCookie();
		
		// Updates playlist
		this.updateTabs();
		
		// Update ticker
		this.updateTicker();
	}
	
	// Performs a redirect if the current page does not have a player
	function pl_CheckRedirect(performRedirect, startItem)
	{
		if(!playerTerra)
		{
			if(this.getCount()>0)
			{
				if(!startItem) startItem = 0;
				var url = 'channelContents.aspx?channel=' + this.getItem(startItem).channel + '&play=true';
				if(startItem)
				{
					url += '&start=' + startItem;
				}
				if(performRedirect) document.location = url;
				return(false);
			}
		}
		return(true);
	}
}
// Objects
var playerTerra;
var playerTester;
var playlistTerra = new PlaylistTerra('playlistTerra');
var ajaxManager = new AjaxManager("ajaxManager", false);
var ajaxTools = new AjaxTools();
var privateList = new Array();

// Player add queuing
var loadingMedia = false;
var loadingMediaQueue = new Array();

// Player Settings
var enableUpdateSize = true;
var playerWidth = 480;
var playerHeight = 360;
var slideWidth = 310;

// Tester
playerTester = new PlayerTester();

// ********************************************************************************
// Initialization
// ********************************************************************************
function Initialize()
{
	// Player
	var direction = new DragDirection();
	playerTerra = new PlayerTerra('playerHtml', GetPlayerType());
	playerTerra.setCurrentPlaylist(playlistTerra);
	
	// Volume Slider
	playerTerra.volumeSlider = new DragItem(document.getElementById('volumePointer'), document.getElementById('volumeResize'), -1, 45, direction.horizontal);
	playerTerra.volumeSlider.onDragFinish.add('playerTerra', 'sliderVolume');
	playerTerra.volumeSlider.onDrag.add('playerTerra', 'sliderVolume');
	playerTerra.volumeSlider.onDrag.add('playerTerra', 'syncVolume');
	
	// Position slider
	playerTerra.positionSlider = new DragItem(document.getElementById('positionPointer'), document.getElementById('positionResize'), -1, slideWidth, direction.horizontal);
	playerTerra.positionSlider.onDragFinish.add('playerTerra', 'setPosition');
	playerTerra.positionSlider.onDrag.add('playerTerra', 'syncPosition');
	
	// Drag & drop
	ddItems.push(playerTerra.volumeSlider);
	ddItems.push(playerTerra.positionSlider);

	// Initial volume
	playerTerra.setVolume(50); 
	
	// Loads playlist from cookie
	LoadPlaylistFromCookie();
}

function CheckInitialize()
{
	var playerType = GetPlayerType();

	var playerHtml = document.getElementById("playerHtml");
	var dragVolume = document.getElementById("volumePointer");
	var dragBar = document.getElementById("volumeResize");

	var proceed = true;
	
	// Checks for the player object itself
	if(proceed && !document.getElementById("playerHtml")) proceed = false;

	// Checks for the drag objects
	if(proceed && !document.getElementById("positionPointer")) proceed = false;
	if(proceed && !document.getElementById("volumePointer")) proceed = false;
	if(proceed && !document.getElementById("positionResize")) proceed = false;
	if(proceed && !document.getElementById("volumeResize")) proceed = false;

	// Object/specific checks 
	
	// Windows-Media
	if(proceed && (playerType == 1 || playerType==4))
	{
		if(!document.getElementById("playerHtml").settings) proceed = false;
	}

	// Silverlight
	if(proceed && playerType == 3)
	{
		try
		{
			if((document.getElementById("playerHtml").Content.findName("media")))
			{
				// Hides fullscreen button
				var fsButton = document.getElementById('fullscreenButton');
				if(fsButton)
				{
					fsButton.style.display = 'none';
				}
			}
		}
		catch(e)
		{
			proceed = false;
		}
	}
		
	if(proceed)
	{
		Initialize();
	}
	else
	{
		setTimeout("CheckInitialize()", 1000);
	}
}

// ********************************************************************************
// Media Loading
// ********************************************************************************
function LoadPlaylistFromCookie()
{
	var playlistCookie = cookieManager.getValue("playlist");
	if(playlistCookie && playlistCookie != "")
	{
		if(playerTerra)
		{
			Add(playlistCookie, videoMediaIndex, true);
		}
		else
		{
			Add(playlistCookie, videoMediaIndex, false);
		}
	}
	Verbose('Loading playlist from cookie');
}

function Play(id, mediaType)
{
	scrollTo(0,0);
	Add(id, mediaType, true);
}

function Add(items, mediaType, canplay)
{
	if(CheckBrowser())
	{
		if(!loadingMedia)
		{
			Verbose('Loading item');
			loadingMedia = true;
		
			var idList = "";
			if(items.length && !items.split)
			{
				for(i = 0; i < items.length; i++)
				{
					if(i > 0)
					{
						idList += ",";
					}
					idList += items[i].id;
				}
			}
			else
			{
				idList = items;
			}
			
			ajaxManager.Add("Ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.AjaxMediaXml&page=genericAjax_aspx&p1=" + idList + "&p2=" + mediaType + "&p3=" + allowDefault + "&p4=" + allowRelated + "&p5=" + allowVideoAd, ParseMediaXml, CreateLoading, DestroyLoading, DestroyLoading, canplay, null);
		}
		else
		{
			Verbose('Item added to queue');
			var script = 'Add(' + items + ',' + mediaType + ',' + canplay + ');'
			loadingMediaQueue.push(script);
		}
	}
}

function ParseMediaXml()
{
	if(this.httpRequest.status == 200)
	{
		var xml = this.httpRequest.responseXML;
		var rootNode = ajaxTools.SelectSingleNode(xml,'tvterra');
		var mediaNodes = ajaxTools.SelectNodes(rootNode,'media');
		
		// Checks if we should start playback now
		var startPlayback = false;
		var startIndex;
		
		// Start playback if the user requested
		if(this.parameters)
		{
			startPlayback = true;
			
			if(cookieStartIndex>=0)
			{
				startIndex = cookieStartIndex; // Stats from the item specified in the querystring
				cookieStartIndex = -1;
			}
			else
			{
				startIndex = playlistTerra.getCount(); // Stats from the last item
			}
		}
		
		if(playerTerra)
		{
			// Start playback if we're currently playing a related
			if(playerTerra.playingRelated)
			{
				startPlayback = true;
				startIndex = playlistTerra.getCount(); // Stats from the last item
			}
			
			// Start playback if the player is open and currently playing nothing
			if(playerTerra.getPlayState()==playerTerra.playState.stopped)
			{
				startPlayback = true;
				startIndex = 0;
			}
		}
		
		// Loads all media items, and stores errors
		var addedList = new Array();
		var loadVideoError;
		for(var k = 0; k < mediaNodes.length; k++)
		{
			var mi = GetMediaItem(mediaNodes[k]);
			
			// Ignores items without URL
			if(mi.getUrl(0)!='')
			{
				if(mi.isPrivate)
				{
					privateList.push(mi);
				}
				else
				{
					addedList.push(mi);
					playlistTerra.add(mi);
				}
			}
			else
			{
				// Proper error messages
				if(mi.ispublished)
				{
					loadVideoError = Translate("VIDEO_NOT_AVAILABLE");
				}
				else
				{
					loadVideoError = Translate("VIDEO_NOT_PUBLISHED");
				}
			}
		}
		if(loadVideoError)
		{
			alert(loadVideoError);
		}
		
		// Updates tab to update the playlist data
		playlistTerra.sync();
		
		// Updates next item
		if(playerTerra) playerTerra.printNextMedia();		

		// Displays warning if at least one item was denied
		if(privateList.length > 0)
		{
			if((!logged) && (!anonymousMode))
			{
				ShowLoginBox();
			}
			else
			{
				AccessDeniedVideo(privateList[0]);
				privateList = new Array();
			}		
		}
		
		loadingMedia = false;
		if(startPlayback && addedList.length>0)
		{
			// Only allows redirecting if there are no "access denied" videos
			if(playlistTerra.checkRedirect(privateList.length==0,startIndex))
			{
				// Start playback if possible
				playerTerra.playItem(startIndex,-1);
			}
		}
		else
		{
			// Adds next items from the queue to the list
			if(loadingMediaQueue.length>0)
			{
				Verbose('Loading next item from queue');
				var script = loadingMediaQueue.shift();
				window.setTimeout(script,100);
			}
		}
	}
}

function GetMediaItem(mediaItemNode,isrelated)
{
	var mi = new MediaItem();
	mi.id = mediaItemNode.attributes.getNamedItem("id").value;
	mi.originalid = mediaItemNode.attributes.getNamedItem("originalid").value;
	mi.title = mediaItemNode.attributes.getNamedItem("title").value;
	mi.image = mediaItemNode.attributes.getNamedItem("image").value;
	mi.isPublished = mediaItemNode.attributes.getNamedItem("ispublished").value == "True";
	mi.isLive = mediaItemNode.attributes.getNamedItem("islive").value == "True";
	mi.isAdult = mediaItemNode.attributes.getNamedItem("isadult").value == "True";
	mi.isPrivate = mediaItemNode.attributes.getNamedItem("isprivate").value == "True";
	mi.duration = mediaItemNode.attributes.getNamedItem("duration").value;
	mi.channel = mediaItemNode.attributes.getNamedItem("channel").value;
	mi.channelTitle = mediaItemNode.attributes.getNamedItem("channeltitle").value;
	mi.source = mediaItemNode.attributes.getNamedItem("source").value;
	mi.sourceTitle = mediaItemNode.attributes.getNamedItem("sourcetitle").value;
	mi.provider = mediaItemNode.attributes.getNamedItem("provider").value;
	mi.mediaType = mediaItemNode.attributes.getNamedItem("mediatype").value;
	mi.isWide = mediaItemNode.attributes.getNamedItem("iswide").value == "True";
	mi.showmyservices = mediaItemNode.attributes.getNamedItem("showmyservices").value == "True";
	mi.playertag = mediaItemNode.attributes.getNamedItem("playertag").value;
	mi.videoadurl = mediaItemNode.attributes.getNamedItem("videoadurl").value;
	mi.startScript = mediaItemNode.attributes.getNamedItem("startscript").value;
	mi.endScript = mediaItemNode.attributes.getNamedItem("endscript").value;
	mi.adFrequency = mediaItemNode.attributes.getNamedItem("adfrequency").value;
	mi.bannerUrl = mediaItemNode.attributes.getNamedItem("bannerurl").value;
	mi.sponsorUrl = mediaItemNode.attributes.getNamedItem("sponsorurl").value;
	mi.syncBannerUrl = mediaItemNode.attributes.getNamedItem("syncbannerurl").value;
	mi.syncBigBannerUrl = mediaItemNode.attributes.getNamedItem("syncbigbannerurl").value;
	mi.syncSponsorUrl = mediaItemNode.attributes.getNamedItem("syncsponsorurl").value;
	mi.isrelated = isrelated;
	
	mi.setUrl(0, mediaItemNode.attributes.getNamedItem("url").value);
	
	// Short title
	mi.shortTitle = mi.title;
	if(mi.shortTitle.length>25)
	{
		mi.shortTitle = mi.shortTitle.substring(0,25);
	}
	
	// Loads related medias
	mi.relateds = new Array();
	var relatedNodes = ajaxTools.SelectNodes(mediaItemNode, "related");
	for(var i = 0; i < relatedNodes.length; i++)
	{
		var miRelated = GetMediaItem(relatedNodes[i],true);
		if(miRelated.getUrl(0) && miRelated.getUrl(0) != "")
		{
			mi.relateds.push(miRelated);
		}
	}
	
	// Related medias should show the same related videos as the parent media
	for(var i = 0; i < mi.relateds.length; i++)
	{
		mi.relateds[i].relateds = mi.relateds;
	}

	return mi;
}

// ********************************************************************************
// Player rendering
// ********************************************************************************
function RenderPlayer()
{
	if(CheckBrowser())
	{
		switch (GetPlayerType())
		{
			case 0:
				break;
			case 1:
				RenderWindowsMediaPlayer(false);
				break;
			case 2:
				RenderQuickTime();
				break;
			case 3:
				RenderSilverlightPlayer();
				break;
			case 4:
				RenderWindowsMediaPlayer(true);
		}
		
		// Checks for player initialization
		CheckInitialize();
	}
}

function RenderWindowsMediaPlayer(firefoxPlugin)
{
	if(firefoxPlugin)
	{
		document.write('<OBJECT id=\"playerHtml\" name=\"playerHtml\" type=\"application/x-ms-wmp\" width=\"' + playerWidth + '\" height=\"' + playerHeight + '\" ' + metricPlayerTag + '>\n');
		enableUpdateSize = false;
	}
	else
	{
		document.write('<OBJECT id=\"playerHtml\" name=\"playerHtml\" CLASSID=\"CLSID:6BF52A52-394A-11d3-B153-00C04F79FAA6\" width=\"' + playerWidth + '\" height=\"' + playerHeight + '\" ' + metricPlayerTag + '>\n');
	}
	document.write('<param name=\"URL\" value=\"\">\n');
	document.write('<param name=\"AutoStart\" value=\"False\">\n');
	document.write('<param name=\"TransparentAtStart\" value=\"0\">\n');
	document.write('<param name=\"ShowStatusBar\" value=\"0\">\n');
	document.write('<param name=\"ShowDisplay\" value=\"0\">\n');
	document.write('<param name=\"AutoSize value=\"0\">\n');
	document.write('<param name=\"UImode\" value=\"none\">\n');
	document.write('<param name=\"AnimationAtStart\" value=\"True\">\n');
	document.write('<param name=\"StretchToFit\" value=\"True\">\n');
	document.write('<param name=\"EnableContextMenu\" value=\"False\">\n');
	document.write('</OBJECT>\n');
	
	if(lcEnabled)
	{
		document.write('<DIV id="lcAuditDiv" style="width: 0px; height: 0px; background: red; z-index: -1; visibility: hidden; overflow: hidden;"></DIV>\n');
		document.write('<SCRIPT language="JavaScript" for="playerHtml" event="playStateChange(newState)">\n');
		document.write('var mediaPlayer = document.getElementById("playerHtml");\n');
		document.write('var bannerDiv = document.getElementById("lcBannerDiv");\n');
		document.write('var auditDiv = document.getElementById("lcAuditDiv");\n');
		document.write('lcUpdatePlaylistState(mediaPlayer, auditDiv, bannerDiv, newState)\n');
		document.write('</SCRIPT>\n');
		
		// Workaround for LC. Their scripts do not show/hide the SyncBanner DIV as necessary
		document.write('<SCRIPT language="JavaScript" for="playerHtml" event="mediaChange(newState)">\n');
		document.write('var currItem = playerTerra.player.playerObject.currentMedia;\n');
		document.write('var internalItem = playerTerra.getCurrentInternalMedia();\n');
		document.write('var bannerUrl = currItem.getItemInfo("IAB_URL");\n');
		document.write('var bannerClick = currItem.getItemInfo("IAB_CLICKTHRU");\n');
		document.write('var auditUrl = currItem.getItemInfo("LCAUDIT");\n');
		document.write('var bannerDiv = document.getElementById("publicidadeLc");\n');
		document.write('var sideBannerDiv = document.getElementById("publicidade");\n');
		document.write('if((bannerUrl!="" || bannerClick!="") && auditUrl!="")\n')
		document.write('{\n')
		document.write('if(bannerDiv) bannerDiv.style.visibility="visible";\n')
		document.write('if(sideBannerDiv) sideBannerDiv.style.visibility="hidden";\n')
		document.write('}\n')
		document.write('else\n')
		document.write('{\n')
		document.write('if(bannerDiv) bannerDiv.style.visibility="hidden";\n')
		document.write('if(sideBannerDiv) sideBannerDiv.style.visibility="visible";\n')
		document.write('}\n')
		
		// Adjusts banner to wide mode
		document.write('if(bannerDiv && internalItem && internalItem.isWide && enableUpdateSize)\n');
		document.write('{\n')
		document.write('bannerDiv.className="bannerSide lightningCastWide";\n')
		document.write('}\n')
		document.write('else\n')
		document.write('{\n')
		document.write('bannerDiv.className="bannerSide lightningCast";\n')
		document.write('}\n')

		document.write('</SCRIPT>\n');
	}
}

function RenderQuickTime()
{
	document.write("<EMBED width=\"" + playerWidth + "\" height=\"" + playerHeight + "\"\n");
	document.write("controller=\"False\" \n");
	document.write("src=\"\" \n");
	document.write("scale=\"ASPECT\" \n");
	document.write("TYPE=\"video/quicktime\"\n");
	document.write("PLUGINSPAGE=\"www.apple.com/quicktime/download\"\n");
	document.write("name=\"playerHtml\"\n");
	document.write("id=\"playerHtml\"\n");
	document.write("enablejavascript=\"true\"\n");
	document.write("volume=\"50\"\n");
	document.write("bgcolor=\"#000000\">\n");
	document.write("</EMBED>\n");
	enableUpdateSize = false;
}

function RenderSilverlightPlayer()
{
	RenderSilverlight(playerWidth, playerHeight, "playerHost");
}

// ********************************************************************************
// Banner
// ********************************************************************************
function RenderBanner(bannerUrl,bigBannerUrl,sponsorUrl,sponsor,expanded,wide)
{
	var msg = '';
	msg += 'RenderBanner called\n';
	msg += 'bannerUrl: ' + bannerUrl + '\n';
	msg += 'bigBannerUrl: ' + bigBannerUrl + '\n';
	msg += 'sponsorUrl: ' + sponsorUrl + '\n';
	msg += 'sponsor: ' + sponsor + '\n';
	msg += 'expanded: ' + expanded + '\n';
	msg += 'wide: ' + wide + '\n';
	Verbose(msg);
	
	var sponsorDiv = document.getElementById("sponsor1");
	if(sponsorDiv && sponsorUrl && sponsorUrl!='')
	{
		// Replaces the special values in the "random" for the url
		sponsorUrl = ApplyBannerParameters(sponsorUrl,sponsor);
			
		var html = '';
		html += "<h3><img src=\"" + sponsoredByUrl + "\" /></h3>";
		html += "<iframe src=\"" + sponsorUrl + "\" width=\"130\" height=\"30\" marginheight=\"0\" marginwidth=\"0\" topmargin=\"0\" leftmargin=\"0\" frameborder=\"no\" border=\"0\" scrolling=\"no\"></iframe>";
		sponsorDiv.innerHTML  = html;
	}
	
	var bannerDiv = document.getElementById("publicidade");
	if(bannerDiv && bannerUrl && bannerUrl!='')
	{
		var bigBannerFrameWidth;
		if(wide && enableUpdateSize)
		{
			bigBannerFrameWidth = 420;
		}
		else
		{
			bigBannerFrameWidth = 490;
		}
		
		bannerUrl = ApplyBannerParameters(bannerUrl,sponsor);
		bigBannerUrl = ApplyBannerParameters(bigBannerUrl,sponsor);
		
		var html = '';
		if(expanded)
		{
			// Close button
			html += "<a id=\"bannerClose\" href=\"#\" onclick=\"ResizeBanner();return(false);\" title=\"" + Translate("CLOSE") + "\" class=\"close\">" + Translate("CLOSE") + " [X]</a>";

			// Two banners, with big banner visible
			html += "<iframe id=\"bannerFrame\" src=\"" + bannerUrl + "\" width=\"150\" height=\"420\" marginheight=\"0\" marginwidth=\"0\" topmargin=\"0\" leftmargin=\"0\" frameborder=\"no\" border=\"0\" scrolling=\"no\" style=\"display: none\"></iframe>";
			html += "<iframe id=\"bigBannerFrame\" src=\"" + bigBannerUrl + "\" width=\"" + bigBannerFrameWidth + "\" height=\"420\" marginheight=\"0\" marginwidth=\"0\" topmargin=\"0\" leftmargin=\"0\" frameborder=\"no\" border=\"0\" scrolling=\"no\"></iframe>";
		}
		else
		{
			// Regular banner only
			html += "<iframe src=\"" + bannerUrl + "\" width=\"150\" height=\"420\" marginheight=\"0\" marginwidth=\"0\" topmargin=\"0\" leftmargin=\"0\" frameborder=\"no\" border=\"0\" scrolling=\"no\"></iframe>";
		}
		bannerDiv.innerHTML  = html;
	}
}

// Hides the expanded ad, necessary to open login/my services
function ResizeBanner()
{
	if(playerTerra)
	{
		if(playerTerra.playingAd)
		{
			var currentMedia = playerTerra.getCurrentInternalMedia();
			if(currentMedia && currentMedia.endScript)
			{
				eval(currentMedia.endScript);
			}
		}
	}
}

var skipNextVideoBanner = false;
function RenderVideoBanner(sponsor,expanded)
{
	var currentItem = playerTerra.getCurrentMedia();
	var currentInternal = playerTerra.getCurrentInternalMedia();
	if(currentItem && currentInternal)
	{
		if(skipNextVideoBanner && !currentInternal.isAd)
		{
			skipNextVideoBanner = false;
			return;
		}

		var bannerUrl = '';
		var bigBannerUrl = '';
		var sponsorUrl = '';
		if(sponsor && sponsor!='')
		{
			// Preroll sync banner
			bannerUrl    = currentItem.syncBannerUrl;
			bigBannerUrl = currentItem.syncBigBannerUrl;
			sponsorUrl   = currentItem.syncSponsorUrl;
			
			// Tells script to ignore the banner call for the next non-ad video
			skipNextVideoBanner = true;
		}
		else
		{
			// Standard video banner
			bannerUrl = currentItem.bannerUrl;
			sponsorUrl = currentItem.sponsorUrl;
		}
		
		RenderBanner(bannerUrl,bigBannerUrl,sponsorUrl,sponsor,expanded,currentInternal.isWide);
	}
}

function SwapVideoBanner()
{
	var bannerClose = document.getElementById('bannerClose');
	var bannerFrame = document.getElementById('bannerFrame');
	var bigBannerFrame = document.getElementById('bigBannerFrame');
	
	if(bannerClose && bannerFrame && bigBannerFrame)
	{
		bannerClose.style.display = 'none';
		bannerFrame.style.display = '';
		bigBannerFrame.style.display = 'none';
	}
}

function ApplyBannerParameters(url,sponsor)
{
	// Replaces the special values in the "random" for the url
	var baseUrl = new String(url);

	// Replaces sponsor
	if(sponsor && sponsor!='')
	{
		baseUrl = baseUrl.replace("#sponsor#",sponsor);
		baseUrl = baseUrl.replace("%23sponsor%23",sponsor); // Escaped
	}

	// Replaces random	
	baseUrl = baseUrl.replace("#random#",currentRandom);
	baseUrl = baseUrl.replace("%23random%23",currentRandom); // Escaped
	
	return(baseUrl);
}

var currentRandom = 0;
function UpdateRandom()
{
	var seed = parseInt(Math.random() * 100000);
	currentRandom = new String(seed);
	
	Verbose('Random updated to ' + currentRandom);
}
UpdateRandom();

// ********************************************************************************
// Player Tag Controls
// ********************************************************************************
var currentPlayerTag = '';
var currentId = 0;

function CheckPlayerTag()
{
	// Makes sure everything is properly initialized
	if(playerTerra)
	{
		if(playerTerra.player)
		{
			// Is playing - should create tag
			if(playerTerra.getPlayState()==playerTerra.playState.playing)
			{
				// Checks if we can read the current item
				var item = playerTerra.getCurrentMedia();
				if(item)
				{
					// Checks if the item has a valid tag
					var tag = item.playertag;

					if(tag)
					{
						// Creates a new tag
						CreatePlayerTagFrame(tag,item.id);
					}
				}
			}
			else
			{
				// Not playing - destroys tag
				DestroyPlayerTagFrame(currentPlayerTag,currentId);
			}
		}
	}
	
	window.setTimeout('CheckPlayerTag()',1000);
}

function CreatePlayerTagFrame(playerTag, id)
{
	// Only performs action on tag changes
	if(playerTag!=currentPlayerTag || id!=currentId)
	{
		// Destroys any previous tags
		DestroyPlayerTagFrame(currentPlayerTag,currentId)

		// Performs the action
		if(playerTag!='')
		{
			// Creates the frame
			var tagFrame = document.getElementById('playerTagFrame_' + playerTag + '_' + id);
			if(!tagFrame)
			{
				tagFrame = document.createElement('iframe');
				tagFrame.id = 'playerTagFrame_' + playerTag + '_' + id;
				tagFrame.frameBorder = 0;
				tagFrame.height = 0;
				tagFrame.width = 0;
				document.body.appendChild(tagFrame);

				tagFrame.src = "playerTag.aspx?playertag=" + playerTag + "&id=" + id;
			}

			// Stores the current tag and id
			currentPlayerTag = playerTag;
			currentId = id;
		}
	}
}

function DestroyPlayerTagFrame(playerTag,id)
{
	if(playerTag!='' && id>0)
	{
		// Removes the frame
		var tagFrame = document.getElementById('playerTagFrame_' + playerTag + '_' + id);
		if(tagFrame)
		{
			document.body.removeChild(tagFrame);	
		}
		
		// Clears the control flag
		currentPlayerTag = '';
		currentId = 0;
	}
}

// Inits the control thread
CheckPlayerTag();

// ********************************************************************************
// For the metric script
// ********************************************************************************
function GetMediaInfo(propertyName)
{
	var item = playerTerra.getCurrentInternalMedia();
	
	// Checks if this is an ad
	var isAd = false;
	if(lcEnabled)
	{
		var mediaItem = playerTerra.player.playerObject.currentMedia;
		if(mediaItem)
		{
			// LCAUDIT parameter can be used to identify preroll videos in LC
			var auditUrl = mediaItem.getItemInfo("LCAUDIT");
			if(auditUrl) isAd = (auditUrl!='');
		}
	}
	else
	{
		isAd = playerTerra.playingAd;
	}
	
	// Gets the property value
	var propertyValue = null;
	if(item)
	{
		switch(propertyName.toLowerCase())
		{
			case 'contentid':
				if(isAd && lcEnabled)
				{
					propertyValue = -1;
				}
				else
				{
					propertyValue = item.originalid;
				}
				break;
			case 'contenttitle':
				propertyValue = item.title;
				break;
			case 'contentname':
				propertyValue = item.title;
				break;
			case 'contentthumb':
				propertyValue = item.image;
				break;				
			case 'sourcetitle':
				if(isAd)
				{
					// Uses item source instead of ad source
					var currentItem = playerTerra.getCurrentMedia();
					propertyValue = currentItem.sourceTitle;
				}
				else
				{
					propertyValue = item.sourceTitle;
				}
				break;
			case 'contentprovider':
				propertyValue = item.provider;
				break;
			case 'contentduration':
				propertyValue = item.duration;
				break;
			case 'islive':
				propertyValue = item.isLive;
				break;
			case 'isadult':
				propertyValue = item.isAdult;
				break;
			case 'isclosed':
				propertyValue = item.isPrivate;
				break;
			case 'iswide':
				propertyValue = item.isWide;
				break;
			case 'isrelated':
				propertyValue = item.isrelated;
				break;
			case 'ispreroll':
				propertyValue = isAd;
				break;
		}
	}

	// Error handling
	if(propertyValue==null)
	{
		// Error reading data, send defaults according to spec
		switch(propertyName.toLowerCase())
		{
			// Int properties
			case 'contentid':
			case 'contentduration':
				return(0);
			// String properties
			case 'contenttitle':
			case 'contentname':
			case 'contentthumb':
			case 'sourcetitle':
			case 'contentprovider':
				return('');
			// Bool Properties
			case 'islive':
			case 'isadult':
			case 'isclosed':
			case 'iswide':
			case 'isrelated':
			case 'ispreroll':
				return(false);
		}
	}
	else
	{
		// Property retrieved, just returns the data
		return(propertyValue)
	}
}

// ********************************************************************************
// To update the channel title using the title of the current channel (media selected)
// ********************************************************************************
function ChangeChannelTitle(title)
{
	document.getElementById('changeTitle').innerHTML = title;
}

function ShowConfigBox(forceTest)
{
	var oDvConfigBox = document.getElementById('dvConfigBox');
	if(!oDvConfigBox) return;

	// Attempts to load from cookie
	var bandwidth = cookieManagerSettings.getValue('bandwidth');
	if(!bandwidth || forceTest)
	{
		oDvConfigBox.style.display='block';
		playerTester.bandwidthTest(true);
	}
	else
	{
		oDvConfigBox.style.display='block';
		playerTester.bandwidthTestFinished(bandwidth);
	}
}

function HideConfigBox()
{
	var oDvConfigBox = document.getElementById('dvConfigBox');
	if(!oDvConfigBox) return;
	oDvConfigBox.style.display='none';
}

function PreSelectConfigBox(bandwidth)
{
	var oRbVelocidade = document.frmVelocidades.rbVelocidade;
	oRbVelocidade[0].checked = true;
	for(var i = 0; i < oRbVelocidade.length; i++)
	{
		if(parseInt(oRbVelocidade[i].value,10) > parseInt(bandwidth,10)) break;
		oRbVelocidade[i].checked = true;
	}
}

function ConfirmConfigBox()
{
	var oRbVelocidade = document.frmVelocidades.rbVelocidade;
	for(var i = 0; i < oRbVelocidade.length; i++) if(oRbVelocidade[i].checked) break;
	cookieManagerSettings.setValue('bandwidth',oRbVelocidade[i].value);
	this.currentBandwidth = oRbVelocidade[i].value;
	HideConfigBox();
	
	if(playerTerra)
	{
		playerTerra.playItem(playerTerra.currentPosition, playerTerra.currentRelated);
	}
}

function CancelConfigBox()
{
	playerTerra.play();
	HideConfigBox();
}

function forceStop()
{
	if(playerTerra)
	{
		playerTerra.stop();
	}
}


// ************************************************************************************************
// *** Detects witch player to use
// ************************************************************************************************

function GetPlayerType()
{
	var player = null;
	var playerType = new PlayerType();

	// IE7 + Windows Media ActiveX
	if (window.ActiveXObject && enableWmp)
	{
		try
		{
			player = new ActiveXObject("WMPlayer.OCX.7");
		}
		catch(e) {}
		
		if(player)
			return (playerType.WindowsMedia);
	}
	
	// IE6 + Windows Media ActiveX
	if (window.ActiveXObject && enableWmp)
	{
		try
		{
			player = new ActiveXObject("MediaPlayer.MediaPlayer.1");
		}
		catch(e) {}
		
		if(player)
			return (playerType.WindowsMedia);
	}

	// Mozilla + Windows Media Firefox (Port25)
	if(HasPlugin("Windows Media Player Firefox") && enableWmpMozilla)
	{
		return (playerType.WindowsMediaFirefox);
	}

	// Mozilla + Plugin ActiveX + Windows Media ActiveX
	if (window.GeckoActiveXObject && enableWmpMozilla)
	{
		try
		{
			player = new GeckoActiveXObject("MediaPlayer.MediaPlayer.1");
		}
		catch (e) {}
	
		if(player)
			return (playerType.WindowsMedia);
	}
	
	// Mozilla / Safari + Quicktime + Flip4Mac
	if(HasPlugin("QuickTime") && enableQuickTime)
	{
		if(HasPlugin("Flip4Mac"))
			return (playerType.Quicktime);
	}

	// IE7 + Silverlight
	if (window.ActiveXObject && enableSilverlight)
	{
		try
		{
			player = new ActiveXObject("AgControl.AgControl");
		}
		catch(e) {}
		
		if(player)
			return (playerType.Silverlight);
	}
	
	// Mozilla / Safari + Silverlight
	if(HasPlugin("Silverlight") && enableSilverlight)
	{
		return playerType.Silverlight;
	}
	
	return (playerType.Unsupported);
}

//Detects if a certain plugin is installed
function HasPlugin(plugin)
{
	for(var i = 0; i < navigator.plugins.length; i++)
	{
		if(navigator.plugins[i].name.indexOf(plugin) != -1)
			return (true);
	}
	
	return (false);
}

function CheckBrowser()
{
	var checkPlugin = GetPlayerType() > 0;
	var checkBrowser = false;
	var checkOS = false;
	
	// checa nome do Browser ( "Firefox", "Safari", "Explorer" )
	var browser = BrowserDetect.browser;
	
	// nome do Sistema Operacional
	var OS = BrowserDetect.OS;
	
	if( OS == "Windows" )
	{
		checkOS = true;
		
		if( browser == "Explorer" || browser == "Firefox" )
		{
			checkBrowser = true;
		}	
		else
		{
			browser = "FALHA";
		}
	}
	else
	{
		if( OS == "Mac" )
		{
			checkOS = true;
			
			if( browser == "Safari" || browser == "Firefox" )
			{
				checkBrowser = true;		
			}	
			else
			{
				browser = "FALHA";
			}
		}
		else
		{
			OS = "FALHA";
		}
	}
	
	if(!checkPlugin || !checkBrowser || !checkOS)
	{	
		top.location.href='checkBrowser.aspx?OS=' + OS + '&browser=' + browser;
		return(false);
	}
	else
	{
		return(true);
	}
}

var BrowserDetect = {
	init: function () {
		this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
		this.version = this.searchVersion(navigator.userAgent)
			|| this.searchVersion(navigator.appVersion)
			|| "an unknown version";
		this.OS = this.searchString(this.dataOS) || "an unknown OS";
	},
	searchString: function (data) {
		for (var i=0;i<data.length;i++)	{
			var dataString = data[i].string;
			var dataProp = data[i].prop;
			this.versionSearchString = data[i].versionSearch || data[i].identity;
			if (dataString) {
				if (dataString.indexOf(data[i].subString) != -1)
					return data[i].identity;
			}
			else if (dataProp)
				return data[i].identity;
		}
	},
	searchVersion: function (dataString) {
		var index = dataString.indexOf(this.versionSearchString);
		if (index == -1) return;
		return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
	},
	dataBrowser: [
		{ 	string: navigator.userAgent,
			subString: "OmniWeb",
			versionSearch: "OmniWeb/",
			identity: "OmniWeb"
		},
		{
			string: navigator.vendor,
			subString: "Apple",
			identity: "Safari"
		},
		{
			prop: window.opera,
			identity: "Opera"
		},
		{
			string: navigator.vendor,
			subString: "iCab",
			identity: "iCab"
		},
		{
			string: navigator.vendor,
			subString: "KDE",
			identity: "Konqueror"
		},
		{
			string: navigator.userAgent,
			subString: "Firefox",
			identity: "Firefox"
		},
		{
			string: navigator.vendor,
			subString: "Camino",
			identity: "Camino"
		},
		{		// for newer Netscapes (6+)
			string: navigator.userAgent,
			subString: "Netscape",
			identity: "Netscape"
		},
		{
			string: navigator.userAgent,
			subString: "MSIE",
			identity: "Explorer",
			versionSearch: "MSIE"
		},
		{
			string: navigator.userAgent,
			subString: "Gecko",
			identity: "Mozilla",
			versionSearch: "rv"
		},
		{ 		// for older Netscapes (4-)
			string: navigator.userAgent,
			subString: "Mozilla",
			identity: "Netscape",
			versionSearch: "Mozilla"
		}
	],
	dataOS : [
		{
			string: navigator.platform,
			subString: "Win",
			identity: "Windows"
		},
		{
			string: navigator.platform,
			subString: "Mac",
			identity: "Mac"
		},
		{
			string: navigator.platform,
			subString: "Linux",
			identity: "Linux"
		}
	]

};
BrowserDetect.init();

// ************************************************************************************************
// *** Player Type Enumeration
// ************************************************************************************************

function PlayerType ()
{
	this.Unsupported = 0;
	this.WindowsMedia = 1;
	this.Quicktime = 2;
	this.Silverlight = 3;
	this.WindowsMediaFirefox = 4;
}
var animating = false;
function PlayHighlight()
{
	if(Highlighs)
	{
		var item = Highlighs[currentHighlight];
		Play(item.id, item.type, item.channel);
	}
}
function AddHighlight()
{
	if(Highlighs)
	{
		var item = Highlighs[currentHighlight];
		Add(item.id, item.type, item.channel);
	}
}
function BackHighlight()
{
	if(animating) return;

	if(Highlighs)
	{
		currentHighlight = currentHighlight == 0 ? Highlighs.length - 1 : currentHighlight - 1;
		ShowCurrentHighlight();
	}
}
function NextHighlight()
{
	if(animating) return;

	if(Highlighs)
	{
		currentHighlight = currentHighlight == Highlighs.length - 1 ? 0 : currentHighlight + 1;
		ShowCurrentHighlight();
	}
}
function ShowCurrentHighlight()
{
	if(Highlighs)
	{
		var item = Highlighs[currentHighlight];
		var image = document.getElementById("highlighImage");
		var title = document.getElementById("highlightTitle");
		var text = document.getElementById("highlightText");
		var channelTitle = document.getElementById("highlighChannel");
		
		title.innerHTML = "<a href=\"#\" onclick=\"PlayHighlight(); return false;\">" + item.title + "</a>";
		
		if(item.isRestrict || item.isAdult)
		{
			if(item.isRestrict && item.isAdult)
			{
				title.className = 'lockedAdult';
			}
			else
			{
				if(item.isRestrict)
				{
					title.className = 'locked';
				}
				if(item.isAdult)
				{
					title.className = 'adult';
				}
			}
		}
		else
		{
			title.className = '';
		}
		
		text.innerHTML = item.text;
		image.src = item.image;
		
		outMode = false;
		FadeIn(image.id, 0);
		
		channelTitle.innerHTML = item.channelTitle;
		channelTitle.href = item.channelUrl;
	}
}

function FadeIn(objID, value)
{
	if(value <= 100)
	{
		animating = true;
		SetOpacity(objID, value);
		value += 5;
		setTimeout("FadeIn('" + objID + "', " + value + ")", 50);
	}
	else
	{
		animating = false;
	}
}

function SetOpacity(objID, opacity)
{
	var obj = document.getElementById(objID);
	
	opacity = (opacity == 100)?99.999:opacity;
	
	// IE/Win
	obj.style.filter = "alpha(opacity:"+opacity+")";
	  
	// Safari 1.2, newer Firefox and Mozilla, CSS3
	obj.style.opacity = opacity/100;
}
// ************************************************************
// Voting Settings
// ************************************************************
var voteManager = new AjaxManager('voteManager'); // Manager for posting ratings
var voteUrl = "ajax/genericAjax.aspx?AjaxSource=TerraMediaCenter.Vote";// Ajax voting URL

var voteName = 'stars';         // Prefix for the span/div containing the stars
var voteImageName = 'starsImg'; // Prefix for the image to be resized

var voteWidth = 60;                     // Total pixels for a "full" rating
var voteStars = 5;                      // Number of the stars
var votePixels = voteWidth / voteStars;

var voteId = 0;         // Current mouse over id
var voteType = 0;       // Current mouse over type
var voteRating = 0;     // Current rating
var voteObj = null;     // Current voting div/span
var voteImageObj = null // Current voting image
var voteRedraw = false; // Allows/Denies redraw of image

var voteTimeout = -1;   // Timeout for "smoother" scrolling
var lastVote = 0;

// ************************************************************
// Voting MouseOver Methods
// ************************************************************

function Vote_Click() 
{
	try
	{
		// Updates the onmouseover event to the new constructor
		voteObj.onmouseover = null;//new Function('Vote_OnMouseOver(' + voteId + ', ' + videoMediaIndex + ', false)');
		voteObj.onclick = null;
		voteObj.onmouseout = null;
		
		// Stores the vote
		var url = voteUrl + '&p1=' + voteId + '&p2=' + voteRating;
		voteManager.Add(url, ParseVote);
		
		// Forces an update of the star to the saved rating
		Vote_UpdateDiv(voteRating);
		
		// Clears the variables
		voteId = 0;
		voteType = '';
		voteRating = 0;
		voteObj = null;
		voteImageObj = null;
		voteRedraw = false;
	}
	catch(e){}
}

// Gets the absolute left of the DIV containing the stars
function Vote_GetLeft() 
{
	if(voteObj)
	{
		var left = voteObj.offsetLeft;
		aux = voteObj.offsetParent;
		while (aux)
		{
			left += aux.offsetLeft;
			aux = aux.offsetParent;
		}
		return(left)
	}
	return(0);
}

function Vote_OnMouseOver(id, type, redraw, last)
{
	lastVote = last;
	// Clears any pending timeouts
	if(voteTimeout>-1)
	{
		window.clearTimeout(voteTimeout);
		voteTimeout = -1;
	}

	// Clears items if we changed places
	if(voteId!=id || voteType!= type)
	{
		Vote_Clear();
	}

	// Stores the current mouseover object
	voteId = id;
	voteType = type;
	voteObj = document.getElementById(voteName + '_' + voteType + '_' + voteId);
	voteImageObj = document.getElementById(voteImageName + '_' + voteType + '_' + voteId);
	voteRedraw = redraw;

	// Enables the mousemove
	document.onmousemove = Vote_OnMouseMove;
}

function Vote_OnMouseOut()
{
	voteTimeout = window.setTimeout('Vote_Clear();',10);
}

function Vote_Clear()
{
	// Clears the current information
	if(voteRedraw)
	{
		Vote_UpdateDiv(0);
	}
	
	Vote_UpdateDiv(lastVote);
	
	voteRating = 0;
	voteId = 0;
	voteType = '';
	voteObj = null;
	voteImageObj = null;
	voteRedraw = false;
	
	var label = document.getElementById("vote_label");
	if(label)
	{
		label.innerHTML = '<h4>' + Translate("MAKE_A_VOTE") + '</h4>';
	}
	
	// Disables the mousemove
	document.onmousemove = null;
}

function Vote_OnMouseMove(e)
{
	if(voteObj)
	{
		// Gets the left position of the div
		var left = Vote_GetLeft();

		if(left>=0)
		{
			// Calls the method to get the mouse position
			// Declared in FloatingMenu.js
			GetMousePosition(e);
		
			// Checks what's the current mouseover star
			var newVote = Math.ceil((currentMouseX-left)/votePixels);
			
			// Makes sure the rating is within valid limits
			if(newVote<1) newVote = 1;
			if(newVote>5) newVote = 5;
			
			// Show label
			var label = document.getElementById("vote_label");
			if(label)
			{
				var tempText = "";
				switch(newVote)
				{
					case 1:
						tempText = Translate("TERRIBLE");
						break;
					case 2:
						tempText = Translate("BAD");
						break;
					case 3:
						tempText = Translate("REGULAR");
						break;
					case 4:
						tempText = Translate("GOOD");
						break;
					case 5:
						tempText = Translate("EXCELLENT");
						break;
					default:
						tempText = Translate("MAKE_A_VOTE");
						break;
				}
				label.innerHTML = '<h4>' + tempText + '</h4>';
			}
			
			// If the vote changed, updates the drawing
			if(voteRating!=newVote)
			{
				// Stores the vote for later usage
				voteRating = newVote;

				// Updates the screen if requested			
				if(voteRedraw) Vote_UpdateDiv(newVote);
			}
		}
	}
}

function Vote_UpdateDiv(newVote)
{
	if(voteImageObj && newVote>-1 && newVote<=voteStars)
	{
		// Updates the star	
		voteImageObj.style.width = votePixels * newVote + 'px';
	}
}

// ************************************************************
// Voting MouseOver Methods
// ************************************************************

var voteNotifyDiv = null;
var voteNotifyTimeout = -1;
var voteNotifyOffsetX = -60;
var voteNotifyOffsetY = -60;

function ParseVote()
{
	if(this.httpRequest.status == 200)
	{
		CreateVoteNotify(this.httpRequest.responseText);
	}
}
function CreateVoteNotify(text)
{
	// Clears any pending timeouts
	if(voteNotifyTimeout!=-1)
	{
		//window.clearTimeout(voteNotifyTimeout);
	}

	if(!voteNotifyDiv)
	{
		// Creates a div
		/*voteNotifyDiv = document.createElement('div');
		voteNotifyDiv.className = 'loadingNotify'; //class that contains div style
		voteNotifyDiv.style.position = 'Absolute';

		document.body.appendChild(voteNotifyDiv);*/
		
		voteNotifyDiv = document.getElementById("vote_label");
	}

	// Updates the position
	//voteNotifyDiv.style.left = currentMouseX + voteNotifyOffsetX + 58 + 'px';
	//voteNotifyDiv.style.top  = currentMouseY + voteNotifyOffsetY + 20 + 'px';
	
	// Updates the text	
	voteNotifyDiv.innerHTML = '<h4>' + text + '</h4>';
	
	playerTerra.alreadyVote = true;
	Vote_Fix();

	// Schedules the notification destruction
	//voteNotifyTimeout = window.setTimeout('DestroyVoteNotify()', 2000);
}

function DestroyVoteNotify()
{
	// Destroys the div and resets the parameters
	document.body.removeChild(voteNotifyDiv);
	voteNotifyDiv = null;
	voteNotifyTimeout = -1;
}

function Vote_Fix()
{
	if(!playerTerra.alreadyVote)
	{
		return;
	}

	// Increments in 1 the total votes
	var voteCountDiv = document.getElementById('vote_count');
	if(voteCountDiv)
	{
		var currentVoteText = new String(voteCountDiv.innerHTML);
		var totalVotes = parseInt(currentVoteText.substring(0,currentVoteText.indexOf(" ")));
		
		if(isNaN(totalVotes))
		{
			voteCountDiv.innerHTML = 1 + ' ' + Translate("VOTES");
		}
		else
		{
			voteCountDiv.innerHTML = (totalVotes+1) + ' ' + Translate("VOTES");
		}
	}
	
}