void DominioWidget::aplicarConfiguracao(void)
{
try
{
Dominio *dominio=NULL;
iniciarConfiguracao<Dominio>();
//Obtém a referência ao domínio que está sendo editado/criado
dominio=dynamic_cast<Dominio *>(this->objeto);
//Configura os atributos do mesmo com os valores definidos no formulário
dominio->definirTipo(tipo_dominio->obterTipoPgSQL());
dominio->definirValorPadrao(valor_padrao_edt->text());
dominio->definirExpressao(expr_checagem_txt->toPlainText());
dominio->definirNomeRestricao(nome_rest_edt->text());
dominio->definirNaoNulo(nao_nulo_chk->isChecked());
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
void CaixaTextoWidget::aplicarConfiguracao(void)
{
try
{
CaixaTexto *caixa=NULL;
iniciarConfiguracao<CaixaTexto>();
caixa=dynamic_cast<CaixaTexto *>(this->objeto);
//caixa->definirPosicaoObjeto(QPointF(this->px_objeto, this->py_objeto));
caixa->definirComentario(texto_txt->toPlainText());
caixa->definirAtributoTexto(CaixaTexto::TEXTO_ITALICO, italico_chk->isChecked());
caixa->definirAtributoTexto(CaixaTexto::TEXTO_NEGRITO, negrito_chk->isChecked());
caixa->definirAtributoTexto(CaixaTexto::TEXTO_SUBLINHADO, sublinhado_chk->isChecked());
caixa->definirCorTexto(sel_cor_tb->palette().color(QPalette::Button));
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
void BancoDadosWidget::aplicarConfiguracao(void)
{
try
{
//Aplica as configurações básicas do objeto
ObjetoBaseWidget::aplicarConfiguracao();
//Define o autor do modelo
modelo->definirAutor(autor_edt->text().toUtf8());
/* Define a condificação do modelo de acordo com a selecionada no formulário
caso a codifição 'Padrão' seja selecionada o modelo usará a codificação padrão
do SGBD em que for executado o script sql gerado */
modelo->definirCodificacao(TipoCodificacao(codificacao_cmb->currentText()));
/* Define as localização LC_COLLATE e LC_CTYPE do modelo de acordo com a selecionada
no formulário caso a localização 'Padrão' seja selecionada o modelo usará a localização
padrão do SGBD em que for executado o script sql gerado */
if(lccollate_cmb->currentIndex() > 0)
modelo->definirLocalizacao(LC_COLLATE, lccollate_cmb->currentText());
else
modelo->definirLocalizacao(LC_COLLATE, "");
if(lcctype_cmb->currentIndex() > 0)
modelo->definirLocalizacao(LC_CTYPE, lcctype_cmb->currentText());
else
modelo->definirLocalizacao(LC_CTYPE, "");
finalizarConfiguracao();
}
catch(Excecao &e)
{
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
//----------------------------------------------------------
void LinguagemWidget::aplicarConfiguracao(void)
{
try
{
Linguagem *linguagem=NULL;
iniciarConfiguracao<Linguagem>();
//Converte o objeto para linguagem
linguagem=dynamic_cast<Linguagem *>(this->objeto);
linguagem->definirConfiavel(confiavel_chk->isChecked());
linguagem->definirFuncao(dynamic_cast<Funcao *>(sel_func_handler->obterObjeto()), Linguagem::FUNC_HANDLER);
linguagem->definirFuncao(dynamic_cast<Funcao *>(sel_func_validator->obterObjeto()), Linguagem::FUNC_VALIDATOR);
linguagem->definirFuncao(dynamic_cast<Funcao *>(sel_func_inline->obterObjeto()), Linguagem::FUNC_INLINE);
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
void EspacoTabelaWidget::aplicarConfiguracao(void)
{
try
{
EspacoTabela *esp_tab=NULL;
iniciarConfiguracao<EspacoTabela>();
//Converte o objeto para espaço de tabela
esp_tab=dynamic_cast<EspacoTabela *>(this->objeto);
//Configura o diretório do espaço de tabelas com o caminho configurado no formulário
esp_tab->definirDiretorio(diretorio_edt->text());
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
//---------------------------------------------------------
void SequenciaWidget::aplicarConfiguracao(void)
{
try
{
Sequencia *sequencia=NULL;
iniciarConfiguracao<Sequencia>();
//Obtém a referência à sequência que está sendo editada/criada
sequencia=dynamic_cast<Sequencia *>(this->objeto);
sequencia->definirCiclica(ciclica_chk->isChecked());
sequencia->definirValores(minimo_edt->text(), maximo_edt->text(), incremento_edt->text(),
inicio_edt->text(), cache_edt->text());
sequencia->definirPossuidora(dynamic_cast<Coluna *>(sel_coluna->obterObjeto()));
//Finaliza a configuração
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
//----------------------------------------------------------
void GatilhoWidget::aplicarConfiguracao(void)
{
try
{
Gatilho *gatilho=NULL;
unsigned i, qtd;
Coluna *coluna=NULL;
iniciarConfiguracao<Gatilho>();
//Obtém a referência ao gatilho que está sendo criado/editado
gatilho=dynamic_cast<Gatilho *>(this->objeto);
//Configura no gatilhos todos os atributos preenchidos no formulário
gatilho->definirTipoDisparo(TipoDisparo(tipo_disparo_cmb->currentText()));
gatilho->executarPorLinha(exec_por_linha_chk->isChecked());
gatilho->definirPostergavel(postergavel_chk->isChecked());
gatilho->definirTipoPostergacao(TipoPostergacao(tipo_postergacao_cmb->currentText()));
gatilho->definirCondicao(exp_condicional_txt->toPlainText());
gatilho->definirFuncao(dynamic_cast<Funcao *>(sel_funcao->obterObjeto()));
gatilho->definirTabReferenciada(dynamic_cast<Tabela *>(sel_tabela_ref->obterObjeto()));
gatilho->definirEvento(TipoEvento::on_insert, insert_chk->isChecked());
gatilho->definirEvento(TipoEvento::on_update, update_chk->isChecked());
gatilho->definirEvento(TipoEvento::on_delete, delete_chk->isChecked());
gatilho->definirEvento(TipoEvento::on_truncate, truncate_chk->isChecked());
/* Remove todas as colunas e argumentos para inserir aqueles
configurados no formulário */
gatilho->removerArgumentos();
gatilho->removerColunas();
//Adiciona os argumentos
qtd=tab_argumentos->obterNumLinhas();
for(i=0; i < qtd; i++)
gatilho->adicionarArgumento(tab_argumentos->obterTextoCelula(i, 0));
//Adiciona as colunas
qtd=tab_colunas->obterNumLinhas();
for(i=0; i < qtd; i++)
{
coluna=reinterpret_cast<Coluna *>(tab_colunas->obterDadoLinha(i).value<void *>());
gatilho->adicionarColuna(coluna);
}
//Aplica as configurações básicas
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
//----------------------------------------------------------
void TabelaWidget::aplicarConfiguracao(void)
{
try
{
Tabela *tabela=NULL;
if(!this->novo_obj)
{
//Adiciona o relacionamento à lista de operações antes de ser modificado
lista_op->adicionarObjeto(this->objeto, Operacao::OBJETO_MODIFICADO);
}
tabela=dynamic_cast<Tabela *>(this->objeto);
tabela->definirAceitaOids(aceita_oids_chk->isChecked());
//Aplica as configurações básicas
ObjetoBaseWidget::aplicarConfiguracao();
try
{
if(modelo->obterRelacionamento(tabela, NULL))
/* Faz a validação dos relacionamentos para refletir a nova configuração
da tabela */
modelo->validarRelacionamentos();
}
catch(Excecao &e)
{
/* O único erro que é desconsiderado é o de invalidação de objetos, pois,
mesmo com a restauração do estado original da tabela estes
objetos não são recuperados */
if(e.obterTipoErro()==ERR_PGMODELER_REFCOLUNAINVTABELA)
//Exibe uma mensagem de erro com o conteúdo da exceção
caixa_msg->show(e);
//Para os demais erros a exceção é encaminhada
else
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
//Finaliza o encademanto de operações aberto
lista_op->finalizarEncadeamentoOperacoes();
//Finaliza a configuração da tabela
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 */
lista_op->anularEncadeamentoOperacoes(true);
this->cancelarConfiguracao();
lista_op->anularEncadeamentoOperacoes(false);
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
//----------------------------------------------------------
void ConversaoTipoWidget::aplicarConfiguracao(void)
{
try
{
ConversaoTipo *conv_tipo=NULL;
iniciarConfiguracao<ConversaoTipo>();
//Obtém a conversão a partir da refência ao objeto configurado
conv_tipo=dynamic_cast<ConversaoTipo *>(this->objeto);
//Configura os tipos de dados da conversão obtendo-os dos widgets de configuração de tipos
conv_tipo->definirTipoDado(ConversaoTipo::CONV_TIPO_ORIGEM, tipo_dado_orig->obterTipoPgSQL());
conv_tipo->definirTipoDado(ConversaoTipo::CONV_TIPO_DESTINO, tipo_dado_dest->obterTipoPgSQL());
/* Configura se a conversão é de entrada/saída conforme o estado do
checkbox que representa o atributo no formulário */
conv_tipo->definirEntradaSaida(entradasaida_chk->isChecked());
//Configura o tipo da conversão conforme o radiobox selecionado no formulário
if(implicita_rb->isChecked())
conv_tipo->definirTipoConversao(ConversaoTipo::CONV_IMPLICITA);
else
conv_tipo->definirTipoConversao(ConversaoTipo::CONV_ATRIBUICAO);
//Atribui a função de conversão com aquela que está selecionada no seletor de função
conv_tipo->definirFuncaoConversao(dynamic_cast<Funcao*>(sel_funcao_conv->obterObjeto()));
//Aplica as configurações básicas
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
//----------------------------------------------------------
void RegraWidget::aplicarConfiguracao(void)
{
try
{
Regra *regra=NULL;
unsigned qtd, i;
iniciarConfiguracao<Regra>();
//Obtém a referência à regra que está sendo criada/editada
regra=dynamic_cast<Regra *>(this->objeto);
//Configura a regra com base nos atributos preenchidos no formulário
regra->definirTipoEvento(TipoEvento(tipo_evento_cmb->currentText()));
regra->definirTipoExecucao(TipoExecucao(tipo_execucao_cmb->currentText()));
regra->definirExpCondicional(exp_condicional_txt->toPlainText());
/* Remove todos os comandos da regra para inserção dos que
foram criados no formulário */
regra->removerComandos();
qtd=tab_comandos->obterNumLinhas();
//Inserindo os comandos sql do formulário na regra
for(i=0; i < qtd; i++)
regra->adicionarComando(tab_comandos->obterTextoCelula(i,0));
//Aplica as configurações básicas
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
//----------------------------------------------------------
void ParametroWidget::aplicarConfiguracao(void)
{
try
{
//iniciarConfiguracao<Parametro>();
//Configura o parâmetro com os valores do formulário
parametro.definirEntrada(param_in_chk->isChecked());
parametro.definirSaida(param_out_chk->isChecked());
parametro.definirValorPadrao(valorpadrao_edt->text());
parametro.definirTipo(tipo_pgsql->obterTipoPgSQL());
/* Efetiva as configurações chamando o método de
aplicação das configurações da classe pai */
ObjetoBaseWidget::aplicarConfiguracao();
finalizarConfiguracao();
}
catch(Excecao &e)
{
cancelarConfiguracao();
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
//----------------------------------------------------------
void TipoWidget::aplicarConfiguracao(void)
{
try
{
Tipo *tipo=NULL;
unsigned i, qtd;
iniciarConfiguracao<Tipo>();
//Obtém a referência ao tipo que está sendo configurado
tipo=dynamic_cast<Tipo *>(this->objeto);
//Caso o mesmo seja marcado como uma enumeração no formulário
if(enumeracao_rb->isChecked())
{
//Configura a instância como tipo enumeração
tipo->definirConfiguracao(Tipo::TIPO_ENUMERACAO);
//Remove todas as enumerações atuais do tipo
tipo->removerEnumeracoes();
//Insere na instância de tipo as enumerações configuradas no formulário
qtd=tab_enumeracoes->obterNumLinhas();
for(i=0; i < qtd; i++)
tipo->adicionarEnumeracao(tab_enumeracoes->obterTextoCelula(i,0));
}
//Caso o mesmo seja marcado como um tipo composto no formulário
else if(composto_rb->isChecked())
{
//Configura a instância como tipo composto
tipo->definirConfiguracao(Tipo::TIPO_COMPOSTO);
//Remove todos os atributos do tipo
tipo->removerAtributos();
//Insere na instância de tipo os atributos configurados no formulário
qtd=tab_atributos->obterNumLinhas();
for(i=0; i < qtd; i++)
tipo->adicionarAtributo(tab_atributos->obterDadoLinha(i).value<Parametro>());
}
//Caso o mesmo seja marcado como um tipo base no formulário
else
{
//Configura a instância como tipo base
tipo->definirConfiguracao(Tipo::TIPO_BASE);
//Atribui todos os valores configurados no formulário à instância de tipo
tipo->definirTipoCopia(tipo_copia->obterTipoPgSQL());
tipo->definirElemento(tipo_elemento->obterTipoPgSQL());
tipo->definirCompInterno(comp_int_sb->value());
tipo->definirPorValor(por_valor_chk->isChecked());
tipo->definirPreferido(preferido_chk->isChecked());
tipo->definirDelimitador(delimitador_edt->text().at(0).toAscii());
tipo->definirValorPadrao(valor_padrao_edt->text());
tipo->definirCategoria(TipoCategoria(categoria_cmb->currentText()));
tipo->definirAlinhamento(TipoPgSQL(alinhamento_cmb->currentText()));
tipo->definirArmazenamento(TipoArmazenamento(armazenamento_cmb->currentText()));
//Atribui todas as funções definidas nos seletores à instância de tipo
for(i=Tipo::FUNCAO_INPUT; i <= Tipo::FUNCAO_ANALYZE; i++)
tipo->definirFuncao(i, dynamic_cast<Funcao *>(sel_funcoes[i]->obterObjeto()));
}
ObjetoBaseWidget::aplicarConfiguracao();
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);
}
}
//----------------------------------------------------------
void RelacionamentoWidget::aplicarConfiguracao(void)
{
try
{
Relacionamento *relacao=NULL;
unsigned tipo_rel, qtd, i;
vector<unsigned> id_cols;
/* Devido a complexidade da classe Relacionamento e a forte ligação entre todos os
relacinamentos do modelo, é necessário armazenar o XML dos objetos especiais e
desconectar TODOS os relacionamentos, executar a modificação no
relacionamento e logo após revalidar todos os demais */
modelo->obterXMLObjetosEspeciais();
modelo->desconectarRelacionamentos();
if(!this->novo_obj)
{
//Adiciona o relacionamento à lista de operações antes de ser modificado
lista_op->adicionarObjeto(this->objeto, Operacao::OBJETO_MODIFICADO);
}
//Aplica as configurações básicas
ObjetoBaseWidget::aplicarConfiguracao();
//Caso o objeto seja um relacionamento tabela-tabela
if(this->objeto->obterTipoObjeto()==OBJETO_RELACAO)
{
//Obtém a referência ao mesmo fazendo o cast correto
relacao=dynamic_cast<Relacionamento *>(this->objeto);
tipo_rel=relacao->obterTipoRelacionamento();
relacao->blockSignals(true);
/* Atribui os valores configurados no formulário ao relacionamento.
Alguns campos são atribuído ao objeto somente para um tipo específico
de relacionamento */
relacao->definirSufixoTabela(RelacionamentoBase::TABELA_ORIGEM, sufixo_orig_edt->text());
relacao->definirSufixoTabela(RelacionamentoBase::TABELA_DESTINO, sufixo_dest_edt->text());
relacao->definirSufixoAutomatico(sufixo_auto_chk->isChecked());
relacao->definirTabelaObrigatoria(RelacionamentoBase::TABELA_ORIGEM, false);
relacao->definirTabelaObrigatoria(RelacionamentoBase::TABELA_DESTINO, false);
if(tab_orig_obrig_chk->isEnabled())
relacao->definirTabelaObrigatoria(RelacionamentoBase::TABELA_ORIGEM, tab_orig_obrig_chk->isChecked());
if(tab_dest_obrig_chk->isEnabled())
relacao->definirTabelaObrigatoria(RelacionamentoBase::TABELA_DESTINO, tab_dest_obrig_chk->isChecked());
if(tipo_rel==RelacionamentoBase::RELACIONAMENTO_GEN ||
tipo_rel==RelacionamentoBase::RELACIONAMENTO_DEP)
{
//Obtém os ids das colunas selecionadas como participantes da chave primária especial
qtd=coluna_rel_lst->count();
for(i=0; i < qtd; i++)
{
//Caso o item na lista esteja selecionado seu id é armazenado no vetor de ids
if(coluna_rel_lst->item(i)->checkState()==Qt::Checked)
id_cols.push_back(i);
}
//Atribui o vetor de ids configurado acima como sendo os ids das colunas da chave primária especial
relacao->definirColsChavePrimariaEspecial(id_cols);
}
//Campos específicos para relacionamentos 1-n e 1-1
else if(tipo_rel==RelacionamentoBase::RELACIONAMENTO_1N ||
tipo_rel==RelacionamentoBase::RELACIONAMENTO_11)
{
relacao->definirIdentificador(identificador_chk->isChecked());
relacao->definirPostergavel(postergavel_chk->isChecked());
relacao->definirTipoPostergacao(TipoPostergacao(tipo_postergacao_cmb->currentText()));
}
//Campos específicos para relacionamentos n-n
else if(tipo_rel==RelacionamentoBase::RELACIONAMENTO_NN)
relacao->definirNomeTabelaRelNN(nome_tab_relnn_edt->text());
try
{
/* Caso o relacinamento seja de dependência, generalização ou
identificador verifica se existe redundância de relacionamentos */
if(tipo_rel==RelacionamentoBase::RELACIONAMENTO_DEP ||
tipo_rel==RelacionamentoBase::RELACIONAMENTO_GEN ||
relacao->relacionamentoIdentificador())
modelo->verificarRedundanciaRelacoes(relacao);
/* Faz a validação dos relacionamentos para refletir a nova configuração
do relacionamento */
modelo->validarRelacionamentos();
relacao->blockSignals(false);
relacao->definirModificado(true);
}
catch(Excecao &e)
{
/* O único erro que é desconsiderado é o de invalidação de objetos, pois,
mesmo com a restauração do estado original do relacionamento estes
objetos não são recuperados */
if(e.obterTipoErro()==ERR_PGMODELER_REFCOLUNAINVTABELA)
//Exibe uma mensagem de erro com o conteúdo da exceção
caixa_msg->show(e);
//Para os demais erros a exceção é encaminhada
else
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
//Finaliza o encademanto de operações aberto
lista_op->finalizarEncadeamentoOperacoes();
//Finaliza a configuração do relacionamento
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 */
lista_op->anularEncadeamentoOperacoes(true);
this->cancelarConfiguracao();
lista_op->anularEncadeamentoOperacoes(false);
/* Faz a validação dos relacionamentos para refletir a nova configuração
do relacionamento */
modelo->validarRelacionamentos();
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
//----------------------------------------------------------
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);
}
}
