/***************************************************************************************
 * Copyright (c) 2001, NeoGrid S/A.  Todos os direitos reservados. 
 *
 * Os Programas desta Aplicação (que incluem tanto o software quanto a sua documentação) 
 * contém informações proprietárias da NeoGrid S/A; eles são licenciados de acordo   com 
 * um contrato de licença contendo restrições de uso e confidencialidade, e  são  também 
 * protegidos pela Lei 9609/98 e 9/610/98, respectivamente Lei do  Software  e  Lei  dos 
 * Direitos Autorais. Engenharia reversa, descompilação e desmontagem dos programas  são 
 * proibidos. Nenhuma parte destes  programas pode ser  reproduzida  ou  transmitida  de 
 * nenhuma forma e por nenhum meio, eletrônico ou mecânico,  por  motivo  algum,  sem  a 
 * permissão escrita da NeoGrid S/A.
 **************************************************************************************/
var NG_VERSION = "$PRODUCTVERSION$1.04$COMPONENTVERSION$0002$"
//encodeToBase64(toArray(this.form.t1.value))
//createStr(decodeFromBase64(this.form.t1.value))




	function toByte(s) {
	   // Serve para letras acentuadas também. 
	  return s & 0xFF;	
	}

    /**
     * max chars per line. A multiple of 4.
     */
    var lineLength = 72;

    /**
     * determines how long the lines are that are generated by encode.
     * Ignored by decode.
     * @param length 0 means no newlines inserted. Must be a multiple of 4.
     */
    function setLineLength(length)
    {
        lineLength = (length/4) * 4;
    }

    /**
     * letter of the alphabet used to encode binary values 0..63
     */
    var valueToChar = new Array();


    /**
     * binary value encoded by a given letter of the alphabet 0..63
     */
    var charToValue = new Array();



    /**
     * Marker value for chars we just ignore, e.g. \n \r high ascii
     */
    var IGNORE = -1;

    /**
     * Marker for = trailing pad
     */
    var PAD = -2;

    // build translate valueToChar table only once.
    // 0..25 -> 'A'..'Z'
	 var AStr = new String('A').charCodeAt(0);
	 var aStr = new String('a').charCodeAt(0);
	 var zeroStr = new String('0').charCodeAt(0);
    for ( var i=0; i<=25; i++ )
        valueToChar[i] = String.fromCharCode(AStr+i);
    // 26..51 -> 'a'..'z'
    for ( var i=0; i<=25; i++ )
        valueToChar[i+26] = String.fromCharCode(aStr+i);
    // 52..61 -> '0'..'9'
    for ( var i=0; i<=9; i++ )
        valueToChar[i+52] = String.fromCharCode(zeroStr+i);
    valueToChar[62] = '+';
    valueToChar[63] = '/';
	 // build translate charToValue table only once.
    for ( var i=0; i<257; i++ )
    {
        charToValue[i] = IGNORE;  // default is to ignore
    }

    for ( var i=0; i<valueToChar.length; i++ )
    {
        charToValue[new String(valueToChar[i]).charCodeAt(0)] = i;
    }
    charToValue[new String("=").charCodeAt(0)] = PAD;

function toArray(str) {
	var x = new Array();
	for ( var i=0; i<str.length; i++ ) {
   	x[i] = str.charCodeAt(i);
	}
	return x;
}

function createStr(b) {
	var str = "";
	for ( var i=0; i<b.length; i++ ) {
    	 str += String.fromCharCode(b[i]);
	}
	return str;
}

    function encodeToBase64(b){	
        // must be local for recursion to work.
        var sb = "";

        // must be local for recursion to work.
        var linePos = 0;
        // first deal with even multiples of 3 bytes.
        var len = Math.floor(b.length / 3)*3;
        
        var leftover = b.length - len;
        for ( var i=0; i<len; i+=3 )
        {
                linePos += 4;
                if ( linePos > lineLength )
                {
                    linePos = 0;
                    if ( lineLength != 0 )
                    {
                        sb+=(lineSeparator);
                    }
                }
            // get next three bytes in unsigned form lined up,
            // in big-endian order
            var combined = b[i+0] & 0xff;

            combined <<= 8;

            combined |= b[i+1] & 0xff;

            combined <<= 8;

            combined |= b[i+2] & 0xff;
				
            // break those 24 bits varo a 4 groups of 6 bits,
            // working LSB to MSB.
            var c3 = combined & 0x3f;
            combined >>>= 6;
            var c2 = combined & 0x3f;
            combined >>>= 6;
            var c1 = combined & 0x3f;
            combined >>>= 6;
            var c0 = combined & 0x3f;
            // Translate the equivalent alpha character
            // emitting them in big-endian order.
            sb+=( valueToChar[c0]);
            sb+=( valueToChar[c1]);
            sb+=( valueToChar[c2]);
            sb+=( valueToChar[c3]);
        }
        // deal with leftover bytes
        switch ( leftover ) {

            case 0:
            default:
                // nothing to do
                break;

            case 1:
                // One leftover byte generates xx==
                // Start a new line if next 4 chars won't fit on the current line
                // We don't encapsulate so that linePos and sb will work recursively
                {

                    linePos += 4;
                    if ( linePos > lineLength )
                    {
                        linePos = 0;
                        if ( lineLength != 0 )
                        {
                            sb+=(lineSeparator);
                        }
                    }
                }
                sb+=(encodeToBase64(new Array(b[len],0,0)).substring(0,2));
                sb+=("==");
                break;

            case 2:
                {
                    linePos += 4;
                    if ( linePos > lineLength )
                    {
                        linePos = 0;
                        if ( lineLength != 0 )
                        {
                            sb+=(lineSeparator);
                        }
                    }
                }
                sb+=(encodeToBase64(new Array(b[len], b[len+1], 0)).substring(0,3));
                sb+=("=");
                break;
        } // end switch;
        return sb.toString();
    }// end encode


    /**
     * how we separate lines, e.g. \n, \r\n, \r etc.
     */
    var lineSeparator = "\n";


    function decodeFromBase64(s)
    {

        // estimate worst case size of output array, no embedded newlines.
        var b = new Array();
        var blen = (s.length / 4) * 3;
	for ( var i=0; i<blen; i++ ) {
   	  b[i] = 0;
	}
		  
        // tracks where we are in a cycle of 4 input chars.
        var cycle = 0;

        // where we combine 4 groups of 6 bits and take apart as 3 groups of 8.
        var combined = 0;

        // how many bytes we have prepared.
        var j = 0;
        // will be an even multiple of 4 chars, plus some embedded \n
        var len = s.length;
        var dummies = 0;
        for ( var i=0; i<len; i++ )
        {	
            var c = s.charCodeAt(i);
            var value  = (c <= 255) ? charToValue[c] : IGNORE;
            // there are two magic values PAD (=) and IGNORE.
            switch ( value )
            {
                case IGNORE:
                    // e.g. \n, just ignore it.
                    break;

                case PAD:
                    value = 0;
                    dummies++;
                    // fallthrough
                default:
                    /* regular value character */
                    switch ( cycle )
                    {
                        case 0:
                            combined = value;
                            cycle = 1;
                            break;

                        case 1:
                            combined <<= 6;
                            combined |= value;
                            cycle = 2;
                            break;

                        case 2:
                            combined <<= 6;
                            combined |= value;
                            cycle = 3;
                            break;

                        case 3:
                            combined <<= 6;
                            combined |= value;
                            // we have just completed a cycle of 4 chars.
                            // the four 6-bit values are in combined in big-endian order
                            // peel them off 8 bits at a time working lsb to msb
                            // to get our original 3 8-bit bytes back           
                            
                            b[j+2] = toByte(combined);
                            combined >>>= 8;
                            b[j+1] = toByte(combined);
                            combined >>>= 8;
                            b[j] = toByte(combined);
                            j += 3;
                            cycle = 0;
                            break;
                    }
                    break;
            }
        } // end for
        j -= dummies;
		  if ( b.length != j )
		  {
	      var b2 = new Array(j);
			for ( var i=0; i<b2.length; i++ ) {
   			b2[i] = b[i];
			}
	      b = b2;
	    }        
      return b;

    }// end decode