Inicio.
O objetivo deste tutorial é demonstrar uma forma de se bloquear um sistema Qt após um tempo de inatividade do mouse ou do teclado, quando, por exemplo, o usuário se ausenta da sala e esquece o sistema aberto possibilitando assim que alguem não autorizado utilize o sistema e eventualmente exclua ou altere dados importantes.
Portanto este tutorial é sobre um recurso de segurança que podemos implementar num sistema Qt, complementando o tutorial anterior onde vimos como gerar senhas criptografadas de acesso ao sistema e como estabelecer níveis de acesso dentro do sistema.
Usaremos como base o aplicativo desenvolvido no tutorial anterior:
http://www.sistemasparalinux.com.br/tutorial_QCA.html
Os fontes podem ser obtidos aqui:
http://www.sistemasparalinux.com.br/fontes_sistema_qca.txt
Vamos criar uma classe herdada de QObject que ira utilizar como base um objeto QTimer e os eventos mouseMoveEvent e keyPressEvent.
Também vamos criar um novo “cadastro”, na verdade um form sem nada, apenas para vermos o efeito das rotinas que iremos desenvolver para travar o sistema.
Vamos começar definindo uma classe herdada de Qobject, esta classe contera as definições das funções que irão bloquear o sistema.
trava_Sistema.h
trava_Sistema.cpp
O constructor da classe lê no arquivo config.txt o parâmetro de tempo para o QTimer.
Logo após o objeto QTimer é instanciado com o parâmetro de tempo lido no arquivo, depois conecta-se o signal timeout() do QTimer com a função que ira chamar a tela de login.
Depois temos a definição do SLOT publico reinicia_Timer(), ele foi definido como public para que possa ser chamado a partir de outros widgets onde um objeto da classe trava_Sistema for instanciado.
Por ultimo a definição da função chama_Login(), que ira chamar a tela de login após decorrido o tempo do timer, ela para o timer, instancia a tela de login, se o usuário logar corretamente, a tela de login é destruida e o QTimer re-iniciado.
A lógica da classe trava_Sistema é muito simples, instancia-se um objeto dela no constructor do centralwidget do aplicativo, no nosso caso um objeto da classe fPrincipal, depois conecta-se os eventos keyPressEvent() e mouseMoveEvent() a função publica reinicia_Timer() do objeto da classe trava_Sistema, então sempre que o mouse é movido ou o teclado utilizado, o QTimer é re-iniciado evitando-se que o SIGNAL timeout() seja enviado.
Caso o sistema permaneça parado, seja pela ausência do usuário ou outra razão, o QTimer corre até o fim, até atingir o limite de tempo que foi fornecido a ele como parâmetro, ai a tela de login é instanciada é exibida, como ela é um formulário modal, sua propriedade windowModality esta definida como applicationModal, ela “seqüestra” a janela, não podendo ser fechada e mesmo que seja minimizada, a janela por traz permanece inacessível, impedindo assim o acesso de pessoas não autorizadas ao sistema, quando é feito o login, o sistema é liberado e o QTimer começa a correr de novo.
Você deve escolher um valor de tempo adequado, prevendo a média de tempo que um eventual usuário pode permanecer ausenta, isto no caso de ele esquecer o sistema aberto, o ideal é que se encerre o aplicativo, mas no caso de um esquecimento estabeleça um tempo, que não deve ser muito pequeno para não causar o incomodo de toda hora a tela de login aparecer, mas que também não pode ser muito longo, permitindo que alguem não autorizado acesse o sistema. O valor de tempo deve ser colocado no arquivo config.txt, também pode ser colocado em um campo de uma tabela no banco de dados ou ficar fixo dentro do sistema, você deve ponderar a estratégia mais segura.
Config.txt
[banco]
database = QPSQL
hostname = localhost
databasename = teste_senha
[timer]
tempo =10000
A tela de desbloqueio herda de fLogin_Parent, que também é a classe mãe da tela de login que aparece quando se inicia o sistema, criei duas classe distintas porque no inicio quero criar o efeito da tela de login sobreposta a janela principal, se a tela de login for fechada sem digitar a senha, o sistema é finalizado, no inicio a tela de login é instanciada por main.cpp e deve ser destruída por ele, se não for digitada a senha, main.cpp deve ter algum meio de saber, criei um ponteiro que retorna esta informação a main.cpp, por isso a tela de login inicial não pode ter em seu constructor o atributo de auto-destruição: this->setAttribute(Qt::WA_DeleteOnClose,true), senão o ponteiro é destruido.
De posse do valor que a tela de login retorna no ponteiro, main.cpp sabe se foi digitada a senha ou não, se não a janela principal também é fechada.
Já na tela que ira aparecer no caso de inatividade do mouse ou teclado, não é necessário o retorno de nenhuma informação, porque ela não pode ser fechada sem a senha correta, o evento closeEvent do widget é re-implementado para testar se a senha foi digitada corretamente, se não foi a janela simplesmente não fecha (event->ignore()). Por isso é necessario o atributo (Qt::WA_DeleteOnClose,true) para auto-destruir o objeto.
fDesbloqueia_Sistema.h
fDesbloqueia_Sistema.cpp
A tela de desbloqueio inicia atribuindo o valor false a uma variável booleana que ira controlar se sera possivel ou não fechar a janela.
Depois instancia-se uma QsqlQuery para consulta ao banco e um objeto da classe pesq_Senha para as rotinas de criptografia QCA.
Na função botao_OK_Click() é exatamente igual a tela de login inicial do sistema, que esta toda comentada no meu tutorial anterior:
http://www.sistemasparalinux.com.br/tutorial_QCA.html
No evento closeEvent testa-se a variavel senha_Correta que começou com false no constructor e na passagem pela função botao_OK_Click() tem seu valor definido de acordo com login correto ou não.
Se a variável for false, o evento é ignorado e a janela não fecha, mantendo o sistema bloqueado.
Esta é a essência do processo de bloqueio, agora é só instanciar um objeto da classe trava_Sistema na janela principal, QmainWindow e a partir dela passarmos ponteiros do objeto para os demais cadastros.
fPrincipal.h
fPrincipal.cpp
Observe que o caminho do arquivo config.txt é passado como parâmetro no constructor de fPrincipal, para também seja passado como parâmetro para o constructor da classe
trava_Sistema, para que se possa ler o valor de tempo no arquivo config.txt.
O objeto da classe trava_Sistema é instanciado e o atributo MouseTracking é definido pela função setMouseTracking(true), mas chamada a partir de centralwidget e não fPrincipal, ou this, porque centralwidget é quem captura o evento mousemove.
Nos demais cadastros basta você definir MouseTracking=true já no designer, porque este atributo define a captura do movimento do mouse sem que nenhum botão seja pressionado, que é o que queremos.
Em keyPressEvent e mouseMoveEvent chamamos a função reinicia_Timer() definida na classe trava_Sistema, o efeito é que basta mover o mouse ou pressionar uma tecla para que o timer seja zerado e a contagem comece novamente, evitando que a tela de login seja chamada.
Em on_action_Usuarios_triggered(), que ira chamar um cadastro vazio, que servira apenas para demonstrarmos o funcionamento, é passado o ponteiro de trava_Sis para o cadastro.
Teste o processo na janela principal, configure um valor de tempo baixo no config.txt, por exemplo 10000, o tempo é em milisegundos, portanto 10000 é dez segundos, deixe o sistema parado, sem mexer no mouse e no teclado e observe após dez segundos a tela de login aparecer.
Vá ao designer e crie um simples Qwidget, de o tamanho que quiser e defina o nome como fCadClientes_Parent e ,importante, marque, no designer,a propriedade mouseTracking. Você nem precisa do designer para uma tela tão simples, se quiser crie diretamente dentro do codigo do aplicativo, se assim fizer, defina no constructor do Qwidget
this->setMouseTracking(true);
fCadClientes.h
No header de fCadClientes declaramos um ponteiro para um objeto da classe trava_Sistema.
fCadClientes.cpp
No constructor de fCadClientes é passado o ponteiro para o objeto da classe trava_Sistema que foi instanciado na janela principal, o ponteiro declarado no header de fCadClientes recebe o endereço do objeto definido na janela principal para que possamos ter acesso as funções da classe trava_Sistema: trava_Sis=tr_Sis;
Depois os eventos mouseMoveEvent e keyPressEvent iguais a janela principal.
Observe que neste “cadastro” temos acesso ao objeto instanciado na janela principal, não instanciamos um novo objeto no constructor com new, senão teríamos dois objetos da classe trava sistema instanciados, a cada cadastro aberto teríamos de parar o timer da janela principal, instanciar um novo objeto no cadastro, quando fechar o cadastro, destrui-lo e re-iniciar o timer na janela principal.
Assim como definimos fica mais pratico.
Ao fim de dois tutoriais, este e o anterior sobre criptografia, vimos como criar senhas seguras, definir níveis de acesso dentro do sistema e bloquea-lo em caso de inatividade de mouse ou teclado.
Abaixo, cadastro de clientes com a tela de login.(Clique na imagem para ampliar)
>
Obs: Baixe aqui os fontes do aplicativo.
Tutorial anterior: Gerando senhas criptografadas em um aplicativo Qt com QCA
Usaremos como base o aplicativo desenvolvido no tutorial anterior:
http://www.sistemasparalinux.com.br/tutorial_QCA.html
Os fontes podem ser obtidos aqui:
http://www.sistemasparalinux.com.br/fontes_sistema_qca.txt
Vamos criar uma classe herdada de QObject que ira utilizar como base um objeto QTimer e os eventos mouseMoveEvent e keyPressEvent.
Também vamos criar um novo “cadastro”, na verdade um form sem nada, apenas para vermos o efeito das rotinas que iremos desenvolver para travar o sistema.
Vamos começar definindo uma classe herdada de Qobject, esta classe contera as definições das funções que irão bloquear o sistema.
trava_Sistema.h
/***************************************************************************
* Copyright (C) 2009 by Rodolfo Ribeiro Machado *
* rrmdeveloper@ig.com.br *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef TRAVA_SISTEMA_H
#define TRAVA_SISTEMA_H
#include <QObject>
#include "fDesbloqueia_Sistema.h"
class QTimer;
class trava_Sistema:public QObject
{
Q_OBJECT
public:
trava_Sistema(QWidget *parent = 0,QString caminho="");
~trava_Sistema();
public slots:
void reinicia_Timer();
private:
QTimer* timer;
int tempo;
private slots:
void chama_Login();
protected:
class fDesbloqueia_Sistema* fDestrava_Sis;
};
#endif
trava_Sistema.cpp
/***************************************************************************
* Copyright (C) 2009 by Rodolfo Ribeiro Machado *
* rrmdeveloper@ig.com.br *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "trava_Sistema.h"
#include <QTimer>
#include "fDesbloqueia_Sistema.h"
#include <QSettings>
trava_Sistema::trava_Sistema(QWidget *parent,QString caminho)
{
QSettings settings(caminho,QSettings::IniFormat);
tempo=settings.value("timer/tempo").toInt();//Lê no arquivo config.txt o valor de tempo para bloquear o sistema.
timer=new QTimer;//Instacia o objeto QTimer e o inicia com o tempo de parada lido no arquivo config.txt.
timer->start(tempo);
connect(timer,SIGNAL(timeout()),this,SLOT(chama_Login()));//Conecta a parada do timer com a função que vai chamar a tela de login.
}
trava_Sistema::~trava_Sistema()
{
delete timer;
}
void trava_Sistema::reinicia_Timer()
{
timer->stop();//Para o timer e o re-inicia.
timer->start(tempo);
}
void trava_Sistema::chama_Login()
{
timer->stop();//Ao chamar a tela de login, para de correr o tempo.
fDestrava_Sis=new fDesbloqueia_Sistema(this);//Instancia e abre a tela de login.
connect(fDestrava_Sis,SIGNAL(destroyed()),this,SLOT(reinicia_Timer()));//Quando a tela de login se fecha, o tempo começa a correr de novo.
fDestrava_Sis->show();
}
O constructor da classe lê no arquivo config.txt o parâmetro de tempo para o QTimer.
Logo após o objeto QTimer é instanciado com o parâmetro de tempo lido no arquivo, depois conecta-se o signal timeout() do QTimer com a função que ira chamar a tela de login.
Depois temos a definição do SLOT publico reinicia_Timer(), ele foi definido como public para que possa ser chamado a partir de outros widgets onde um objeto da classe trava_Sistema for instanciado.
Por ultimo a definição da função chama_Login(), que ira chamar a tela de login após decorrido o tempo do timer, ela para o timer, instancia a tela de login, se o usuário logar corretamente, a tela de login é destruida e o QTimer re-iniciado.
A lógica da classe trava_Sistema é muito simples, instancia-se um objeto dela no constructor do centralwidget do aplicativo, no nosso caso um objeto da classe fPrincipal, depois conecta-se os eventos keyPressEvent() e mouseMoveEvent() a função publica reinicia_Timer() do objeto da classe trava_Sistema, então sempre que o mouse é movido ou o teclado utilizado, o QTimer é re-iniciado evitando-se que o SIGNAL timeout() seja enviado.
Caso o sistema permaneça parado, seja pela ausência do usuário ou outra razão, o QTimer corre até o fim, até atingir o limite de tempo que foi fornecido a ele como parâmetro, ai a tela de login é instanciada é exibida, como ela é um formulário modal, sua propriedade windowModality esta definida como applicationModal, ela “seqüestra” a janela, não podendo ser fechada e mesmo que seja minimizada, a janela por traz permanece inacessível, impedindo assim o acesso de pessoas não autorizadas ao sistema, quando é feito o login, o sistema é liberado e o QTimer começa a correr de novo.
Você deve escolher um valor de tempo adequado, prevendo a média de tempo que um eventual usuário pode permanecer ausenta, isto no caso de ele esquecer o sistema aberto, o ideal é que se encerre o aplicativo, mas no caso de um esquecimento estabeleça um tempo, que não deve ser muito pequeno para não causar o incomodo de toda hora a tela de login aparecer, mas que também não pode ser muito longo, permitindo que alguem não autorizado acesse o sistema. O valor de tempo deve ser colocado no arquivo config.txt, também pode ser colocado em um campo de uma tabela no banco de dados ou ficar fixo dentro do sistema, você deve ponderar a estratégia mais segura.
Config.txt
[banco]
database = QPSQL
hostname = localhost
databasename = teste_senha
[timer]
tempo =10000
A tela de desbloqueio herda de fLogin_Parent, que também é a classe mãe da tela de login que aparece quando se inicia o sistema, criei duas classe distintas porque no inicio quero criar o efeito da tela de login sobreposta a janela principal, se a tela de login for fechada sem digitar a senha, o sistema é finalizado, no inicio a tela de login é instanciada por main.cpp e deve ser destruída por ele, se não for digitada a senha, main.cpp deve ter algum meio de saber, criei um ponteiro que retorna esta informação a main.cpp, por isso a tela de login inicial não pode ter em seu constructor o atributo de auto-destruição: this->setAttribute(Qt::WA_DeleteOnClose,true), senão o ponteiro é destruido.
De posse do valor que a tela de login retorna no ponteiro, main.cpp sabe se foi digitada a senha ou não, se não a janela principal também é fechada.
Já na tela que ira aparecer no caso de inatividade do mouse ou teclado, não é necessário o retorno de nenhuma informação, porque ela não pode ser fechada sem a senha correta, o evento closeEvent do widget é re-implementado para testar se a senha foi digitada corretamente, se não foi a janela simplesmente não fecha (event->ignore()). Por isso é necessario o atributo (Qt::WA_DeleteOnClose,true) para auto-destruir o objeto.
fDesbloqueia_Sistema.h
/***************************************************************************
* Copyright (C) 2009 by Rodolfo Ribeiro Machado *
* rodolfo@Programador *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef FDESBLOQUEIA_SISTEMA_H
#define FDESBLOQUEIA_SISTEMA_H
#include "ui_fLogin_Parent.h"
class QSqlQuery;
class fDesbloqueia_Sistema:public QDialog,private Ui::fLogin_Parent
{
Q_OBJECT
public:
fDesbloqueia_Sistema(QObject *parent=0);
~fDesbloqueia_Sistema();
private:
void closeEvent ( QCloseEvent * event );
bool senha_Correta;
QSqlQuery* query_Login;
void keyPressEvent(QKeyEvent* e);
private slots:
void botao_OK_Click();
protected:
class pesq_Senha* testa_Senha;
};
#endif
fDesbloqueia_Sistema.cpp
/***************************************************************************
* Copyright (C) 2009 by Rodolfo Ribeiro Machado *
* rodolfo@Programador *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "fDesbloqueia_Sistema.h"
#include <QCloseEvent>
#include <QSqlQuery>
#include <QMessageBox>
#include <QDesktopWidget>
#include "pesq_Senha.h"
fDesbloqueia_Sistema::fDesbloqueia_Sistema(QObject *parent)
{
setupUi(this);
this->setAttribute(Qt::WA_DeleteOnClose,true);
senha_Correta=false;
connect(botao_OK,SIGNAL(clicked()),this,SLOT(botao_OK_Click()));
this->setFixedSize (this->size());//Para que não se possa redimensionar a janela
QRect rect = QApplication::desktop()->availableGeometry(this);//para centralizar na tela.
this->move(rect.center() - this->rect().center());
edit_Usuario->setFocus();
query_Login=new QSqlQuery;
testa_Senha=new pesq_Senha;
}
fDesbloqueia_Sistema::~fDesbloqueia_Sistema()
{
delete query_Login;
delete testa_Senha;
}
void fDesbloqueia_Sistema:: botao_OK_Click()
{
QString senha=edit_Senha->text();
QByteArray senha_Hash;
//Abre a tabela de usuários, o parâmetro da consulta é o nome digitado, por isso na tabela a um índice que não permite usuários duplicados.
query_Login->prepare(" select "
" a.id_usuarios,"
" a.nome,"
" a.senha,"
" a.nivel,"
" a.tipo_senha, "
" b.codigo,"
" b.chave, "
" b.vetor, "
" b.tipo_hash "
" from "
" usuarios a,"
" codigos b "
" where "
" a.id_usuarios=b.id_codigos and "
" a.nome=:nom");
query_Login->bindValue(":nom",edit_Usuario->text());
query_Login->exec();
query_Login->next();
if (query_Login->size()>0)
{
if (query_Login->value(4).toInt()==0)//Testa se a senha é hash ou criptografada.
{
//hash
senha=senha.append(query_Login->value(5).toString());//Recupera a string aleatória gerada no momento da gravação da senha, e concatena com a senha digitada.
switch (query_Login->value(8).toInt())//Testa se o padrão do hash e md5 ou sha1.
{
case 0:
{
senha_Hash=testa_Senha->gera_hash_Senha(senha,0);//Gera o hash da senha digitada
break;
}
case 1:
{
senha_Hash=testa_Senha->gera_hash_Senha(senha,1);
break;
}
}
if (senha_Hash==query_Login->value(2).toByteArray())//Compara o hash da senha digitada com a senha gravada
{
senha_Correta=true;
this->close();
}
else
{
edit_Senha->clear();
edit_Senha->setFocus();
QMessageBox::information(0,"Acesso ao Sistema","Senha incorreta!");
}
}
else
if (query_Login->value(4).toInt()==1)//Senha criptografada
{
if (senha==testa_Senha->descriptografa(query_Login->value(2).toByteArray(),query_Login->value(6).toByteArray(),query_Login->value(7).toByteArray()))//Descriptografa a senha gravada e compara com a digitada.A rotina usa como parâmetros a senha digitada, a chave o vetor gerados e gravados no banco.
{
senha_Correta=true;
this->close();
}
else
{
edit_Senha->clear();
edit_Senha->setFocus();
QMessageBox::information(0,"Acesso ao Sistema","Senha incorreta!");
}
}
else
QMessageBox::information(0,"Acesso ao Sistema","Tipo de senha desconhecido!");
}
else
{
edit_Usuario->setFocus();
QMessageBox::information(0,"Acesso ao Sistema","Usúario não existe no banco de dados!");
}
}
void fDesbloqueia_Sistema::keyPressEvent(QKeyEvent* e)
{
if ( e->key() == Qt::Key_Enter || e->key() == Qt::Key_Return )//Tabula com enter.
QApplication::focusWidget()->nextInFocusChain()->setFocus();
}
void fDesbloqueia_Sistema::closeEvent( QCloseEvent * event )
{
if (senha_Correta)//Não deixa fechar se a senha é incorreta.
event->accept();
else
event->ignore();
}
A tela de desbloqueio inicia atribuindo o valor false a uma variável booleana que ira controlar se sera possivel ou não fechar a janela.
Depois instancia-se uma QsqlQuery para consulta ao banco e um objeto da classe pesq_Senha para as rotinas de criptografia QCA.
Na função botao_OK_Click() é exatamente igual a tela de login inicial do sistema, que esta toda comentada no meu tutorial anterior:
http://www.sistemasparalinux.com.br/tutorial_QCA.html
No evento closeEvent testa-se a variavel senha_Correta que começou com false no constructor e na passagem pela função botao_OK_Click() tem seu valor definido de acordo com login correto ou não.
Se a variável for false, o evento é ignorado e a janela não fecha, mantendo o sistema bloqueado.
Esta é a essência do processo de bloqueio, agora é só instanciar um objeto da classe trava_Sistema na janela principal, QmainWindow e a partir dela passarmos ponteiros do objeto para os demais cadastros.
fPrincipal.h
/***************************************************************************
* Copyright (C) 2009 by Rodolfo Ribeiro Machado *
* rodolfo@Programador *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef FPRINCIPAL_H
#define FPRINCIPAL_H
#include "ui_fPrincipal_Parent.h"
class fPrincipal:public QMainWindow,private Ui::fPrincipal_Parent
{
Q_OBJECT
public:
fPrincipal(QString caminho="");
~fPrincipal();
void pega_Nivel(int pegNivel);//Declara a função que pega o nivel de acesso.
protected:
class trava_Sistema* trava_Sis;
class fCadClientes* fCadCli;
class fCadUsuarios* fCadUs;//Declara o cadastro de usuários.
class ScribbleArea *scribbleArea;
private slots:
void on_actionClientes_triggered();
void on_action_Usuarios_triggered();//Slot que ira instanciar o objeto da classe fCadUsuarios.
private:
void mouseMoveEvent(QMouseEvent * event);
void keyPressEvent(QKeyEvent* e);
int nivel;
};
#endif
fPrincipal.cpp
/***************************************************************************
* Copyright (C) 2009 by Rodolfo Ribeiro Machado *
* rodolfo@Programador *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "fPrincipal.h"
#include <QDesktopWidget>
#include "trava_Sistema.h"
#include "fCadClientes.h"
#include "fCadUsuarios.h"
fPrincipal::fPrincipal(QString caminho)
{
setupUi(this);
this->setAttribute(Qt::WA_DeleteOnClose,true);//para auto destruir o objeto e liberar a memoria.
QRect rect = QApplication::desktop()->availableGeometry(this);//para centralizar na tela.
this->move(rect.center() - this->rect().center());
this->setFixedSize (this->size());//Para que não se possa redimensionar a janela
trava_Sis=new trava_Sistema(this,caminho);//Instancia um objeto da classe trava_Sistema, que tem os métodos para bloquear o sistema
centralwidget->setMouseTracking(true);//Você deve colocar esta linha, pois no ui_fPrincipal_Parent.h, ele define centralwidget = new QWidget(fPrincipal_Parent); centralwidget->setObjectName(QString::fromUtf8("centralwidget")); Então quem responde por capturar corretamente o evento do mouse é centralwidget.
}
fPrincipal::~fPrincipal()
{
delete trava_Sis;
}
void fPrincipal::keyPressEvent(QKeyEvent* e)
{
trava_Sis->reinicia_Timer();//Ao usar o teclado, zera o timer
}
void fPrincipal::mouseMoveEvent ( QMouseEvent * event )
{
trava_Sis->reinicia_Timer();//Ao mover o mouse, zera o timer
}
void fPrincipal::on_actionClientes_triggered()
{
fCadCli=new fCadClientes(this,trava_Sis);//Passa o objeto trava_Sis como parâmetro para o objeto instanciado, no caso um cadastro.
fCadCli->show();
}
void fPrincipal::on_action_Usuarios_triggered()
{
fCadUs=new fCadUsuarios(this,nivel);//Instancia o cadastro de usuários.
fCadUs->show();
}
void fPrincipal::pega_Nivel(int pegNivel)
{
nivel=pegNivel;//Acerta a variavel nivel com o valor de pegNivel que vem do main.cpp
}
Em fPrincipal.h, o header da janela principal do sistema, você declara um objeto da classe trava_Sistema:
protected:
class trava_Sistema* trava_Sis;
No constructor, em fPrincipal.cpp você instancia o objeto:
fPrincipal::fPrincipal(QString caminho)
{
setupUi(this);
this->setAttribute(Qt::WA_DeleteOnClose,true);//para auto destruir o objeto e liberar a memoria.
QRect rect = QApplication::desktop()->availableGeometry(this);//para centralizar na tela.
this->move(rect.center() - this->rect().center());
this->setFixedSize (this->size());//Para que não se possa redimensionar a janela
trava_Sis=new trava_Sistema(this,caminho);//Instancia um objeto da classe trava_Sistema, que tem os métodos para bloquear o sistema
centralwidget->setMouseTracking(true);//Você deve colocar esta linha, pois no ui_fPrincipal_Parent.h, ele define centralwidget = new QWidget(fPrincipal_Parent); centralwidget->setObjectName(QString::fromUtf8("centralwidget")); Então quem responde por capturar corretamente o evento do mouse é centralwidget.
}
Observe que o caminho do arquivo config.txt é passado como parâmetro no constructor de fPrincipal, para também seja passado como parâmetro para o constructor da classe
trava_Sistema, para que se possa ler o valor de tempo no arquivo config.txt.
O objeto da classe trava_Sistema é instanciado e o atributo MouseTracking é definido pela função setMouseTracking(true), mas chamada a partir de centralwidget e não fPrincipal, ou this, porque centralwidget é quem captura o evento mousemove.
Nos demais cadastros basta você definir MouseTracking=true já no designer, porque este atributo define a captura do movimento do mouse sem que nenhum botão seja pressionado, que é o que queremos.
void fPrincipal::keyPressEvent(QKeyEvent* e)
{
trava_Sis->reinicia_Timer();//Ao usar o teclado, zera o timer
}
void fPrincipal::mouseMoveEvent ( QMouseEvent * event )
{
trava_Sis->reinicia_Timer();//Ao mover o mouse, zera o timer
}
void fPrincipal::on_actionClientes_triggered()
{
fCadCli=new fCadClientes(this,trava_Sis);//Passa o objeto trava_Sis como parâmetro para o objeto instanciado, no caso um cadastro.
fCadCli->show();
}
Em keyPressEvent e mouseMoveEvent chamamos a função reinicia_Timer() definida na classe trava_Sistema, o efeito é que basta mover o mouse ou pressionar uma tecla para que o timer seja zerado e a contagem comece novamente, evitando que a tela de login seja chamada.
Em on_action_Usuarios_triggered(), que ira chamar um cadastro vazio, que servira apenas para demonstrarmos o funcionamento, é passado o ponteiro de trava_Sis para o cadastro.
Teste o processo na janela principal, configure um valor de tempo baixo no config.txt, por exemplo 10000, o tempo é em milisegundos, portanto 10000 é dez segundos, deixe o sistema parado, sem mexer no mouse e no teclado e observe após dez segundos a tela de login aparecer.
Vá ao designer e crie um simples Qwidget, de o tamanho que quiser e defina o nome como fCadClientes_Parent e ,importante, marque, no designer,a propriedade mouseTracking. Você nem precisa do designer para uma tela tão simples, se quiser crie diretamente dentro do codigo do aplicativo, se assim fizer, defina no constructor do Qwidget
this->setMouseTracking(true);
fCadClientes.h
/***************************************************************************
* Copyright (C) 2009 by Rodolfo Ribeiro Machado *
* rodolfo@Programador *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef FCADCLIENTES_H
#define FCADCLIENTES_H
#include "ui_fCadClientes_Parent.h"
class trava_Sistema;
class fCadClientes:public QWidget,private Ui::fCadClientes_Parent
{
Q_OBJECT
public:
fCadClientes(QWidget* parent=0,trava_Sistema* tr_Sis=0);
~fCadClientes();
protected:
class trava_Sistema* trava_Sis;
private:
void mouseMoveEvent(QMouseEvent * event);
void keyPressEvent(QKeyEvent* e);
};
#endif
No header de fCadClientes declaramos um ponteiro para um objeto da classe trava_Sistema.
fCadClientes.cpp
/***************************************************************************
* Copyright (C) 2009 by Rodolfo Ribeiro Machado *
* rodolfo@Programador *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "fCadClientes.h"
#include <QDesktopWidget>
#include "trava_Sistema.h"
fCadClientes::fCadClientes(QWidget* parent,trava_Sistema* tr_Sis)
{
setupUi(this);
this->setAttribute(Qt::WA_DeleteOnClose,true);//para auto destruir o objeto e liberar a memoria.
QRect rect = QApplication::desktop()->availableGeometry(this);//para centralizar na tela.
this->move(rect.center() - this->rect().center());
this->setFixedSize (this->size());//Para que não se possa redimensionar a janela
trava_Sis=tr_Sis;//Passa o endereço do objeto da classe trava_Sistema instanciado na tela principal para a variavel tr_Sis.
}
fCadClientes::~fCadClientes()
{
}
void fCadClientes::mouseMoveEvent(QMouseEvent * event)
{
trava_Sis->reinicia_Timer();//reseta o objeto QTimer e o inicia de novo, assim que o mouse é movimentado.
}
void fCadClientes::keyPressEvent(QKeyEvent* e)
{
trava_Sis->reinicia_Timer();//reseta o objeto QTimer e o inicia de novo, assim que o teclado é usado.
}
No constructor de fCadClientes é passado o ponteiro para o objeto da classe trava_Sistema que foi instanciado na janela principal, o ponteiro declarado no header de fCadClientes recebe o endereço do objeto definido na janela principal para que possamos ter acesso as funções da classe trava_Sistema: trava_Sis=tr_Sis;
Depois os eventos mouseMoveEvent e keyPressEvent iguais a janela principal.
Observe que neste “cadastro” temos acesso ao objeto instanciado na janela principal, não instanciamos um novo objeto no constructor com new, senão teríamos dois objetos da classe trava sistema instanciados, a cada cadastro aberto teríamos de parar o timer da janela principal, instanciar um novo objeto no cadastro, quando fechar o cadastro, destrui-lo e re-iniciar o timer na janela principal.
Assim como definimos fica mais pratico.
Ao fim de dois tutoriais, este e o anterior sobre criptografia, vimos como criar senhas seguras, definir níveis de acesso dentro do sistema e bloquea-lo em caso de inatividade de mouse ou teclado.
Abaixo, cadastro de clientes com a tela de login.(Clique na imagem para ampliar)
>
Obs: Baixe aqui os fontes do aplicativo.
Tutorial anterior: Gerando senhas criptografadas em um aplicativo Qt com QCA