//----------------------------------------------------------
void TipoWidget::manipularAtributo(int res)
{
int lin;
Parametro param;
//Obtém a linha selecionada da tabela.
lin=tab_atributos->obterLinhaSelecionada();
//Caso o usuário clique no botão 'aplicar' da janela de conf. de parâmetro
if(res==QDialog::Accepted)
{
//Obtém o parâmetro configurado
param=parametro_wgt->obterParametro();
//Insere-o na tabela de atributos
tab_atributos->definirTextoCelula(QString::fromUtf8(param.obterNome()), lin, 0);
tab_atributos->definirTextoCelula(QString::fromUtf8(*param.obterTipo()), lin, 1);
tab_atributos->definirDadoLinha(QVariant::fromValue<Parametro>(param), lin);
}
//Caso o usuário clique no botão 'cancelar' da janela de conf. de parâmetro
else if(res==QDialog::Rejected)
{
//Remove a última linha da tabela quando se tratar de adição de novo parâmetro
if(tab_atributos->obterTextoCelula(lin,0).isEmpty())
tab_atributos->removerLinha(lin);
}
}
//----------------------------------------------------------
void ParametroWidget::definirAtributos(Parametro param, ModeloBD *modelo)
{
this->parametro=param;
//Configura os campos do formulário com os valores do parâmetro passado
param_in_chk->setChecked(param.parametroEntrada());
param_out_chk->setChecked(param.parametroSaida());
valorpadrao_edt->setText(QString::fromUtf8(param.obterValorPadrao()));
tipo_pgsql->definirAtributos(param.obterTipo(), modelo);
ObjetoBaseWidget::definirAtributos(modelo,NULL,&this->parametro);
}
//-----------------------------------------------------------
void Tipo::adicionarAtributo(Parametro atrib)
{
//O atributo não pode ter o nome vazio nem tipo nulo
if(atrib.obterNome()=="" || atrib.obterTipo()==TipoPgSQL::nulo)
throw Excecao(ERR_PGMODELER_INSATRIBTIPOINV,__PRETTY_FUNCTION__,__FILE__,__LINE__);
else if(TipoPgSQL::obterIndiceTipoUsuario(this->obterNome(true), this) == !atrib.obterTipo())
throw Excecao(Excecao::obterMensagemErro(ERR_PGMODELER_TIPOUSRAUTOREF).arg(this->obterNome(true)),
ERR_PGMODELER_TIPOUSRAUTOREF,__PRETTY_FUNCTION__,__FILE__,__LINE__);
//Verifica se o atributo com mesmo nome já não foi inserido no tipo
else if(atributoExiste(atrib.obterNome()))
throw Excecao(ERR_PGMODELER_INSATRIBTIPODUPLIC,__PRETTY_FUNCTION__,__FILE__,__LINE__);
atributos.push_back(atrib);
}
//-----------------------------------------------------------
void Tipo::converterParametrosFuncoes(bool conv_inversa)
{
unsigned i, conf_funcs[]={ FUNCAO_INPUT, FUNCAO_RECV,
FUNCAO_OUTPUT, FUNCAO_SEND };
TipoFuncao conf_func;
Parametro param;
Funcao *funcao=NULL;
for(i=0; i < 4; i++)
{
funcao=funcoes[conf_funcs[i]];
if(funcao)
{
/* Para as funções OUTPUT e SEND a conversão normal é mudar o tipo do primeiro
parâmetro de 'any' para o tipo 'this' já a conversão inversa faz o processo contrário */
if(conf_funcs[i]==FUNCAO_OUTPUT || conf_funcs[i]==FUNCAO_SEND)
{
param=funcao->obterParametro(0);
funcao->removerParametro(0);
if(!conv_inversa)
{
param.definirTipo(TipoPgSQL(this));
funcao->adicionarParametro(param);
}
else
{
param.definirTipo(TipoPgSQL("any"));
funcao->adicionarParametro(param);
}
}
/* Para as funções INPUT e RECV a conversão normal é mudar o tipo de retorno
de 'any' para o tipo 'this' já a conversão inversa faz o processo contrário */
else if(conf_funcs[i]==FUNCAO_INPUT || conf_funcs[i]==FUNCAO_RECV)
{
if(!conv_inversa)
funcao->definirTipoRetorno(TipoPgSQL(this));
else
funcao->definirTipoRetorno(TipoPgSQL("any"));
}
}
}
}
//----------------------------------------------------------
void FuncaoWidget::exibirDadosParametro(Parametro param, TabelaObjetosWidget *tab, unsigned idx_lin)
{
if(tab)
{
QString str_aux;
/* Para as duas tabelas (tab_parametros ou tab_retorno) as duas primeiras colunas
são destinadas, respectivamente, ao nome e tipo do parâmetro */
tab->definirTextoCelula(QString::fromUtf8(param.obterNome()),idx_lin,0);
tab->definirTextoCelula(QString::fromUtf8(*param.obterTipo()),idx_lin,1);
/* Armazena na linha da tabela uma cópia do tipo do parâmetro.
Isso é usado pelo método obterParametro() quando o usuário
solicita obter um parâmetro a partir de um a linha da tabela */
tab->definirDadoLinha(QVariant::fromValue<TipoPgSQL>(param.obterTipo()), idx_lin);
/* Caso a tabela passada seja a de parâmetro configura as demais
colunas com os demais atributos do parâmetro */
if(tab==tab_parametros)
{
//Exibe se o parâmetro é de entrada/saída
if(param.parametroEntrada()) str_aux="IN";
if(param.parametroSaida()) str_aux+="OUT";
tab->definirTextoCelula(str_aux,idx_lin,2);
//Exibe o valor padrão do parâmetro
tab->definirTextoCelula(QString::fromUtf8(param.obterValorPadrao()),idx_lin,3);
}
}
}
//-----------------------------------------------------------
void Tipo::definirAtributoElementos(unsigned tipo_def)
{
Parametro param;
QString str_elem;
unsigned i, qtd;
qtd=Tipo::atributos.size();
for(i=0; i < qtd; i++)
{
param=Tipo::atributos[i];
if(tipo_def==ParserEsquema::DEFINICAO_SQL)
{
str_elem+=param.obterNome() + " " + (*param.obterTipo());
if(i < (qtd-1)) str_elem+=",";
}
else
{
str_elem+=param.obterDefinicaoObjeto(tipo_def);
}
}
ObjetoBase::atributos[AtributosParsers::ELEMENTOS]=str_elem;
}
//----------------------------------------------------------
Parametro FuncaoWidget::obterParametro(TabelaObjetosWidget *tab, unsigned idx_lin)
{
Parametro param;
QString str_aux;
if(tab)
{
try
{
/* Configura o nome do parâmetro com o texto da coluna de nome
da linha especificada da tabela */
param.definirNome(tab->obterTextoCelula(idx_lin,0));
//Configura o tipo do parâmetro com o tipo armazenado na linha atual da tabela
param.definirTipo(tab->obterDadoLinha(idx_lin).value<TipoPgSQL>());
//Obtendo informações específicas quando se trata da tabela de parâmetros
if(tab==tab_parametros)
{
//Marcando se o parâmetro é de entrada/saída de acordo com o texto da coluna da tabela
str_aux=tab->obterTextoCelula(idx_lin, 2);
param.definirEntrada(str_aux.contains("IN"));
param.definirSaida(str_aux.contains("OUT"));
//Configura o valor padrâo do parâmetro
param.definirValorPadrao(tab->obterTextoCelula(idx_lin,3));
}
}
catch(Excecao &e)
{
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
return(param);
}
//----------------------------------------------------------
void TipoWidget::definirAtributos(ModeloBD *modelo, ListaOperacoes *lista_op, Tipo *tipo)
{
TipoPgSQL tp_copia, tp_elem;
unsigned conf_tipo, i, qtd;
Parametro param;
//Conecta o método de manipulação de atributos ao formulário de parâmetros
connect(parametro_wgt, SIGNAL(finished(int)), this, SLOT(manipularAtributo(int)));
//Define os atributos do formulários e da janela pai
ObjetoBaseWidget::definirAtributos(modelo, lista_op, tipo);
//Define o modelo de dados de referência dos seletores de função
for(i=Tipo::FUNCAO_INPUT; i <= Tipo::FUNCAO_ANALYZE; i++)
sel_funcoes[i]->definirModelo(modelo);
//Caso o tipo esteja especificado
if(tipo)
{
//Obtém a configuração do mesmo
conf_tipo=tipo->obterConfiguracao();
//Caso o tipo seja composto
if(conf_tipo==Tipo::TIPO_COMPOSTO)
{
//Marca o radiobox no formulário que indica o tipo composto
composto_rb->setChecked(true);
/* Desabilita os sinais da tabela de atributos para inserção
de todos os atributos do tipo sem disparar sinais e executar slots */
tab_atributos->blockSignals(true);
//Obtém a quantidade de atributos do tipo
qtd=tipo->obterNumAtributos();
/* Preenche a tabela de atributos, obtendo cada um e
exibindo os dados na tabela */
for(i=0; i < qtd; i++)
{
//Adiciona uma linha na tabela
tab_atributos->adicionarLinha();
//Obtém um atributo do tipo
param=tipo->obterAtributo(i);
//Exibe os dados do atributo na tabela
tab_atributos->definirTextoCelula(QString::fromUtf8(param.obterNome()), i, 0);
tab_atributos->definirTextoCelula(QString::fromUtf8(*param.obterTipo()), i, 1);
//Armazena o próprio atributo na linha da tabela
tab_atributos->definirDadoLinha(QVariant::fromValue<Parametro>(param), i);
}
//Desbloqueia os sinais da tabela de atributos
tab_atributos->blockSignals(false);
//Limpa a seleção da tabela
tab_atributos->limparSelecao();
}
//Caso o tipo seja enumeração
else if(conf_tipo==Tipo::TIPO_ENUMERACAO)
{
//Marca o campo respectivo no formulário
enumeracao_rb->setChecked(true);
/* Desabilita os sinais da tabela de enumerações para inserção
de todos as enumerações do tipo sem disparar sinais e executar slots */
tab_enumeracoes->blockSignals(true);
qtd=tipo->obterNumEnumeracoes();
//Insere todos as enumerações do tipo na tabela
for(i=0; i < qtd; i++)
{
tab_enumeracoes->adicionarLinha();
tab_enumeracoes->definirTextoCelula(tipo->obterEnumeracao(i), i, 0);
}
//Desbloqueia os sinais da tabela de enumerações
tab_enumeracoes->blockSignals(false);
tab_enumeracoes->limparSelecao();
}
//Caso o tipo seja base
else
{
//Marca o radiobox no formulário que indica o tipo base
tipo_base_rb->setChecked(true);
//Obtém o tipo cópia do tipo
tp_copia=tipo->obterTipoCopia();
//Obtém o tipo de elemento do tipo
tp_elem=tipo->obterElemento();
/* Configura os campos do formulário relacionados ao tipo base
com os valores definidos na instância de tipo passada */
comp_int_sb->setValue(tipo->obterCompInterno());
por_valor_chk->setChecked(tipo->passadoPorValor());
preferido_chk->setChecked(tipo->tipoPreferido());
delimitador_edt->setText(QString(tipo->obterDelimitador()));
valor_padrao_edt->setText(QString::fromUtf8(tipo->obterValorPadrao()));
categoria_cmb->setCurrentIndex(categoria_cmb->findText(~tipo->obterCategoria()));
armazenamento_cmb->setCurrentIndex(armazenamento_cmb->findText(~tipo->obterArmazenamento()));
alinhamento_cmb->setCurrentIndex(alinhamento_cmb->findText(~tipo->obterAlinhamento()));
//Atribui aos seletores de funções todas as funções configuradas na instância
for(i=Tipo::FUNCAO_INPUT; i <= Tipo::FUNCAO_ANALYZE; i++)
sel_funcoes[i]->definirObjeto(tipo->obterFuncao(i));
}
}
//Configura o widget de tipo de cópia com o tipo obtido da instância de tipo
tipo_copia->definirAtributos(tp_copia, modelo);
//Configura o widget de tipo de elemento com o tipo obtido da instância de tipo
tipo_elemento->definirAtributos(tp_elem, modelo);
}
//----------------------------------------------------------
void FuncaoWidget::aplicarConfiguracao(void)
{
try
{
Funcao *func=NULL;
unsigned qtd, i;
Parametro param;
QString str_aux;
//Inicia a configuração da função
iniciarConfiguracao<Funcao>();
//Faz a conversão do objeto editado (genérico) para o tipo função
func=dynamic_cast<Funcao *>(this->objeto);
//Atribui os valores básicos configurados no formulário para a função
func->definirLinguagem(modelo->obterObjeto(linguagem_cmb->currentText(), OBJETO_LINGUAGEM));
func->definirTipoFuncao(tipo_func_cmb->currentText());
func->definirFuncaoJanela(func_janela_chk->isChecked());
func->definirCustoExecucao(custo_exec_spb->value());
func->definirQuantidadeLinhas(linhas_ret_sbp->value());
func->definirTipoComportamento(comportamento_cmb->currentText());
func->definirTipoSeguranca(seguranca_cmb->currentText());
/* Remove todos os parâmetros da função para adicionar os que foram
configurados no formulário */
func->removerParametros();
//Obtém a quantidade de parâmetros configurados no formulário
qtd=tab_parametros->obterNumLinhas();
for(i=0; i < qtd; i++)
{
/* Cria um parâmetro auxiliar e os configura de acordo com os valores
do parâmetro atual (i) na tabela */
param.definirNome(tab_parametros->obterTextoCelula(i,0));
param.definirTipo(tab_parametros->obterDadoLinha(i).value<TipoPgSQL>());
str_aux=tab_parametros->obterTextoCelula(i,2);
param.definirEntrada(str_aux.indexOf("IN") >= 0);
param.definirSaida(str_aux.indexOf("OUT") >= 0);
param.definirValorPadrao(tab_parametros->obterTextoCelula(i,3));
//Uma vez configurado esse parâmetro e inserido na função
func->adicionarParametro(param);
}
/* Caso a linguagem selecionada no formulário for a C
indica que a função está definida em uma biblioteca externa
para tanto os valores dos campos biblioteca e simbolo
serão atribuídos à função que está sendo configurada */
if(linguagem_cmb->currentText()==~TipoLinguagem(TipoLinguagem::c))
{
func->definirBiblioteca(biblioteca_edt->text());
func->definirSimbolo(simbolo_edt->text());
}
/* Caso a linguagem seja diferente de C atribui o código fonte
definido no destacador de código do formulário */
else
func->definirCodigoFonte(codigofonte_txt->toPlainText());
//Caso o tipo de retorno configurado no formulário seja simples ou conjunto
if(simples_rb->isChecked() || conjunto_rb->isChecked())
{
/* Define o tipo de retorno da função obtendo o tipo definido no widget de
configuração de tipos pgsql */
func->definirTipoRetorno(tipo_ret->obterTipoPgSQL());
/* Marca na função se a mesma retorna um conjunto de dados de acordo
com o estado do radiobox 'conjunto_rb' */
func->definirRetornaSetOf(conjunto_rb->isChecked());
}
//Caso a função retorna uma tabela, a mesma é atribuída à função
else
{
func->removerTiposRetTabela();
qtd=tab_retorno->obterNumLinhas();
/* Adiciona uma coluna na tabela de retorno com os dados configurados na tabela
respectiva do formulário */
for(i=0; i<qtd; i++)
{
func->adicionarTipoRetTabela(tab_retorno->obterTextoCelula(i,0),
tab_retorno->obterDadoLinha(i).value<TipoPgSQL>());
}
}
//Finaliza a configuração da função
ObjetoBaseWidget::aplicarConfiguracao();
/* Executa a validação da função em relação aos objetos das classes
ConversaoCodificacao, ConversaoTipo, ElemClasseOperadores, FuncaoAgregada,
Gatilho, Linguagem, Operador, Tipo */
validarFuncaoConfigurada();
finalizarConfiguracao();
}
catch(Excecao &e)
{
/* Cancela a configuração o objeto removendo a ultima operação adicionada
referente ao objeto editado/criado e desaloca o objeto
caso o mesmo seja novo */
cancelarConfiguracao();
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
