Ext.namespace('DNS', 'DNS.Pesquisas', 'DNS.Pesquisas.Config', 'DNS.Pesquisas.Context');

DNS.Pesquisas.Config.location = '/pesquisas/';
DNS.Pesquisas.Config.blank_url = DNS.Config.base_url + '/pesquisas/main/blank.jsp';
DNS.Pesquisas.Config.timeout = 120000;


Ext.BLANK_IMAGE_URL = '/pesquisas/shared/s.gif';
Ext.SSL_SECURE_URL = '/pesquisas/main/blank.jsp';
Ext.Updater.defaults.sslBlankUrl = '/pesquisas/main/blank.jsp';


function limpaContexto(){
    // Não limpa os tamanhos da janela
    DNS.Pesquisas.Context.nord = '';
    DNS.Pesquisas.Context.directo = 'N';
}

// TextField que limita o número de caracteres do input
DNS.Pesquisas.TextField = Ext.extend(Ext.form.TextField, {
    constructor: function(config){
        if (!config.maxLength) {
            config.maxLength = 255;
        }
        config = Ext.apply({
            //enableKeyEvents: false,
            autoCreate: {
                tag: 'input',
                type: 'text',
                maxlength: config.maxLength,
                name: config.name,
                autocomplete: 'off'
            }
        }, config);
        DNS.Pesquisas.TextField.superclass.constructor.call(this, config);
    }
});


Ext.reg('DNS-textfield', DNS.Pesquisas.TextField);


/////////////////////////////
// Overrides (NÃO APAGAR)
/////////////////////////////

// Permite obter correctamente o valor do radiogroup
Ext.override(Ext.form.RadioGroup, {
    getName: function(){
        return this.items.first().getName();
    },
    
    getValue: function(){
        var v = '';
        
        this.items.each(function(item){
            if (item.getValue()) {
                v = item.getRawValue();
            }
            return !item.getValue();
        });
        
        return v;
    },
    
    setValue: function(v){
        this.items.each(function(item){
            item.setValue(item.getRawValue() == v);
        });
    }
});


// Permite mudar as labels dos campos automaticamente
Ext.override(Ext.form.Field, {
    setFieldLabel: function(text){
        this.el.up('.x-form-item', 10, true).child('.x-form-item-label').update(text);
    }
});


// testa se é um inteiro positivo 
DNS.IsNumeric = function(ObjVal){
    return /^\d+$/.test(ObjVal);
}

// Tipos de validação customizados
Ext.apply(Ext.form.VTypes, {

    // tive que contruir esta expressao regular pois a quem vem com o extjs 2.2 deixa os browsers pendurados
    customemail: function(val, field){
        //return /^.*.\@.*.\..*.$/.test(val)		
        //return /^[a-zA-Z0-9!#$%&''*+-=?^_`{|}~]*[a-zA-Z0-9!#$%&''*+-=?^_`{|}~]\@[a-zA-Z0-9!#$%&''*+-=?^_`{|}~]*[a-zA-Z0-9!#$%&''*+-=?^_`{|}~]\.[a-zA-Z0-9!#$%&''*+-=?^_`{|}~]*[a-zA-Z0-9!#$%&''*+-=?^_`{|}~]$/.test(val)        
        var trimVal = val.trim();
        return /^[a-zA-Z0-9!#$%&'*+-=?^_`{|}~]+\@[a-zA-Z0-9!#$%&'*+-=?^_`{|}~]+\.[a-zA-Z0-9!#$%&'*+-=?^_`{|}~]+$/.test(trimVal)
    },
    // a tradução para PT está no locale do ExtJS
    customemailText: 'Introduza um endereço de email válido.',
    
    numeric: function(val, field){
        if (DNS.IsNumeric(val)) {
            return true;
        }
        else {
            return false;
        }
    },
    numericText: 'Only numeric characters are allowed',
    
    nif: function(val, field){
    
        var nif = val;
        var c;
        var checkDigit = 0;
        //Check if is not null, is numeric and if has 9 numbers
        if (nif != null && DNS.IsNumeric(nif) && nif.length == 9) {
            //Get the first number of NIF
            c = nif.charAt(0);
            //Check firt number is (1, 2, 5, 6, 8 or 9)
            if (c == '1' || c == '2' || c == '5' || c == '6' || c == '8' || c == '9') {
                //Perform CheckDigit calculations
                checkDigit = c * 9;
                var i = 0;
                for (i = 2; i <= 8; i++) {
                    checkDigit += nif.charAt(i - 1) * (10 - i);
                }
                checkDigit = 11 - (checkDigit % 11);
                //if checkDigit is higher than ten set it to zero
                if (checkDigit >= 10) 
                    checkDigit = 0;
                //Compare checkDigit with the last number of NIF
                //If equal the NIF is Valid.
                if (checkDigit == nif.charAt(8)) 
                    return true;
            }
        }
        return false;
    },
    nifText: 'Número de Identificação Fiscal Inválido.',
	
    nib: function(val, field){
		
        var Nib = val;
        var sCheckDigit = Nib.substring(19,21);
        var ResultadoMultiplicacao = 0;
        var Contador=0;
        var digito;
	
	
        try {
            for (Contador = 0; Contador < 19; Contador++)
            {
                digito = parseInt(Nib.substring(Contador, Contador+1));
                ResultadoMultiplicacao = ((ResultadoMultiplicacao + digito) * 10) % 97;
            }
		
            ResultadoMultiplicacao = 98 - ((ResultadoMultiplicacao * 10) % 97);
		
            var sResultado = ResultadoMultiplicacao;
		
            if (ResultadoMultiplicacao < 10)
                sResultado = "0" + sResultado;
		
            if (!(sResultado == sCheckDigit))
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        catch(err)
        {
            return false;
        }
		
    },
    nibText: 'NIB Inválido.',

    niss: function(val, field){
		
        var Niss = val;
        var sCheckDigit = Niss.substring(10,11);
        var ResultadoMultiplicacao = 0;
        var Contador=0;
        var digito;
		
        var factores = [29,23,19,17,13,11,7,5,3,2];
		
        try {
            for (Contador = 0; Contador < 10; Contador++)
            {
                digito = parseInt(Niss.substring(Contador, Contador+1));
                ResultadoMultiplicacao += ((factores[Contador] * digito));
            }
		
            ResultadoMultiplicacao = ResultadoMultiplicacao % 10;
		
            var sResultado = 9 - ResultadoMultiplicacao;
		
            if (!(sResultado == sCheckDigit))
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        catch(err)
        {
            return false;
        }
		
    },
    nissText: 'NISS Inválido.'
	
});


// Permite que um GridPanel saiba qual é o seu ColumnModel
// para que na contrução possa usar o scope this
Ext.override(Ext.grid.GridPanel, {
    initComponent: Ext.grid.GridPanel.prototype.initComponent.createSequence(function(){
        if (this.colModel) {
            // give the ColumnModel a reference to this grid
            // (the grid's SelectionModel has a reference to the grid, so why not the ColumnModel too?)
            this.colModel.grid = this;
        }
    })
});


// Formata valores em euro  
Ext.util.Format.Currency = function(v){
    v = (Math.round((v - 0) * 100)) / 100;
    v = (v == Math.floor(v)) ? v + ".00" : ((v * 10 == Math.floor(v * 10)) ? v + "0" : v);
    return (v + ' &euro;').replace(/\./, ',');
};


// Formata valores em euro com EUR 
Ext.util.Format.CurrencyEUR = function(v){
    v = (Math.round((v - 0) * 100)) / 100;
    v = (v == Math.floor(v)) ? v + ".00" : ((v * 10 == Math.floor(v * 10)) ? v + "0" : v);
    return (v + ' EUR').replace(/\./, ',');
};


// Colocar qtips nos fields
Ext.sequence(Ext.form.Field.prototype, 'afterRender', function(){
    if (this.qtipText) {
        Ext.QuickTips.register({
            target: this.getEl(),
            title: '',
            text: this.qtipText,
            enabled: true
        });
        var label = findLabel(this);
        if (label) {
            Ext.QuickTips.register({
                target: label,
                title: '',
                text: this.qtipText,
                enabled: true
            });
        }
    }
});

// funcao auxiliar que procura labels nos form fields, usada no override dos qtips (acima)
var findLabel = function(field){
    var wrapDiv = null;
    var label = null
   
    wrapDiv = field.getEl().up('div.x-form-element');
    if (wrapDiv) {
        label = wrapDiv.child('label');
    }
    if (label) {
        return label;
    }   
    wrapDiv = field.getEl().up('div.x-form-item');
    if (wrapDiv) {
        label = wrapDiv.child('label');
    }
    if (label) {
        return label;
    }
}


// permite esconder os campos e também as respectivas labels
Ext.override(Ext.layout.FormLayout, {
    renderItem : function(c, position, target){
        if(c && !c.rendered && (c.isFormField || c.fieldLabel) && c.inputType != 'hidden'){
            var args = this.getTemplateArgs(c);
            if(typeof position == 'number'){
                position = target.dom.childNodes[position] || null;
            }
            if(position){
                c.formItem = this.fieldTpl.insertBefore(position, args, true);
            }else{
                c.formItem = this.fieldTpl.append(target, args, true);
            }
            c.actionMode = 'formItem';
            c.render('x-form-el-'+c.id);
            c.container = c.formItem;
            c.actionMode = 'container';
        }else {
            Ext.layout.FormLayout.superclass.renderItem.apply(this, arguments);
        }
    }
});

Ext.override(Ext.form.TriggerField, {
    actionMode: 'wrap',
    onShow: Ext.form.TriggerField.superclass.onShow,
    onHide: Ext.form.TriggerField.superclass.onHide
});

Ext.override(Ext.form.Checkbox, {
    actionMode: 'wrap'
});

Ext.override(Ext.form.HtmlEditor, {
    actionMode: 'wrap'
});