void OperationListWidget::redoOperation(void)
{
try
{
connect(model_wgt->op_list, SIGNAL(s_operationExecuted(int,QString,unsigned)), task_prog_wgt, SLOT(updateProgress(int,QString,unsigned)));
task_prog_wgt->setWindowTitle(trUtf8("Redoing operations..."));
task_prog_wgt->show();
model_wgt->op_list->redoOperation();
task_prog_wgt->close();
disconnect(model_wgt->op_list, nullptr, task_prog_wgt, nullptr);
notifyUpdateOnModel();
model_wgt->scene->clearSelection();
}
catch(Exception &e)
{
task_prog_wgt->close();
this->updateOperationList();
disconnect(model_wgt->op_list, nullptr, task_prog_wgt, nullptr);
throw Exception(e.getErrorMessage(),e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
//-----------------------------------------------------------
void ListaOperacoesWidget::refazerOperacao(void)
{
try
{
//Exibe o progresso de operações de refazer
connect(modelo_wgt->lista_op, SIGNAL(s_operacaoExecutada(int,QString,unsigned)), prog_tarefa, SLOT(executarProgesso(int,QString,unsigned)));
prog_tarefa->setWindowTitle(trUtf8("Redoing operations..."));
prog_tarefa->show();
modelo_wgt->lista_op->refazerOperacao();
prog_tarefa->close();
disconnect(modelo_wgt->lista_op, NULL, prog_tarefa, NULL);
atualizarModeloObjetos();
//Limpa a seleção na cena
modelo_wgt->cena->clearSelection();
}
catch(Excecao &e)
{
prog_tarefa->close();
disconnect(modelo_wgt->lista_op, NULL, prog_tarefa, NULL);
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
void ClientConnection::run()
{
DEBUG_ONLY(Mara::MLogger::log(Mara::LogLevel::Debug, QString("Creating connection socket.")));
setStatus(MaraClient::Connection_Inactive);
_userDisconnected = false;
Mara::MTcpSocket socket;
_socket = &socket;
_socketError = "";
_connectTimer = new QTimer(&socket);
QObject::connect(_connectTimer, SIGNAL(timeout()), this, SLOT(checkConnection()));
_connectTimer->setSingleShot(true);
QObject::connect(_socket, SIGNAL(connected()), this, SLOT(socketConnected()));
QObject::connect(_socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
QObject::connect(_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError)));
QObject::connect(this, SIGNAL(signalSendPacket(const Mara::MPacket*)),
_socket, SLOT(sendPacket(const Mara::MPacket*)));
QObject::connect(_socket, SIGNAL(packetReceived(Mara::MPacket*)),
_packetHandler, SLOT(handlePacket(Mara::MPacket*)));
DEBUG_ONLY(Mara::MLogger::log(Mara::LogLevel::Debug, QString("Connecting to %1:%2.").arg(_serverAddress).arg(_serverPort)));
setStatus(MaraClient::Connection_Connecting);
_socket->connectToHost(_serverAddress, _serverPort);
_connectTimer->start(10000);
_socketActive = true;
exec();
_socketActive = false;
_socket->close();
_serverAddress = "";
_serverPort = 0;
if(_connectTimer && _connectTimer->isActive())
_connectTimer->stop();
if(_status != MaraClient::Connection_Error)
setStatus(MaraClient::Connection_Inactive);
}
void ModelExportForm::exportModel(void)
{
try
{
this->resize(this->maximumSize());
progress_pb->setValue(0);
ln2_frm->setVisible(true);
progress_lbl->setVisible(true);
progress_pb->setVisible(true);
ico_lbl->setVisible(false);
if(export_to_img_rb->isChecked())
{
QPixmap pix;
QRectF ret=model->scene->itemsBoundingRect();
bool exibir_grade, exibir_lim, alin_objs;
ObjectsScene::getGridOptions(exibir_grade, alin_objs, exibir_lim);
ObjectsScene::setGridOptions(show_grid_chk->isChecked(), false, show_delim_chk->isChecked());
pix=QPixmap(ret.size().toSize());
QPainter p(&pix);
model->scene->clearSelection();
model->scene->update();
model->scene->render(&p, QRectF(QPointF(0,0), pix.size()), ret);
ObjectsScene::setGridOptions(exibir_grade, alin_objs, exibir_lim);
model->scene->update();
if(!pix.save(image_edt->text()))
throw Exception(Exception::getErrorMessage(ERR_FILE_NOT_WRITTEN).arg(Utf8String::create(image_edt->text())),
ERR_FILE_NOT_WRITTEN,__PRETTY_FUNCTION__,__FILE__,__LINE__);
}
else
{
int type_id;
QString version, sql_buf, sql_cmd;
DBConnection *conn=NULL, new_db_conn;
unsigned i, count;
bool db_created=false;
int objs_idx[]={-1, -1};
ObjectType types[]={OBJ_ROLE, OBJ_TABLESPACE};
BaseObject *object=NULL;
vector<Exception> errors;
/* Error codes treated in this method
42P04 duplicate_database
42723 duplicate_function
42P06 duplicate_schema
42P07 duplicate_table
42710 duplicate_object
Reference:
http://www.postgresql.org/docs/current/static/errcodes-appendix.html*/
QString error_codes[]={"42P04", "42723", "42P06", "42P07", "42710"};
vector<QString> err_codes_vect;
try
{
for(i=0; i < 5; i++)
err_codes_vect.push_back(error_codes[i]);
task_prog_wgt->setWindowTitle(trUtf8("Generating source code..."));
task_prog_wgt->show();
connect(this->model->db_model, SIGNAL(s_objetoCarregado(int,QString,unsigned)),
task_prog_wgt, SLOT(updateProgress(int,QString,unsigned)));
progress_lbl->setText(trUtf8("Initializing model export..."));
progress_lbl->repaint();
if(export_to_file_rb->isChecked())
{
//Sets the SQL version for the output code
SchemaParser::setPgSQLVersion(pgsqlvers_cmb->currentText());
progress_lbl->setText(trUtf8("Saving file '%1'").arg(file_edt->text()));
model->db_model->saveModel(file_edt->text(), SchemaParser::SQL_DEFINITION);
progress_pb->setValue(25);
}
//Exporting directly to DBMS
else
{
//Get the selected connection to database
conn=reinterpret_cast<DBConnection *>(connections_cmb->itemData(connections_cmb->currentIndex()).value<void *>());
conn->connect();
//Retrive the DBMS version in order to generate the correct code
version=(conn->getDBMSVersion()).mid(0,3);
//Overriding the DBMS version case the checkbox is marked
if(pgsqlvers_chk->isChecked())
SchemaParser::setPgSQLVersion(pgsqlvers1_cmb->currentText());
else
SchemaParser::setPgSQLVersion(version);
//Creates the roles and tablespaces separately from the other objects
for(type_id=0; type_id < 2; type_id++)
{
count=model->db_model->getObjectCount(types[type_id]);
for(i=0; i < count; i++)
{
object=model->db_model->getObject(i, types[type_id]);
progress_lbl->setText(trUtf8("Creating object '%1' (%2)...").arg(Utf8String::create(object->getName())).arg(object->getTypeName()));
progress_lbl->repaint();
try
{
conn->executeDDLCommand(object->getCodeDefinition(SchemaParser::SQL_DEFINITION));
}
catch(Exception &e)
{
if(!ignorar_dup_chk->isChecked() ||
(ignorar_dup_chk->isChecked() &&
std::find(err_codes_vect.begin(), err_codes_vect.end(), e.getExtraInfo())==err_codes_vect.end()))
throw Exception(e.getErrorMessage(),
e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__,&e);
else
errors.push_back(e);
}
progress_pb->setValue((10 * (type_id+1)) + ((i/static_cast<float>(count)) * 10));
objs_idx[type_id]++;
}
}
//Creating the database on the DBMS
progress_lbl->setText(trUtf8("Creating database '%1'...").arg(Utf8String::create(model->db_model->getName())));
progress_lbl->repaint();
try
{
conn->executeDDLCommand(model->db_model->__getCodeDefinition(SchemaParser::SQL_DEFINITION));
db_created=true;
}
catch(Exception &e)
{
if(!ignorar_dup_chk->isChecked() ||
(ignorar_dup_chk->isChecked() &&
std::find(err_codes_vect.begin(), err_codes_vect.end(), e.getExtraInfo())==err_codes_vect.end()))
throw Exception(e.getErrorMessage(),
e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__,&e);
else
errors.push_back(e);
}
progress_pb->setValue(30);
new_db_conn=(*conn);
new_db_conn.setConnectionParam(DBConnection::PARAM_DB_NAME, model->db_model->getName());
progress_lbl->setText(trUtf8("Connecting to database '%1'...").arg(Utf8String::create(model->db_model->getName())));
progress_lbl->repaint();
new_db_conn.connect();
progress_pb->setValue(50);
//Creating the other object types
progress_lbl->setText(trUtf8("Creating objects on database '%1'...").arg(Utf8String::create(model->db_model->getName())));
progress_lbl->repaint();
//Gera o código SQL de todo o banco
sql_buf=model->db_model->getCodeDefinition(SchemaParser::SQL_DEFINITION, false);
/* Extract each SQL command from the buffer and execute them separately. This is done
to permit the user, in case of error, identify what object is wrongly configured. */
i=0;
count=sql_buf.size();
while(i < count)
{
try
{
sql_cmd.clear();
sql_cmd=sql_cmd.trimmed();
//Extract the characters until the end of buffer o a semicolon
while(i < count)
{
if(sql_buf.at(i)==';' && sql_buf.at(i+1)=='\n')
{
sql_cmd+=';';
break;
}
else
sql_cmd+=sql_buf.at(i);
i++;
}
//Executes the extracted command
if(!sql_cmd.isEmpty())
{
i++;
new_db_conn.executeDDLCommand(sql_cmd);
}
progress_pb->setValue(50 + ((i/static_cast<float>(count)) * 10));
}
catch(Exception &e)
{
if(!ignorar_dup_chk->isChecked() ||
(ignorar_dup_chk->isChecked() &&
std::find(err_codes_vect.begin(), err_codes_vect.end(), e.getExtraInfo())==err_codes_vect.end()))
throw Exception(Exception::getErrorMessage(ERR_EXPORT_FAILURE).arg(Utf8String::create(sql_cmd)),
ERR_EXPORT_FAILURE,__PRETTY_FUNCTION__,__FILE__,__LINE__,&e);
else
errors.push_back(e);
}
}
}
task_prog_wgt->close();
disconnect(this->model->db_model, NULL, task_prog_wgt, NULL);
}
catch(Exception &e)
{
QString drop_cmd=QString("DROP %1 %2;");
task_prog_wgt->close();
disconnect(this->model->db_model, NULL, task_prog_wgt, NULL);
//In case of error during the export all created object are removed
if(db_created || objs_idx[0] >= 0 || objs_idx[1] >= 0)
{
if(new_db_conn.isStablished())
new_db_conn.close();
if(db_created)
conn->executeDDLCommand(drop_cmd
.arg(model->db_model->getSQLName())
.arg(model->db_model->getName(true)));
for(type_id=1; type_id >=0; type_id--)
{
while(objs_idx[type_id] >= 0)
{
object=model->db_model->getObject(objs_idx[type_id], types[type_id]);
try
{
conn->executeDDLCommand(drop_cmd
.arg(object->getSQLName())
.arg(object->getName(true)));
}
catch(Exception &e)
{}
objs_idx[type_id]--;
}
}
}
if(errors.empty())
throw Exception(e.getErrorMessage(),e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
else
{
errors.push_back(e);
throw Exception(e.getErrorMessage(),__PRETTY_FUNCTION__,__FILE__,__LINE__, errors);
}
}
}
progress_pb->setValue(100);
progress_lbl->setText(trUtf8("Exporting process sucessfuly ended!"));
progress_lbl->repaint();
ico_lbl->setPixmap(QPixmap(QString(":/icones/icones/msgbox_info.png")));
ico_lbl->setVisible(true);
QTimer::singleShot(5000, this, SLOT(hideExportProgress(void)));
}
catch(Exception &e)
{
MessageBox msg_box;
progress_lbl->setText(trUtf8("Error on export!"));
progress_lbl->repaint();
ico_lbl->setPixmap(QPixmap(QString(":/icones/icones/msgbox_erro.png")));
ico_lbl->setVisible(true);
QTimer::singleShot(5000, this, SLOT(hideExportProgress(void)));
msg_box.show(e);
}
}
//-----------------------------------------------------------
void FormExportacao::exportarModelo(void)
{
try
{
//Redimensiona a janela para exibição dos widgets de progresso
this->resize(this->maximumSize());
//Exibe os widgets de progresso
prog_pb->setValue(0);
ln2_frm->setVisible(true);
rot_prog_lbl->setVisible(true);
prog_pb->setVisible(true);
//Inicialmente o ícone de sucesso/erro da exportação fica escondido
ico_lbl->setVisible(false);
if(exportacao_png_rb->isChecked())
{
QPixmap pix;
QRectF ret=modelo_wgt->cena->itemsBoundingRect();
bool exibir_grade, exibir_lim, alin_objs;
//Faz um backup das opções de grade da cena
CenaObjetos::obterOpcoesGrade(exibir_grade, alin_objs, exibir_lim);
//Redefine as opções da grade conforme os checkboxes
CenaObjetos::definirOpcoesGrade(grade_chk->isChecked(), false, lim_paginas_chk->isChecked());
//Cria o pixmap
pix.resize(ret.size().toSize());
///Desenha a cena no pixmap e faz a escala correta
QPainter p(&pix);
modelo_wgt->cena->update();
modelo_wgt->cena->render(&p, QRectF(QPointF(0,0), pix.size()), ret);
//Restaura as definições da grade
CenaObjetos::definirOpcoesGrade(exibir_grade, alin_objs, exibir_lim);
modelo_wgt->cena->update();
//Caso a imagem não possa ser salva, retorna um erro
if(!pix.save(imagem_edt->text()))
throw Excecao(Excecao::obterMensagemErro(ERR_PGMODELER_ARQNAOGRAVADO).arg(QString::fromUtf8(imagem_edt->text())),
ERR_PGMODELER_ARQNAOGRAVADO,__PRETTY_FUNCTION__,__FILE__,__LINE__);
}
else
{
int id_tipo;
QString versao, buf_sql, cmd_sql;
ConexaoBD *conexao=NULL, conex_novo_bd;
unsigned i, qtd;
bool bd_criado=false;
int idx_objs[]={-1, -1};
TipoObjetoBase vet_tipos[]={OBJETO_PAPEL, OBJETO_ESPACO_TABELA};
ObjetoBase *objeto=NULL;
vector<Excecao> vet_erros;
/* Vetor que armazena os códigos de erros referentes a objetos duplicados no PostgreSQL:
Estes erros podem ser consultados na íntegra em:
http://www.postgresql.org/docs/current/static/errcodes-appendix.html
Códigos usados neste método:
42P04 duplicate_database
42723 duplicate_function
42P06 duplicate_schema
42P07 duplicate_table
42710 duplicate_object
*/
QString cod_erros[]={"42P04", "42723", "42P06", "42P07", "42710"};
vector<QString> vet_cod_erros;
try
{
for(i=0; i < 5; i++)
vet_cod_erros.push_back(cod_erros[i]);
//Configura o widget de progresso para capturar o progresso da geração do código
prog_tarefa->setWindowTitle(trUtf8("Generating source code..."));
prog_tarefa->show();
connect(this->modelo_wgt->modelo, SIGNAL(s_objetoCarregado(int,QString,unsigned)),
prog_tarefa, SLOT(executarProgesso(int,QString,unsigned)));
rot_prog_lbl->setText(trUtf8("Initializing model export..."));
rot_prog_lbl->repaint();
//Caso seja exportação em arquivo
if(exportacao_arq_rb->isChecked())
{
//Define a versão do postgresql a ser adotada
ParserEsquema::definirVersaoPgSQL(pgsqlvers_cmb->currentText());
rot_prog_lbl->setText(trUtf8("Saving file '%1'").arg(arquivo_edt->text()));
//Salva o modelo em arquivo
modelo_wgt->modelo->salvarModelo(arquivo_edt->text(), ParserEsquema::DEFINICAO_SQL);
prog_pb->setValue(25);
}
//Caso seja exportação direto para o SGBD
else
{
//Obtém a conexão selecionada no combo
conexao=reinterpret_cast<ConexaoBD *>(conexoes_cmb->itemData(conexoes_cmb->currentIndex()).value<void *>());
//Tenta se conectar
conexao->conectar();
//Obtém a versão do servidor PostgreSQL. Essa versão é usada na geração de código a seguir
versao=(conexao->obterVersaoSGBD()).mid(0,3);
/* Caso o checkbox de versão esteja marcada então a versão do servidor é ignorada
usando aquela escolhida no combo */
if(pgsqlvers_chk->isChecked())
ParserEsquema::definirVersaoPgSQL(pgsqlvers1_cmb->currentText());
else
ParserEsquema::definirVersaoPgSQL(versao);
//Cria os Papéis e espaços de tabela separadamente dos demais
for(id_tipo=0; id_tipo < 2; id_tipo++)
{
qtd=modelo_wgt->modelo->obterNumObjetos(vet_tipos[id_tipo]);
for(i=0; i < qtd; i++)
{
objeto=modelo_wgt->modelo->obterObjeto(i, vet_tipos[id_tipo]);
rot_prog_lbl->setText(trUtf8("Creating object '%1' (%2)...").arg(QString::fromUtf8(objeto->obterNome())).arg(objeto->obterNomeTipoObjeto()));
rot_prog_lbl->repaint();
try
{
conexao->executarComandoDDL(objeto->obterDefinicaoObjeto(ParserEsquema::DEFINICAO_SQL));
}
catch(Excecao &e)
{
/* Caso o checkbox de ignorar duplicidade não esteja marcado ou se este está marcado porém a
informação adicinal da exceção não carrega um dos códigos indicando duplicidade de objeto
redireciona o erro, caso contrário apenas o ignora */
if(!ignorar_dup_chk->isChecked() ||
(ignorar_dup_chk->isChecked() &&
std::find(vet_cod_erros.begin(), vet_cod_erros.end(), e.obterInfoAdicional())==vet_cod_erros.end()))
throw Excecao(e.obterMensagemErro(),
e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__,&e);
else
vet_erros.push_back(e);
}
prog_pb->setValue((10 * (id_tipo+1)) + ((i/static_cast<float>(qtd)) * 10));
idx_objs[id_tipo]++;
}
}
//Cria o banco de dados no servidor
rot_prog_lbl->setText(trUtf8("Creating database '%1'...").arg(QString::fromUtf8(modelo_wgt->modelo->obterNome())));
rot_prog_lbl->repaint();
try
{
conexao->executarComandoDDL(modelo_wgt->modelo->__obterDefinicaoObjeto(ParserEsquema::DEFINICAO_SQL));
bd_criado=true;
}
catch(Excecao &e)
{
/* Caso o checkbox de ignorar duplicidade não esteja marcado ou se este está marcado porém a
informação adicinal da exceção não carrega um dos códigos indicando duplicidade de objeto
redireciona o erro, caso contrário apenas o ignora */
if(!ignorar_dup_chk->isChecked() ||
(ignorar_dup_chk->isChecked() &&
std::find(vet_cod_erros.begin(), vet_cod_erros.end(), e.obterInfoAdicional())==vet_cod_erros.end()))
throw Excecao(e.obterMensagemErro(),
e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__,&e);
else
vet_erros.push_back(e);
}
prog_pb->setValue(30);
conex_novo_bd=(*conexao);
conex_novo_bd.definirParamConexao(ConexaoBD::PARAM_NOME_BD, modelo_wgt->modelo->obterNome());
rot_prog_lbl->setText(trUtf8("Connecting to database '%1'...").arg(QString::fromUtf8(modelo_wgt->modelo->obterNome())));
rot_prog_lbl->repaint();
conex_novo_bd.conectar();
prog_pb->setValue(50);
//Cria os demais objetos no novo banco
rot_prog_lbl->setText(trUtf8("Creating objects on database '%1'...").arg(QString::fromUtf8(modelo_wgt->modelo->obterNome())));
rot_prog_lbl->repaint();
//Gera o código SQL de todo o banco
buf_sql=modelo_wgt->modelo->obterDefinicaoObjeto(ParserEsquema::DEFINICAO_SQL, false);
/* Extrai cada comando SQL do buffeer e o executa separadamente, isso é feito
para que, em caso de erro, o usuário saiba exatamente a SQL que gerou a
exceção uma vez que a libpq não proporciona este nível de detalhes */
i=0;
qtd=buf_sql.size();
while(i < qtd)
{
try
{
cmd_sql.clear();
//Executa um trimm no comando SQL extraído
cmd_sql=cmd_sql.trimmed();
//Extrai os caracteres até encontrar o final do buffer ou um ';'
while(i < qtd)
{
/* Caso o caracter seja um ';' e o próximo seja uma quebra de linha, significa o final do comando SQL
assim a varredura será interrompida */
if(buf_sql.at(i)==';' && buf_sql.at(i+1)=='\n')
{
cmd_sql+=';';
break;
}
else
cmd_sql+=buf_sql.at(i);
i++;
}
//Executa um trimm no comando SQL extraído
//cmd_sql=cmd_sql.trimmed();
//Caso o comando não esteja vazio
if(!cmd_sql.isEmpty())
{
i++;
//Executa-o na conexão
conex_novo_bd.executarComandoDDL(cmd_sql);
}
prog_pb->setValue(50 + ((i/static_cast<float>(qtd)) * 10));
}
catch(Excecao &e)
{
/* Caso o checkbox de ignorar duplicidade não esteja marcado ou se este está marcado porém a
informação adicinal da exceção não carrega um dos códigos indicando duplicidade de objeto
redireciona o erro, caso contrário apenas o ignora */
if(!ignorar_dup_chk->isChecked() ||
(ignorar_dup_chk->isChecked() &&
std::find(vet_cod_erros.begin(), vet_cod_erros.end(), e.obterInfoAdicional())==vet_cod_erros.end()))
throw Excecao(Excecao::obterMensagemErro(ERR_PGMODELERUI_FALHAEXPORTACAO).arg(QString::fromUtf8(cmd_sql)),
ERR_PGMODELERUI_FALHAEXPORTACAO,__PRETTY_FUNCTION__,__FILE__,__LINE__,&e);
else
vet_erros.push_back(e);
}
}
}
prog_tarefa->close();
disconnect(this->modelo_wgt->modelo, NULL, prog_tarefa, NULL);
}
catch(Excecao &e)
{
QString drop_cmd=QString("DROP %1 %2;");
prog_tarefa->close();
disconnect(this->modelo_wgt->modelo, NULL, prog_tarefa, NULL);
/* Caso os algum objeto tenha sido criado é preciso excluí-los do banco.
Para isso, os mesmos são removidos na ordem contrária de criação:
banco de dados, espaço de tabelas e papéis */
if(bd_criado || idx_objs[0] >= 0 || idx_objs[1] >= 0)
{
if(conex_novo_bd.conexaoEstabelecida())
conex_novo_bd.fechar();
//Caso o banco de dados foi criado, exclui o mesmo
if(bd_criado)
conexao->executarComandoDDL(drop_cmd
.arg(modelo_wgt->modelo->obterNomeSQLObjeto())
.arg(modelo_wgt->modelo->obterNome(true)));
//Removendo os espaços de tabela e papéis
for(id_tipo=1; id_tipo >=0; id_tipo--)
{
while(idx_objs[id_tipo] >= 0)
{
objeto=modelo_wgt->modelo->obterObjeto(idx_objs[id_tipo], vet_tipos[id_tipo]);
try
{
conexao->executarComandoDDL(drop_cmd
.arg(objeto->obterNomeSQLObjeto())
.arg(objeto->obterNome(true)));
}
catch(Excecao &e)
{}
idx_objs[id_tipo]--;
}
}
}
if(vet_erros.empty())
throw Excecao(e.obterMensagemErro(),e.obterTipoErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
else
{
vet_erros.push_back(e);
throw Excecao(e.obterMensagemErro(),__PRETTY_FUNCTION__,__FILE__,__LINE__, vet_erros);
}
}
}
//Finaliza o progresso da exportação
prog_pb->setValue(100);
rot_prog_lbl->setText(trUtf8("Exporting process sucessfuly ended!"));
rot_prog_lbl->repaint();
ico_lbl->setPixmap(QPixmap(QString(":/icones/icones/msgbox_info.png")));
ico_lbl->setVisible(true);
//Oculta os widgets de progresso após 10 segundos
QTimer::singleShot(5000, this, SLOT(ocultarProgressoExportacao(void)));
}
catch(Excecao &e)
{
//Exibe no progresso a mensagem de falha
rot_prog_lbl->setText(trUtf8("Error on export!"));
rot_prog_lbl->repaint();
ico_lbl->setPixmap(QPixmap(QString(":/icones/icones/msgbox_erro.png")));
ico_lbl->setVisible(true);
//Oculta os widgets de progresso após 10 segundos
QTimer::singleShot(5000, this, SLOT(ocultarProgressoExportacao(void)));
caixa_msg->show(e);
}
}
