コード例 #1
0
ファイル: dominiowidget.cpp プロジェクト: Barahir44/pgmodeler
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);
 }
}
コード例 #2
0
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);
 }
}
コード例 #3
0
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);
 }
}
コード例 #4
0
//----------------------------------------------------------
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);
 }
}
コード例 #5
0
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);
 }
}
コード例 #6
0
//---------------------------------------------------------
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);
 }
}
コード例 #7
0
ファイル: gatilhowidget.cpp プロジェクト: arleincho/pgmodeler
//----------------------------------------------------------
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);
 }
}
コード例 #8
0
ファイル: tabelawidget.cpp プロジェクト: esthinri/pgmodeler
//----------------------------------------------------------
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);
 }
}
コード例 #9
0
//----------------------------------------------------------
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);
 }
}
コード例 #10
0
ファイル: regrawidget.cpp プロジェクト: esthinri/pgmodeler
//----------------------------------------------------------
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);
 }
}
コード例 #11
0
//----------------------------------------------------------
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);
 }
}
コード例 #12
0
ファイル: tipowidget.cpp プロジェクト: esthinri/pgmodeler
//----------------------------------------------------------
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);
 }
}
コード例 #13
0
//----------------------------------------------------------
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);
 }
}
コード例 #14
0
ファイル: funcaowidget.cpp プロジェクト: arleincho/pgmodeler
//----------------------------------------------------------
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);
 }
}