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 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 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 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 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 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);
}
}
