//-----------------------------------------------------------------------------------
// Criado: 20/08/2004 - TTakahase
// Modificado: 04/01/2006 - TTakahase
// Modificado: 24/05/2008 - TTakahase
//
// Para utilizar estes scripts, defina na tag BODY nos forms as seguintes
// propriedades:
//   onload="Akan_OnLoad(event)"
//   onresize="Akan_OnResize(event)"
//   onunload="Akan_OnUnload(event)"
//   onclick="Akan_OnClick(event)"
//
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				CONSTANTES
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
var COOKIE_AKAN = "Akan";
var COOKIE_DIV_SCROLL_LOCK = "DivScrollLock";
var COOKIE_BODY_SCROLL_LOCK = "BodyScrollLock";
var COOKIE_FOCUS_LOCK = "FocusLock";
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				VARIÁVEIS GLOBAIS
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Facilidade para testar o browser
var GboIsMSIE=(window.navigator.appName=="Microsoft Internet Explorer");
var GboIsMSIE6=(window.navigator.appVersion.search('MSIE 6.0')!=-1);
var GboIsMSIE7=(window.navigator.appVersion.search('MSIE 7.0')!=-1);
// Array de funções onload()
var GvpOnLoad=null;
// Array de funções onresize()
var GvpOnResize=null;
// Array de funções onunload()
var GvpOnUnload=null;
// Array de funções onclick()
var GvpOnClick=null;
// Determina se TODOS os Divs terão persistência no scroll.
// Chame a função Akan_SetDivScrollLock() para alterar o valor desta variável.
var GboDivScrollLock=false;
// Determina se o Body terá persistência no scroll.
// Chame a função Akan_SetBodyScrollLock() para alterar o valor desta variável.
var GboBodyScrollLock=false;
// Determina a persistência de foco nos controles.
// Chame a função Akan_SetFocuslLock() para alterar o valor desta variável.
var GboFocusLock=false;
// Variável que se contiver um ID válido, este controle receberá foco durante
// o evento onLoad.
var GpcFocusCtrl=null;
// Utilizado para evitar que a persistência de foco retire o foco das janelas
// pop-up. Retorna para false no final do evento onLoad.
var GboAvoidFocusOnce=false;
// Ativa o ajuste dos componentes com problemas para definir seu comprimento
// através de % (atualmente compontentes tipo Input)
var GboWidthAdjustment=false;
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES DE GERÊNCIAMENTO DA AkanLib ©
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Função integradora para ser usada no body.onload.
// Esta função varre o array de funções onload(), permitindo assim que sejam
// especificadas n funções.
function Akan_OnLoad(PoEvent)
{	if (GboWidthAdjustment) Akan_WidthAdjustment();
	if (GboDivScrollLock) Akan_DivScrollLockControl(true);
	if (GboBodyScrollLock) Akan_BodyScrollLockControl(true);
	if (GboAvoidFocusOnce==false)
	{	if (GboFocusLock) Akan_FocusLockControl(true);
		if (GpcFocusCtrl!=null) Akan_SetFocus(GpcFocusCtrl);
	} else GboAvoidFocusOnce=false;
	if (GvpOnLoad!=null)
		for (i=0;i<GvpOnLoad.length;i++) GvpOnLoad[i](i,PoEvent);
}
//-----------------------------------------------------------------------------------
// Função integradora para ser usada no body.onresize.
// Esta função varre o array de funções onresize(), permitindo assim que sejam
// especificadas n funções.
function Akan_OnResize(PoEvent)
{	if (GboWidthAdjustment) Akan_WidthAdjustment();
	if (GvpOnResize!=null)
		for (i=0;i<GvpOnResize.length;i++) GvpOnResize[i](i,PoEvent);
}
//-----------------------------------------------------------------------------------
// Função integradora para ser usada no body.onunload.
// Esta função varre o array de funções onunload(), permitindo assim que sejam
// especificadas n funções.
function Akan_OnUnload(PoEvent)
{	if (GboDivScrollLock) Akan_DivScrollLockControl(false);
	if (GboBodyScrollLock) Akan_BodyScrollLockControl(false);
	if (GboFocusLock) Akan_FocusLockControl(false);
	if (GvpOnUnload!=null)
		for (i=0;i<GvpOnUnload.length;i++) GvpOnUnload[i](i,PoEvent);
}
//-----------------------------------------------------------------------------------
// Função integradora para ser usada no body.onclick.
// Esta função varre o array de funções onclick(), permitindo assim que sejam
// especificadas n funções.
function Akan_OnClick(PoEvent)
{	if (GvpOnClick!=null)
		for (i=0;i<GvpOnClick.length;i++) GvpOnClick[i](i,PoEvent);
}
//-----------------------------------------------------------------------------------
// Adiciona no array de funções onload(), para funcionar necessita que a
// função Akan_OnLoad() seja chamada no onload() do body da página.
// O evento deve ser do seguinte formato XXXX(PiIndex,PoEvent)
function Akan_AddOnLoadEvent(PpFunc)
{	if (GvpOnLoad==null) GvpOnLoad=new Array();
	GvpOnLoad[GvpOnLoad.length]=PpFunc;
}
//-----------------------------------------------------------------------------------
// Adiciona no array de funções onresize(), para funcionar necessita que a
// função Akan_OnResize() seja chamada no onresize() do body da página.
// O evento deve ser do seguinte formato XXXX(PiIndex,PoEvent)
function Akan_AddOnResizeEvent(PpFunc)
{	if (GvpOnResize==null) GvpOnResize=new Array();
	GvpOnResize[GvpOnResize.length]=PpFunc;
}
//-----------------------------------------------------------------------------------
// Adiciona no array de funções onunload(), para funcionar necessita que a
// função Akan_OnUnload() seja chamada no onunload() do body da página.
// O evento deve ser do seguinte formato XXXX(PiIndex,PoEvent)
function Akan_AddOnUnloadEvent(PpFunc)
{	if (GvpOnUnload==null) GvpOnUnload=new Array();
	GvpOnUnload[GvpOnUnload.length]=PpFunc;
}
//-----------------------------------------------------------------------------------
// Adiciona no array de funções onclick(), para funcionar necessita que a
// função Akan_OnClick() seja chamada no onclick() do body da página.
// O evento deve ser do seguinte formato XXXX(PiIndex,PoEvent)
function Akan_AddOnClickEvent(PpFunc)
{	if (GvpOnClick==null) GvpOnClick=new Array();
	GvpOnClick[GvpOnClick.length]=PpFunc;
}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES PARA CONTROLE DE FOCO E PERSISTÊNCIA
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Ativa ou não a persistência de foco
function Akan_SetFocusLock(PboSet)
{	GboFocusLock=PboSet;
}
//-----------------------------------------------------------------------------------
// Função interna
function Akan_FocusLockControl(PboState)
{	if (PboState) //Load
	{	var LpcCookie;
		
		LpcCookie=Akan_GetCookieAkan(COOKIE_FOCUS_LOCK);
		if (LpcCookie!=null) Akan_SetFocusObject(Akan_GetObjectByID(LpcCookie));
	}
	else //Unload
	{ if ((document.activeElement!=null)&&(Akan_IsNotEmpty(document.activeElement.id)))
			Akan_SetCookieAkan(COOKIE_FOCUS_LOCK,document.activeElement.id);
}	}
//-----------------------------------------------------------------------------------
// Determina se o controle pode receber foco
// Retorna:
//   true ou false
function Akan_CanFocus(PoCtrl)
{	if (PoCtrl!=null)
	{	var LpcType=PoCtrl.tagName.toLowerCase();
		if ((LpcType=="select")||(LpcType=="input")||(LpcType=="textarea")||(LpcType=="a"))
		{	if ((PoCtrl.disabled==false)&&(PoCtrl.style.visibility.toLowerCase()!="hidden")
				&&((LpcType!="input")||(PoCtrl.type.toLowerCase()!="hidden"))&&(PoCtrl.tabIndex>=0))
				return true;
	}	}
	return false;
}
//-----------------------------------------------------------------------------------
// Define o foco para determinado objeto (precisa ser controle focável)
function Akan_SetFocusObject(PoCtrl)
{	if (Akan_CanFocus(PoCtrl)) PoCtrl.focus();
}
//-----------------------------------------------------------------------------------
// Define o foco para um ID de controle
function Akan_SetFocus(PpcCtrlID)
{	Akan_SetFocusObject(Akan_GetObjectByID(PpcCtrlID));
}
//-----------------------------------------------------------------------------------
// Agenda o foco para um ID de controle no evento OnLoad()
function Akan_SetFocusDelayed(PpcCtrlID)
{	GpcFocusCtrl=PpcCtrlID;
}
//-----------------------------------------------------------------------------------
// Passa o foco para o controle anterior ao PoActiveCtrl
function Akan_PrevFocus(PoActiveCtrl)
{	if (PoActiveCtrl!=null)
	{	var LiCount=document.all.length;
		for (i=0;i<LiCount;i++)
			if (document.all[i]==PoActiveCtrl)
				for (i--;i>=0;i--)
					if (Akan_CanFocus(document.all[i]))
					{	document.all[i].focus();
						return true;
					}
	}
	return false;
}
//-----------------------------------------------------------------------------------
// Passa o foco para o controle posterior ao PoActiveCtrl
function Akan_NextFocus(PoActiveCtrl)
{	if (PoActiveCtrl!=null)
	{	var LiCount=document.all.length;
		for (i=0;i<LiCount;i++)
			if (document.all[i]==PoActiveCtrl)
				for (i++;i<LiCount;i++)
					if (Akan_CanFocus(document.all[i]))
					{	document.all[i].focus();
						return true;
					}
	}
	return false;
}
//-----------------------------------------------------------------------------------
// Ativa ou não o controle de scroll dos DIVs
function Akan_SetDivScrollLock(PboSet)
{	GboDivScrollLock=PboSet;
}
//-----------------------------------------------------------------------------------
// Função interna
function Akan_DivScrollLockControl(PboState)
{	if (PboState) //Load
	{	var LpcCookie,LvpcDivs,LvpcEntry,LoDiv,LvpcSize;
		
		LpcCookie=Akan_GetCookieAkan(COOKIE_DIV_SCROLL_LOCK);
		if (LpcCookie!=null)
		{	LvpcDivs=LpcCookie.split("; ");
			for (i=LvpcDivs.length-1;i>=0;i--)
			{	LvpcEntry=LvpcDivs[i].split("=");
				LoDiv=Akan_GetObjectByID(LvpcEntry[0]);
				if (LoDiv!=null)
				{	LvpcSize=LvpcEntry[1].split(",");
					if (LoDiv.scrollHeight>LoDiv.offsetHeight) LoDiv.scrollTop=LvpcSize[0];
					if (LoDiv.scrollWidth>LoDiv.offsetWidth) LoDiv.scrollLeft=LvpcSize[1];
	}	}	}	}
	else //Unload
	{ var LpcDivs="";
		var LvoDivs=document.getElementsByTagName('div');
		if (LvoDivs!=null)
		{	for (i=LvoDivs.length-1;i>=0;i--)
				if ((LvoDivs[i].scrollTop!=0)||(LvoDivs[i].scrollLeft))
					LpcDivs+=LvoDivs[i].id+"="+LvoDivs[i].scrollTop+","+LvoDivs[i].scrollLeft+"; ";
		}
		if (LpcDivs!="") LpcDivs=LpcDivs.substr(0,LpcDivs.length-2);
		else LpcDivs=null;
		Akan_SetCookieAkan(COOKIE_DIV_SCROLL_LOCK,LpcDivs);
}	}
//-----------------------------------------------------------------------------------
// Ativa ou não o controle de scroll do Body
function Akan_SetBodyScrollLock(PboSet)
{	GboBodyScrollLock = PboSet;
}
//-----------------------------------------------------------------------------------
// Função interna
function Akan_BodyScrollLockControl(PboState)
{	if (PboState) //Load
	{	var LpcCookie, LvpcSize;
		
		LpcCookie = Akan_GetCookieAkan(COOKIE_BODY_SCROLL_LOCK);
		if (LpcCookie != null)
		{	LvpcSize = LpcCookie.split(",");
			if (document.body.scrollHeight > document.body.offsetHeight) document.body.scrollTop = LvpcSize[0] * (document.body.scrollHeight - document.body.offsetHeight);
			if (document.body.scrollWidth > document.body.offsetWidth) document.body.scrollLeft = LvpcSize[1] * (document.body.scrollWidth - document.body.offsetWidth);
	}	}
	else //Unload
		Akan_SetCookieAkan(COOKIE_BODY_SCROLL_LOCK,  document.body.scrollTop / (document.body.scrollHeight - document.body.offsetHeight) + "," + document.body.scrollLeft / (document.body.scrollWidth - document.body.offsetWidth));
}
//-----------------------------------------------------------------------------------
// Ativa ou desativa o controle de foco manual e automático pelo período do
// evento onLoad.
function Akan_AvoidFocusOnce(PboState)
{	GboAvoidFocusOnce=PboState;
}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES PARA LOCALIZAR CONTROLES
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
function Akan_GetObjectByID(PpcID)
{	if (document.getElementById)
	{	var LoID=document.getElementById(PpcID);
		if (LoID) return LoID;
	}
  if ((document.all)&&(document.all(PpcID))) return document.all(PpcID);
  if ((document.layers)&&(document.layers[PpcID])) return document.layers[PpcID];
	return null;
}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES PARA MANIPULAR DADOS EM CONTROLES
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Pega o indice do item selecionado de uma controle tipo lista
function Akan_GetSelectedIndex(PpcCtrlID)
{	var LoDDL=Akan_GetObjectByID(PpcCtrlID);
	if ((LoDDL!=null)&&(LoDDL.selectedIndex!=null)) return LoDDL.selectedIndex;
	return -1;
}
//-----------------------------------------------------------------------------------
// Pega o valor do item selecionado de uma controle tipo lista
function Akan_GetSelectedValue(PpcCtrlID)
{	var LiIndex=Akan_GetSelectedIndex(PpcCtrlID);
	if (LiIndex>=0) return Akan_GetObjectByID(PpcCtrlID).options[LiIndex].value;
	return null;
}
//-----------------------------------------------------------------------------------
// Pega o índice do item selecionado de um CRadioButtonList (apenas NetFramework).
// O parâmetro precisa ser o ClientID do componente da NetFramework como no exemplo:
// Akan_GetSelectedIndexRBL('<%= m_oMyRBL.ClientID %>')
function Akan_GetSelectedIndexRBL(PpcCtrlID)
{	var LiIndex=0;
	var LoRB;
	
	while (true)
	{	LoRB=Akan_GetObjectByID(PpcCtrlID+"_"+LiIndex);
		if (LoRB!=null)
		{	if (LoRB.status) return LiIndex;
			LiIndex++;
		} else break;
	}
	return -1;
}
//-----------------------------------------------------------------------------------
// Pega o valor do item selecionado de um CRadioButtonList (apenas NetFramework).
// O parâmetro precisa ser o ClientID do componente da NetFramework como no exemplo:
// Akan_GetSelectedIndexRBL('<%= m_oMyRBL.ClientID %>')
function Akan_GetSelectedValueRBL(PpcCtrlID)
{	var LiIndex=0;
	var LoRB;
	
	while (true)
	{	LoRB=Akan_GetObjectByID(PpcCtrlID+"_"+LiIndex);
		if (LoRB!=null)
		{	if (LoRB.status) return LoRB.value;
			LiIndex++;
		} else break;
	}
	return null;
}
//-----------------------------------------------------------------------------------
// Verifica se o valor do controle não é null nem vazio retornando true
// nestas condições
function Akan_IsNotFullEmptyControl(PpcCtrlID)
{	var LoCtrl=Akan_GetObjectByID(PpcCtrlID);
	return ((LoCtrl!=null)&&(Akan_IsNotFullEmpty(LoCtrl.value)));
}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES PARA ESTADO DE CONTROLES
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Verifica se o controle está visível retornando true nesta condição
function Akan_IsVisible(PpcCtrlID)
{	var LoFocus=Akan_GetObjectByID(PpcCtrlID);
	if (LoFocus!=null) return (LoFocus.style.visibility.toLowerCase()!='hidden');
	return false;
}
//-----------------------------------------------------------------------------------
// Habilita ou não controle
function Akan_Enable(PpcCtrlID,PboEnable)
{	var LoCtrl=Akan_GetObjectByID(PpcCtrlID);
	if (LoCtrl!=null) LoCtrl.disabled=!PboEnable;
}
//-----------------------------------------------------------------------------------
// Torna 'invisível' o controle definido certos atributos (position,left,top)
// de modo que fique totalmente fora da janela.
// Cuidado ao alterar esses atributos quando invisível pois não surtirá efeito
// quando tornar visível com esta função.
function Akan_Visible(PoCtrl, PboVisible)
{	if (PboVisible)
	{	if (PoCtrl.style.m_oAkanDisplay != undefined)
		{	PoCtrl.style.display = PoCtrl.style.m_oAkanDisplay;
			PoCtrl.style.m_oAkanDisplay = undefined;
	}	}
	else
	{	if (PoCtrl.style.m_oAkanDisplay == undefined)
		{	PoCtrl.style.m_oAkanDisplay = PoCtrl.style.display;
			PoCtrl.style.display = 'none';
}	}	}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES PARA POSICIONAMENTO DE CONTROLES
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Retorna em pixels a posição Y do controle em relação a área visível do browser
function Akan_GetOffsetTop(PoCtrl)
{	var LiReturn;
	
	LiReturn=0;
	while ((PoCtrl!=null)&&(PoCtrl.tagName!='FORM'))
	{	if ((PoCtrl.tagName!="TR")&&(PoCtrl.tagName!="TBODY")) LiReturn+=PoCtrl.offsetTop;
		PoCtrl=PoCtrl.parentElement;
	}
	return LiReturn;
}
//-----------------------------------------------------------------------------------
// Retorna em pixels a posição X do controle em relação a área visível do browser
function Akan_GetOffsetLeft(PoCtrl)
{	var LiReturn;
	
	LiReturn=0;
	while ((PoCtrl!=null)&&(PoCtrl.tagName!='FORM'))
	{	if ((PoCtrl.tagName!="TR")&&(PoCtrl.tagName!="TBODY")) LiReturn+=PoCtrl.offsetLeft;
		PoCtrl=PoCtrl.parentElement;
	}
	return LiReturn;
}
//-----------------------------------------------------------------------------------
function Akan_SetWidthAdjustment(PboEnable)
{	GboWidthAdjustment=PboEnable;
}
//-----------------------------------------------------------------------------------
// Efetua o ajuste do comprimento (quando em %) para certos controles (Input)
// Função, inicialmente, usado internamente, mas pode ser invocado quando necessário.
function Akan_WidthAdjustment()
{	var LpoInputs;
	
	LpoInputs=document.getElementsByTagName("INPUT");
	for (i=0;i<LpoInputs.length;i++)
		if (LpoInputs[i].WidthAdjustment!=null)
			LpoInputs[i].style.width=0;
	LpoInputs=document.getElementsByTagName("TEXTAREA");
	for (i=0;i<LpoInputs.length;i++)
		if (LpoInputs[i].WidthAdjustment!=null)
			LpoInputs[i].style.width=0;

	LpoInputs=document.getElementsByTagName("INPUT");
	for (i=0;i<LpoInputs.length;i++)
		if (LpoInputs[i].WidthAdjustment!=null)
			LpoInputs[i].style.width=(LpoInputs[i].parentElement.offsetWidth*LpoInputs[i].WidthAdjustment)/100.0;
	LpoInputs=document.getElementsByTagName("TEXTAREA");
	for (i=0;i<LpoInputs.length;i++)
		if (LpoInputs[i].WidthAdjustment!=null)
			LpoInputs[i].style.width=(LpoInputs[i].parentElement.offsetWidth*LpoInputs[i].WidthAdjustment)/100.0;
}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES PARA COOKIES
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Pega uma entrada de uma string tipo cookie
function Akan_GetCookieLikeChunk(PpcChunk,PpcKey)
{	if ((Akan_IsNotEmpty(PpcKey))&&(PpcChunk!=null))
	{	var LvpcCookie=PpcChunk.split("; ");
		if (LvpcCookie!=null)
		{	for (var i=LvpcCookie.length-1;i>=0;i--)
			{	var LvpcEntry=LvpcCookie[i].split("=");
				if (PpcKey==LvpcEntry[0])
				{	if ((LvpcEntry[1]!=null)&&(LvpcEntry[1]!="null")) return unescape(LvpcEntry[1]);
					break;
	}	}	}	}
	return null;
}
//-----------------------------------------------------------------------------------
// Seta uma entrada de uma string tipo cookie
// Se PpcName for null, então remove a entrada
function Akan_SetCookieLikeChunk(PpcChunk,PpcKey,PpcValue)
{	if (Akan_IsNotEmpty(PpcKey))
	{	var LvpcCookie,i,LpcEntry;
		
		if (PpcValue!=null) LpcEntry=PpcKey+"="+escape(PpcValue);
		else LpcEntry=null;
		if (PpcChunk!=null) LvpcCookie=PpcChunk.split("; ");
		else LvpcCookie=null;
		if (LvpcCookie!=null)
		{	for (i=LvpcCookie.length-1;i>=0;i--)
				if (PpcKey==LvpcCookie[i].split("=")[0]) break;
			if (i>=0)
			{	if (LpcEntry!=null) LvpcCookie[i]=LpcEntry;
				else LvpcCookie.splice(i,1);
				PpcChunk=LvpcCookie.join("; ");
			} else if (LpcEntry!=null) PpcChunk+="; "+LpcEntry;
		} else PpcChunk=LpcEntry;
	}
	return PpcChunk;
}
//-----------------------------------------------------------------------------------
// Pega uma entrada do cookie
function Akan_GetCookie(PpcName)
{	return Akan_GetCookieLikeChunk(document.cookie,PpcName);
}
//-----------------------------------------------------------------------------------
function Akan_GetCookieAkan(PpcKey)
{	if (Akan_IsNotEmpty(PpcKey))
	{	var LpcChunk;

		if ((LpcChunk=Akan_GetCookie(COOKIE_AKAN))!=null)
			return Akan_GetCookieLikeChunk(LpcChunk,PpcKey);
	}
	return null;
}
//-----------------------------------------------------------------------------------
// Seta uma entrada do cookie
function Akan_SetCookie(PpcKey,PpcValue)
{	if (Akan_IsNotEmpty(PpcKey)) document.cookie=PpcKey+"="+escape(PpcValue);
}
//-----------------------------------------------------------------------------------
function Akan_SetCookieAkan(PpcKey,PpcValue)
{	if (Akan_IsNotEmpty(PpcKey))
		Akan_SetCookie(COOKIE_AKAN,Akan_SetCookieLikeChunk(Akan_GetCookie(COOKIE_AKAN),PpcKey,PpcValue));
}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES PARA MANIPULAR STRINGS
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Remove espaços a esquerda e caracteres 10 e 13 (LF e CR)
function Akan_TrimLeft(PpcString)
{	if ((PpcString!=null)&&(PpcString.length>0))
	{	var i;
		for (i=0;i<PpcString.length;i++)
			if ((PpcString.charAt(i)!=' ')&&(PpcString.charAt(i)!='\n')&&(PpcString.charAt(i)!='\r')) break;
		if (i!=PpcString.length)
		{	if (i!=0) PpcString=PpcString.substr(i);
			return PpcString;
	}	}
	return null;
}
//-----------------------------------------------------------------------------------
// Remove espaços a direita e caracteres 10 e 13 (LF e CR)
function Akan_TrimRight(PpcString)
{	if ((PpcString!=null)&&(PpcString.length>0))
	{	var i;
		for (i=PpcString.length-1;i>=0;i--)
			if ((PpcString.charAt(i)!=' ')&&(PpcString.charAt(i)!='\n')&&(PpcString.charAt(i)!='\r')) break;
		if (i!=-1)
		{	if (i!=PpcString.length-1) PpcString=PpcString.substring(0,i+1);
			return PpcString;
	}	}
	return null;
}
//-----------------------------------------------------------------------------------
function Akan_Trim(PpcString)
{	return Akan_TrimLeft(Akan_TrimRight(PpcString));
}
//-----------------------------------------------------------------------------------
// Verifica se a string não é null nem vazio retornando true nestas condições
function Akan_IsNotEmpty(PpcText)
{	return ((PpcText!=null)&&(PpcText.length>0));
}
//-----------------------------------------------------------------------------------
// Verifica se a string não é null nem vazio nem com somente espaços em branco
// retornando true nestas condições
function Akan_IsNotFullEmpty(PpcText)
{	return ((Akan_IsNotEmpty(PpcText))&&(Akan_Trim(PpcText)!=null));
}
//-----------------------------------------------------------------------------------
function Akan_GetDigitsOnly(PpcStr)
{	if (Akan_IsNotEmpty(PpcStr))
	{	var LpcStr='',i;
		for (i=0;i<PpcStr.length;i++)
			if ((PpcStr.charAt(i)>='0')&&(PpcStr.charAt(i)<='9')) LpcStr+=PpcStr.charAt(i);
		return LpcStr;
	}
	return null;
}
//-----------------------------------------------------------------------------------
// Retorna somente um número, com sinal ou não, com separador de decimal ou não.
// O sinal, se houver, será colocado sempre a esquerda.
// Se utilizado ponto como separador decimal, então será substituido por vírgula.
// A função procura primeiro pela vírgula mais a direita, utilizando-a como
//   separador se encontrado, caso contrário, utiliza o ponto mais a direita.
function Akan_GetNumberOnly(PpcStr)
{	if (Akan_IsNotEmpty(PpcStr))
	{	var LpcStr,LcKey,i;
		var LboSignal,LboZero;
		var LbDec;
		
		LpcStr='';
		LboSignal=false;
		LboZero=true;
		LbDec=(PpcStr.indexOf(",")!=-1?0:1);
		for (i=PpcStr.length-1;i>=0;i--)
		{	LcKey=PpcStr.charAt(i);
			if (LcKey=='-') LboSignal=true;
			else if ((LcKey>='0')&&(LcKey<='9'))
			{ LpcStr=LcKey+LpcStr;
				if (LcKey!='0') LboZero=false;
			}
			else if (((LbDec==0)&&(LcKey==','))||((LbDec==1)&&(LcKey=='.')))
			{ LpcStr=','+LpcStr;
				LbDec=2;
		}	}
		if (LpcStr!='')
		{	if (LbDec==2)
			{	if (LpcStr.charAt(0)==',') LpcStr='0'+LpcStr;
				if (LpcStr.charAt(LpcStr.length-1)==',') LpcStr=LpcStr.substr(0,LpcStr.length-1);
			}
			if ((LboSignal)&&(!LboZero)) LpcStr='-'+LpcStr;
			return LpcStr;
	}	}
	return null;
}
//-----------------------------------------------------------------------------------
function Akan_FormatNumber(PpcValue,PpcMask)
{	var LiMLen,i,LcKey,LpcKey,LpcRet,LpcChunk;
	var LiVLen,j,LcVal;
	var LoReturn,LoPre,LoState,LiState;
	var LcType; //0: Digito, 1: Valor, 2: texto
	
	LoReturn=new Array();
	LoReturn.boReturn=true;
	LoReturn.pcResult='';
	if (!Akan_IsNotEmpty(PpcValue)) return LoReturn;
	if (!(Akan_IsNotEmpty(PpcMask)&&(PpcMask.length>1)))
	{	LoReturn.pcResult=PpcValue;
		return LoReturn;
	}
	LcType=PpcMask.charAt(0);
	PpcMask=PpcMask.substr(1);
	LiMLen=PpcMask.length;
	switch (LcType)
	{	case '0': PpcValue=Akan_GetDigitsOnly(PpcValue); break;
		case '1':
		{ PpcValue=Akan_GetNumberOnly(PpcValue);
			/*i=PpcMask.indexOf(',');
			if (i!=-1)
			{	j=0;
				while ((++i<LiMLen)&&(PpcMask.charAt(i)=='0')) j++;
				i=PpcValue.indexOf(',');
				if (i!=-1) j-=PpcValue.length-i+1;
				else PpcValue+=',';
				while (j-->0) PpcValue+='0';
			}*/
		} break;
	}
	//Pré processamento da máscara
	LoPre=new Array();
	j=-1;
	for (i=0;i<LiMLen;i++)
	{	LcKey=PpcMask.charAt(i);
		if ((LcKey=='9')||(LcKey=='0')||(LcKey=='[')||(LcKey==']')||(LcKey==','))
		{	LoPre[++j]=new Array();
			LoPre[j].boKey=true;
			LoPre[j].pcData=LcKey.toString();
			if (LcKey==',')
			{	LoPre[j].pcData2=PpcMask.substr(++i,2);
				i++;
			}
			continue;
		}
		if (LcKey=='\\') LcKey=PpcMask.charAt(++i);
		if ((j==-1)||(LoPre[j].boKey))
		{	LoPre[++j]=new Array();
			LoPre[j].boKey=false;
			LoPre[j].pcData='';
		}
		LoPre[j].pcData+=LcKey;
	}
	//Processa texto com máscara
	LiState=-1;
	LoState=new Array();
	j=(LiVLen=PpcValue.length)-1;
	LpcRet='';
	for (i=LoPre.length-1;i>=0;i--)
	{	if (LoPre[i].boKey)
		{	LpcKey=LoPre[i].pcData;
			if (LpcKey=="]")
			{	LoState[++LiState]=new Array();
				LoState[LiState].boFound=false;
				LoState[LiState].iPos=LpcRet.length;
				continue;
			}
			if (LpcKey=="[")
			{	if (LiState>=0)
				{	if (LiState>0) LoState[LiState-1].boFound=LoState[LiState].boFound;
					if (LoState[LiState].boFound==false) LpcRet=LpcRet.substr(LpcRet.length-LoState[LiState].iPos);
					LiState--;
				}
				continue;
			}
			if ((LpcKey=="9")||(LpcKey=="0"))
			{	if (j>=0) LcVal=PpcValue.charAt(j--);
				else LcVal='';
				LpcChunk='';
				if ((LcVal>='0')&&(LcVal<='9')) LpcChunk=LcVal;
				else if ((LpcKey=="0")&&(LcVal=='')) LpcChunk='0';
				if (LpcChunk!='')
				{	LpcRet=LpcChunk+LpcRet;
					if (LiState>=0) LoState[LiState].boFound=true;
			}	}
			continue;
		}
		LpcRet=LoPre[i].pcData+LpcRet;
	}
	LoReturn.pcResult=LpcRet;
	return LoReturn;
}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES DA CLASSE CTextBoxPersistent
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
function Akan_TBPAcceptEnter(PoEvent,PboMulti)
{	if (PoEvent.keyCode==13)
	{	var LboAccept;
		
		if (PboMulti==false) LboAccept=(PoEvent.ctrlKey|PoEvent.shiftKey|PoEvent.altKey==false);
		else LboAccept=(PoEvent.shiftKey|PoEvent.altKey==false)&&(PoEvent.ctrlKey);
		if (LboAccept)
		{ PoEvent.srcElement.m_boReturnValue=false;
			PoEvent.cancelBubble=true;
}	}	}
//-----------------------------------------------------------------------------------
//
//
//
//
//
//
//
//
//
//				FUNÇÕES DA CLASSE CTextBoxPersistent
//
//
//
//
//
//
//
//
//
//-----------------------------------------------------------------------------------
// Corrige o problema de PNGs com transparência no IE6.
// Atenção: existe a opção 'scale' que poderá ser repassada a image. Ex.: <img src='xxx' scale='image'>.
// Valores para scale: image, scale e crop.
function AkanAlphaBlender(PpcImgFake)
{	var oImgs, pcScale;
	
	if (!GboIsMSIE6) return;
	//Ajusta IMG
	oImgs = document.getElementsByTagName("img");
	if (oImgs != null)
	{	for (i = 0; i < oImgs.length; i++)
		{	if (oImgs[i].src.substring(oImgs[i].src.length-3).toLowerCase() == 'png')
			{	pcScale = oImgs[i].scale;
				if (pcScale == null) pcScale = 'scale';
				oImgs[i].style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + oImgs[i].src + "', sizingMethod='" + pcScale + "')";
				oImgs[i].src = PpcImgFake;
			}
		}
	}
	//Ajusta INPUT com type = IMAGE
	oImgs = document.getElementsByTagName("input");
	if (oImgs != null)
	{	for (i = 0; i < oImgs.length; i++)
		{	if ((oImgs[i].type.toLowerCase() == "image") && (oImgs[i].src.substring(oImgs[i].src.length-3).toLowerCase() == 'png'))
			{	pcScale = oImgs[i].scale;
				if (pcScale == null) pcScale = 'scale';
				oImgs[i].style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + oImgs[i].src + "', sizingMethod='" + pcScale + "')";
				oImgs[i].src = PpcImgFake;
			}
		}
	}
}