Mudanças entre as edições de "Projeto de Programação 1 - Programa Controle de Acesso"

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
(Esta página contém um modelo básico para o desenvolvimento do projeto final de Programação 1. Além disso tem algumas explicações de código em GTK e linguagem C assim como dicas de material de apoio.)
 
 
(25 revisões intermediárias por 2 usuários não estão sendo mostradas)
Linha 7: Linha 7:
 
* Armazenamento da base de dados em arquivo;
 
* Armazenamento da base de dados em arquivo;
 
* Prever possibilidade de vários administradores;
 
* Prever possibilidade de vários administradores;
 +
 +
 +
== Implementações básicas para a Interface GUI ==
 +
==== Criando e configurando a janela do Administrador ====
 +
 +
Aqui pode-se ver as funções básicas da interface gráfica do administrador: criação de uma janela centralizada de tamanho 800x600, própria para a interface, entre outros.
 +
 +
<syntaxhighlight lang=c>
 +
/** Funções para se iniciar e configurar a janela administrador do Controle de Acesso de usuário **/
 +
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 +
gtk_window_set_title(GTK_WINDOW(window), "Controle de Acesso de Usuário - Administrador");
 +
gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
 +
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 +
gtk_container_set_border_width(GTK_CONTAINER(window), 5);
 +
</syntaxhighlight>
 +
 +
==== Criando frames para divisão de espaços para a janela ====
 +
 +
Através do GTK é preciso criar frames para utilizar da forma mais organizada a janela do programa. Assim pelo exemplo abaixo foi criado três frames: (1) Bem Vindo, (2) Opções de Gerenciamento ao administrador e (3) Log de Acesso.
 +
 +
<syntaxhighlight lang=c>
 +
  /** Funções para dividir a janela em dois frames: o primeiro (da esquerda) será um campo fixo e o segundo(da direita) conterá as atividades do  administrador **/
 +
table1 = gtk_table_new(2, 2, TRUE);
 +
gtk_table_set_row_spacings(GTK_TABLE(table1), 10);
 +
gtk_table_set_col_spacings(GTK_TABLE(table1), 10);
 +
gtk_container_add(GTK_CONTAINER(window), table1);
 +
 +
frame1 = gtk_frame_new("Bem Vindo");
 +
gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_IN);
 +
frame2 = gtk_frame_new("Opções de Gerenciamento");
 +
gtk_frame_set_shadow_type(GTK_FRAME(frame2), GTK_SHADOW_IN);
 +
frame3 = gtk_frame_new("Log de acesso");
 +
gtk_frame_set_shadow_type(GTK_FRAME(frame3), GTK_SHADOW_IN); 
 +
 +
gtk_table_attach_defaults(GTK_TABLE(table1), frame1, 0, 1, 0, 1);
 +
gtk_table_attach_defaults(GTK_TABLE(table1), frame2, 1, 2, 0, 2);
 +
gtk_table_attach_defaults(GTK_TABLE(table1), frame3, 0, 1, 1, 2);
 +
</syntaxhighlight>
 +
 +
==== Botão HOME e mensagen de Boas Vindas ====
 +
 +
No exemplo abaixo observa-se a implementação de um botão HOME com a função de voltar sempre à página principal quando clicado. Além disso tem-se as funções relacionadas à criação de uma caixa (box) para inserir os botões ordenados das atividades do Admin. Também há uma aplicação básica como mostrar uma mensagem de Boas Vindas.
 +
 +
<syntaxhighlight lang=c>
 +
/** Caixa que conterá itens do menu esquerdo - campo fixo **/
 +
/** Funções para criar o botão HOME **/
 +
/** Mensagem de boas vindas ao usuário **/
 +
vbox2 = gtk_vbox_new(FALSE, 10);
 +
hbox2 = gtk_hbox_new(FALSE, 10);
 +
halign2 = gtk_alignment_new (0,1,0,0);
 +
 +
botaoHome = gtk_button_new_with_label ("Home");
 +
gtk_widget_set_size_request(botaoHome, 70, 35);
 +
boasvindas = gtk_label_new ("Bom Dia Administrador!");
 +
 +
gtk_box_pack_start(GTK_BOX (hbox2), botaoHome, FALSE, TRUE, 10);
 +
gtk_box_pack_start(GTK_BOX (hbox2), boasvindas, FALSE, TRUE, 10);
 +
 +
gtk_container_add (GTK_CONTAINER (halign2), hbox2);
 +
gtk_box_pack_start(GTK_BOX (vbox2), halign2, FALSE, FALSE, 0);
 +
 +
gtk_container_add(GTK_CONTAINER(frame1), vbox2);
 +
 +
/** Função do botão HOME **/
 +
g_signal_connect(G_OBJECT(botaoHome), "clicked", G_CALLBACK(gtk_widget_show_all), NULL);
 +
</syntaxhighlight>
 +
 +
==== Funções para fechar a janela e mostrar todos os seus itens ====
 +
<syntaxhighlight lang=c>
 +
g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), G_OBJECT(window));
 +
 +
/** Função para mostrar todos os itens da janela **/
 +
gtk_widget_show_all(window);
 +
</syntaxhighlight>
  
  
 
== Sistema de controle de acesso ==
 
== Sistema de controle de acesso ==
 +
 +
==== Configuração da janela de Controle de Acesso ====
 +
 +
No campo abaixo apresentamos a criação de uma tabela que contém 2 linhas e 2 colunas. No lado esquerdo temos a indicação do Usuário e da Senha e do lado direito temos os campos de preenchimento para os dados de entrada.
 +
 +
<syntaxhighlight lang=c>
 +
/** Configurações da estrutura vertical principal da janela **/
 +
 +
vbox = gtk_vbox_new(FALSE, 10);
 +
gtk_container_add(GTK_CONTAINER(janela), vbox);
 +
labelInicio = gtk_label_new ("Entre com seu nome de usuário/administrador e senha para fazer login:");
 +
 +
halignInicio = gtk_alignment_new(0,1,0,0);
 +
gtk_container_add(GTK_CONTAINER(halignInicio), labelInicio);
 +
gtk_box_pack_start(GTK_BOX(vbox), halignInicio, FALSE, FALSE, 10);
 +
 +
/** Configurações da tabela de Login **/
 +
tabLogin = gtk_table_new (3, 3, FALSE);
 +
gtk_box_pack_start (GTK_BOX(vbox), tabLogin, FALSE, FALSE, 10);
 +
 +
labelUsuario = gtk_label_new ("Usuário:");
 +
gtk_table_attach(GTK_TABLE(tabLogin), labelUsuario, 0, 1, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 +
labelSenha = gtk_label_new ("Senha:");
 +
gtk_table_attach(GTK_TABLE(tabLogin), labelSenha, 0, 1, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 +
 +
/**Campo para entrada de nome do usuário/administrador**/
 +
    entryUser = gtk_entry_new ();
 +
gtk_table_attach(GTK_TABLE(tabLogin), entryUser, 1, 2, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 +
/**Campo para entrada de senha do usuário/administrador**/
 +
entrySenha = gtk_entry_new ();
 +
gtk_entry_set_visibility(GTK_ENTRY (entrySenha), FALSE);
 +
gtk_table_attach(GTK_TABLE(tabLogin), entrySenha, 1, 2, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 +
/**Botão "OK" para confirmar login**/
 +
buttonOK = gtk_button_new_with_label ("OK");
 +
gtk_widget_set_size_request(buttonOK, 35, 25);
 +
gtk_table_attach(GTK_TABLE(tabLogin), buttonOK, 2, 3, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 +
 +
 +
gtk_widget_show_all(janela);
 +
 +
g_signal_connect(G_OBJECT(buttonOK), "clicked", G_CALLBACK(buttonOK_clicked), NULL);
 +
</syntaxhighlight>
 +
 +
==== Função de validação de entrada ====
 +
 +
Funções básicas para o Controle de Acesso do usuário como validação dos dados de entrada.
 +
 +
<syntaxhighlight lang=c>
 +
/** Função que valida um usuário e abre a porta **/
 +
void tratar_usuario(char *userID, char *senha)
 +
{
 +
int userEncontrado=1;
 +
int i=0;
 +
 +
for (i=0;i<TAB_USER && userEncontrado; i++) {
 +
if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 +
userEncontrado=0;
 +
}
 +
 +
/* Se usuário encontrado abre a porta */
 +
if (userEncontrado==0) {
 +
i--; /* o indice do sujeito é i-1 */
 +
if (TabelaUsuarios[i].ContUser>=3) {
 +
printf("\nUsuário Bloqueado! Contate o administrador para desbloquear o usuário.\n");
 +
}else {
 +
if(TabelaUsuarios[i].ContUser<3){
 +
 +
if(strcmp(senha,TabelaUsuarios[i].Senha)==0) {
 +
TabelaUsuarios[i].ContUser=0;
 +
printf("\nAbrir porta!!!");
 +
printf("\n%s\n%s %s!\n", MsgPadrao, TabelaUsuarios[i].MsgUser, userID);
 +
registrar_login(userID);
 +
}else {/*Bloquear usuário se a senha dada é errada mais de três vezes*/
 +
zerar();
 +
TabelaUsuarios[i].ContUser++;
 +
if(TabelaUsuarios[i].ContUser<3)
 +
printf("Senha Inválida. Tente novamente:\n");
 +
else
 +
printf("Senha Inválida!\n");
 +
}
 +
}
 +
if(TabelaUsuarios[i].ContUser>=3)
 +
printf("\nUsuário Bloqueado!!!\n");
 +
}
 +
}else
 +
printf("\nUsuário requerido não cadastrado.\n");
 +
}
 +
</syntaxhighlight>
 +
 +
==== Funções de Login de Usuário ====
 +
 +
Abaixo temos as funções relacionadas ao tratamento de dados de entrada do usuário. Ao extrair os dados dos campos de preenchimento da interface, realiza-se uma conferência com as dados já cadastrados nas listas de usuários. Então só depois é possível o acesso do usuário já cadastrado.
 +
 +
<syntaxhighlight lang=c>
 +
/*Funções de Login de usuário e/ou admin*/
 +
stat ic void buttonOK_clicked(GtkWidget *widget, gpointer data)
 +
{
 +
int i=0, aux=0, adminEncontrado=1, userEncontrado=1;
 +
 +
CCusuario = gtk_entry_get_text(GTK_ENTRY (entryUser));
 +
CCsenha = gtk_entry_get_text(GTK_ENTRY (entrySenha));
 +
 +
userID = g_strdup (CCusuario);
 +
senha = g_strdup (CCsenha);
 +
 +
g_printf("\nUsuário=%s\n", userID);
 +
g_printf("\nSenha=%s\n", senha);
 +
 +
/*Analisar no campo de login se é admin, e chamar função de tratamento para admin*/
 +
for (aux=0;aux<TAB_ADMIN && adminEncontrado; aux++) {
 +
if( strcmp(userID, TabelaAdmin[aux].UserAdmin)==0)
 +
adminEncontrado=0;
 +
}
 +
if (adminEncontrado==0) {
 +
gtk_main_quit();
 +
tratar_admin(userID, senha);
 +
}
 +
 +
/*Analisar no campo de login se é usuário comum, e chamar função de tratamento para usuário*/
 +
for (i=0;i<TAB_USER && userEncontrado; i++) {
 +
if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 +
userEncontrado=0;
 +
}
 +
if (userEncontrado==0) {
 +
gtk_main_quit();
 +
tratar_usuario(userID, senha);
 +
}
 +
gtk_main();
 +
</syntaxhighlight>
 +
 +
==== Função zerar campo de preenchimento ====
 +
 +
Com essa função, apaga-se a senha errada que o próprio usuário fornece. Logo é dada mais uma alternativa para o usuário digitar e fornecer a senha novamente.
 +
 +
<syntaxhighlight lang=c>
 +
/*Função para apagar a senha erroneamente digitada no campo de senha*/
 +
void zerar()
 +
{
 +
gtk_editable_delete_text( GTK_EDITABLE(entrySenha), 0, -1 );
 +
 +
}
 +
</syntaxhighlight>
 +
 +
== Ações do Administrador ==
 +
==== Bloquear Usuário ====
 +
<syntaxhighlight lang=c>
 +
case 1: /*** PARA BLOQUEAR USUÁRIO ***/
 +
printf("\nPara bloquear usuário:\n");
 +
printf("\nEntre com o nome do usuário a ser bloqueado: ");
 +
scanf(" %s", userID);
 +
 +
/* Loop para encontrar o usuário na tabela */
 +
for (aux=0, userEncontrado=1;aux<TAB_USER && userEncontrado;aux++) {
 +
if( strcmp(userID, TabelaUsuarios[aux].UserId)==0)
 +
userEncontrado=0;
 +
}
 +
 +
/* Se o usuário for encontrado será bloqueado */
 +
if (userEncontrado==0) {
 +
aux--;
 +
if (TabelaUsuarios[aux].ContUser>=3) {
 +
printf("\nUsuário encontrado já bloqueado!\n");
 +
} else{
 +
printf("\nBloqueando usuário...\n");
 +
TabelaUsuarios[aux].ContUser = 3;
 +
 +
/* Condição para verificar o sucesso da operação.*/
 +
if(TabelaUsuarios[aux].ContUser>=3)
 +
printf("\nUsuário bloqueado com sucesso!\n");
 +
}
 +
} else
 +
printf("\nUsuário não cadastrado!\n");
 +
break;
 +
</syntaxhighlight>
 +
 +
==== Cadastrar novo Usuário ====
 +
<syntaxhighlight lang=c>
 +
case 2: /*** PARA CADASTRAR NOVO USUÁRIO ***/
 +
printf("\nPara cadastrar novo usuário: ");
 +
 +
/* Loop para encontrar o final da tabela */
 +
for(i=0;TabelaUsuarios[i].UserId[0] && i<TAB_USER;i++)
 +
aux++;
 +
 +
/* Condição para novo cadastro.*/
 +
if (i==TAB_USER)
 +
printf("\nLimite de cadastro de usuários atingido.\n");
 +
else {
 +
 +
printf("\nEntre com um novo nome de Usuário:\n");
 +
scanf(" %s", userID);
 +
 +
/* Loop para encontrar o usuário na tabela */
 +
for (i=0; i<aux && userEncontrado; i++) {
 +
if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 +
userEncontrado=0;
 +
}
 +
/* Se o usuário for encontrado já está cadastrado. */
 +
if (userEncontrado==0)
 +
printf("\nUsuário já cadastrado.Tente novamente com outro usuário.\n");
 +
else {
 +
strcat(TabelaUsuarios[aux].UserId,userID);
 +
 +
printf("\nEntre com uma nova senha para o novo usuário %s:\n", userID);
 +
scanf(" %s", senha);
 +
strcat(TabelaUsuarios[aux].Senha,senha);
 +
 +
strcat(TabelaUsuarios[aux].MsgUser,"Bom Dia");
 +
 +
/* Condição para verificar o sucesso da operação.*/
 +
if(strcmp(userID, TabelaUsuarios[aux].UserId)==0 && strcmp(senha, TabelaUsuarios[aux].Senha)==0)
 +
printf("\nNovo usuário '%s' cadastrado com sucesso!\n", TabelaUsuarios[aux].UserId);
 +
}
 +
}
 +
break;
 +
</syntaxhighlight>
 +
 +
==== Desbloquear um Usuário ====
 +
<syntaxhighlight lang=c>
 +
case 3: /*** PARA DESBLOQUEAR USUÁRIO ***/
 +
printf("\nPara desbloquear usuário:\n");
 +
printf("\nEntre com o nome do usuário a ser desbloqueado: ");
 +
scanf(" %s", userID);
 +
 +
/* Loop para encontrar o usuário na tabela */
 +
for (aux=0;aux<TAB_USER && userEncontrado;aux++) {
 +
if( strcmp(userID, TabelaUsuarios[aux].UserId)==0)
 +
userEncontrado=0;
 +
}
 +
 +
/* Se o usuário for encontrado será desbloqueado */
 +
if (userEncontrado==0) {
 +
aux--;
 +
if (TabelaUsuarios[aux].ContUser>=3) {
 +
printf("\nUsuário encontrado bloqueado! Desbloqueando usuário...");
 +
TabelaUsuarios[aux].ContUser=0;
 +
 +
/* Condição para verificar o sucesso da operação.*/
 +
if(TabelaUsuarios[aux].ContUser<=3)
 +
printf("\nUsuário desbloqueado com sucesso!\n");
 +
} else
 +
printf("\nUsuário encontrado desbloqueado! Tente novamente com outro usuário.\n");
 +
} else
 +
printf("\nUsuário não cadastrado!\n");
 +
break;
 +
</syntaxhighlight>
 +
 +
==== Excluir um Usuário ====
 +
<syntaxhighlight lang=c>
 +
case 4: /*** PARA EXCLUIR UM USUÁRIO ***/
 +
printf("\nDigite o nome de usuário que deseja excluir: ");
 +
scanf(" %s", userID);
 +
 +
/* Loop para encontrar o usuário na tabela.*/
 +
for (i=0;i<TAB_USER && userEncontrado; i++) {
 +
if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 +
userEncontrado=0;
 +
}
 +
/* Se usuário for encontrado será deletado */
 +
if (userEncontrado==0) {
 +
printf("\nExcluindo usuário...\n");
 +
i--;
 +
TabelaUsuarios[i].UserId[0]='\0';
 +
TabelaUsuarios[i].Senha[0]='\0';
 +
TabelaUsuarios[i].ContUser=0;
 +
TabelaUsuarios[i].MsgUser[0]='\0';
 +
 +
/* Condição para verificar o sucesso da operação.*/
 +
if(TabelaUsuarios[i].UserId[0]==0)
 +
printf("\nUsuário excluído com sucesso!\n");
 +
} else
 +
printf("\nUsuário não cadastrado!\n");
 +
 +
break;
 +
</syntaxhighlight>
 +
 +
==== Imprimir Tabela de Usuários ====
 +
<syntaxhighlight lang=c>
 +
case 5: /*** PARA IMPRIMIR TABELA DE USUÁRIOS. ***/
 +
printf("\nListando tabela de usuários cadastrados...\n");
 +
 +
for(aux=0;TabelaUsuarios[aux].UserId[0] && aux<TAB_USER;aux++) {
 +
printf("\n%s",TabelaUsuarios[aux].UserId);
 +
cont++;
 +
}
 +
printf("\n\nNúmero de usuários cadastrados: %d\n", cont);
 +
break;
 +
</syntaxhighlight>
 +
 +
==== Limpar Lista de Usuários ====
 +
<syntaxhighlight lang=c>
 +
case 6: /*** PARA LIMPAR LISTA DE USUÁRIOS ***/
 +
printf("\nLimpando tabela de usuários...\n");
 +
          for(i=0;TabelaUsuarios[i].UserId[0];i++) {
 +
            TabelaUsuarios[i].UserId[0]='\0';
 +
          TabelaUsuarios[i].Senha[0]='\0';
 +
            TabelaUsuarios[i].ContUser=0;
 +
TabelaUsuarios[i].MsgUser[0]='\0';
 +
}
 +
break;
 +
</syntaxhighlight>
 +
 +
==== Modificar mensagem particular do Usuário ====
 +
<syntaxhighlight lang=c>
 +
case 7: /*** PARA MODIFICAR MENSAGEM PARTICULAR DO USUÁRIO. ***/
 +
printf("\nPara modificar mensagem particular do usuário:\n");
 +
printf("\nEntre com o nome de usuário que deseja modificar a mensagem: ");
 +
scanf(" %s", userID);
 +
 +
/* Loop para encontrar o usuário na tabela.*/
 +
for (i=0;i<TAB_USER && userEncontrado; i++) {
 +
if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 +
userEncontrado=0;
 +
}
 +
/* Se usuário for encontrado será modificado a mensagem particular. */
 +
if (userEncontrado==0) {
 +
printf("\nEntre com a nova mensagem: ");
 +
i--;
 +
scanf(" %s", TabelaUsuarios[i].MsgUser);
 +
 +
/* Verificação do sucesso da operação.*/
 +
printf("\nA nova mensagem é '%s'.\n", TabelaUsuarios[i].MsgUser);
 +
printf("\nMensagem particular modificada com sucesso!\n");
 +
}else
 +
printf("\nUsuário não cadastrado!\n");
 +
break;
 +
</syntaxhighlight>
 +
 +
==== Modificar mensagem padrão ====
 +
<syntaxhighlight lang=c>
 +
case 13: /*** PARA MODIFICAR MENSAGEM PADRAO ***/
 +
printf("\nPara modificar mensagem padrão:\n");
 +
printf("\nEntre com a nova mensagem: ");
 +
scanf(" %s", MsgPadrao);
 +
 +
/* Verificação do sucesso da operação.*/
 +
printf("\nA nova mensagem é '%s'.\n", MsgPadrao);
 +
printf("\nMensagem padrão modificada com sucesso!\n");
 +
break;
 +
</syntaxhighlight>
 +
 +
==== Modificar senha do Administrador ====
 +
<syntaxhighlight lang=c>
 +
case 15: /*** PARA MODIFICAR SENHA DO ADMINISTRADOR ***/
 +
printf("\nPara modificar senha do administrador:\n");
 +
printf("\nEntre com a senha atual do admin: ");
 +
scanf(" %s", senha);
 +
 +
for (i=0;i<TAB_ADMIN && userEncontrado; i++) {
 +
if( strcmp(userID, TabelaAdmin[i].UserAdmin)==0)
 +
userEncontrado=0;
 +
}
 +
/* Condição para modificar a atual senha do administrador.*/
 +
if (userEncontrado==0) {
 +
i--;
 +
if (strcmp(senha, TabelaAdmin[i].SenhaAdmin)==0) {
 +
printf("\nEntre com a nova senha: ");
 +
scanf(" %s", senha);
 +
printf("\nConfirme a nova senha: ");
 +
scanf(" %s", TabelaAdmin[i].SenhaAdmin);
 +
 +
/* Condição para verificar o sucesso da operação.*/
 +
if (strcmp(senha, TabelaAdmin[i].SenhaAdmin)==0)
 +
printf("\nSenha do administrador modificada com sucesso!\n");
 +
else
 +
printf("\nFalha ao modificar a senha. Dados incorretos. Tente novamente e verifique a nova senha.\n");
 +
} else
 +
printf("\nDados incorretos. Tente novamente e verifique a senha do administrador fornecida.\n");
 +
}
 +
break;
 +
</syntaxhighlight>
 +
 +
== Interface do Administrador (GUI) ==
 +
 +
==== Chamada de funções para Administrar ====
 +
 +
Abaixo encontra-se um exemplo de chamada de funções do GTK para acessar opções de atividades do Administrador:
 +
<syntaxhighlight lang=c>
 +
  /** Chamadas funções para usuário **/
 +
void BloquearUser_clicked(GtkWidget *widget, gpointer data)
 +
{
 +
administrar(1, userID, senha);
 +
}
 +
 +
/** Chamadas funções para administrador **/
 +
 +
void BloquearAdmin_clicked(GtkWidget *widget, gpointer data)
 +
{
 +
administrar(8, userID, senha);
 +
}
 +
</syntaxhighlight>
 +
 +
==== Tabela contendo os botões de atividades do Administrador ====
 +
 +
Tais botões estarão chamando os tipos de funções mostrados acima e são criados seguindo o exemplo abaixo:
 +
<syntaxhighlight lang=c>
 +
/** Caixa que conterá as atividades do administrador **/
 +
vbox1 = gtk_vbox_new(FALSE, 1);
 +
 
 +
labelopcoes = gtk_label_new("Entre com uma das opções:");
 +
gtk_label_set_justify(GTK_LABEL(labelopcoes), GTK_JUSTIFY_CENTER);
 +
 +
labeluser = gtk_label_new("Para usuário:");
 +
labeladmin = gtk_label_new("Para administrador:");
 +
 +
/** Definição dos textos que representam cada botão de ação **/
 +
BloquearUser = gtk_button_new_with_label("Bloquear usuário");
 +
BloquearAdmin = gtk_button_new_with_label("Bloquear administrador");
 +
 +
/** Criação dos botões para uso nas atividades do admin **/
 +
gtk_box_pack_start(GTK_BOX(vbox1), labelopcoes, 0, TRUE, 0);
 +
gtk_box_pack_start(GTK_BOX(vbox1), labeluser, 0, TRUE, 0);
 +
gtk_box_pack_start(GTK_BOX(vbox1), BloquearUser, 0, TRUE, 0);
 +
gtk_box_pack_start(GTK_BOX(vbox1), CadastrarUser, 0, TRUE, 0);
 +
 +
/* Função do botão "Bloquear usuário"*/
 +
g_signal_connect(G_OBJECT(BloquearUser), "clicked", G_CALLBACK(BloquearUser_clicked), NULL);
 +
 +
/* Função do botão "Bloquear administrador"*/
 +
g_signal_connect(G_OBJECT(BloquearAdmin), "clicked", G_CALLBACK(BloquearAdmin_clicked), NULL);
 +
</syntaxhighlight>
 +
 +
 +
 +
== Log de Acesso ==
 +
 +
==== Salvar Log em arquivo de texto no computador ====
 +
 +
<syntaxhighlight lang=c>
 +
struct TRegistroLog TabelaLog[TAB_LOG];
 +
 +
/*Função para salvar o log de entrada e/ou saída em um arquivo de texto no computador*/
 +
void save()
 +
{
 +
FILE *log;
 +
int i;
 +
register int aux;
 +
 +
log=fopen("LogAcesso.txt", "w");
 +
 +
if (log==NULL) {
 +
printf("\nO arquivo não pode ser aberto.");
 +
return;
 +
}
 +
 +
for(i=0;TabelaLog[i].Usuario[0] && i<TAB_LOG;i++)
 +
fprintf(log, "%s %s %s", TabelaLog[i].Usuario, TabelaLog[i].Entrada, TabelaLog[i].Saida);
 +
fclose(log);
 +
}
 +
</syntaxhighlight>
 +
 +
==== Abrir o arquivo texto de Log ====
 +
 +
A função abaixo indica como salvar as informações de uma estrutura em arquivo de texto.
 +
 +
<syntaxhighlight lang=c>
 +
/*****FUNÇÃO NÃO IMPLEMENTADA, PORÉM PARCIALMENTE PRONTA, PARA ABRIR O ARQUIVO DE LOG PELO ADMINISTRADOR*****/
 +
   
 +
void load ()
 +
{
 +
FILE *log;
 +
register int i;
 +
 +
log=fopen("LogAcesso.txt", "r");
 +
 +
if (log==NULL)
 +
prinf("\nO arquivo não pode ser aberto.");
 +
return;
 +
}
 +
 +
init_list();
 +
for (i=0; i<TAB_LOG; i++)
 +
if (fread(&TabelaLog[i], sizeof (struct TRegistroLog), 1, log)!=1) {
 +
if (feof (log)) break;
 +
printf("\nErro de escrita no arquivo de log.\n");
 +
}
 +
fclose(log);
 +
}
 +
</syntaxhighlight>
 +
 +
==== Função para registrar o login ====
 +
 +
No exemplo abaixo é apresentado os passos para registrar os dados de entrada do usuário no exato momento de entrada do mesmo.
 +
 +
<syntaxhighlight lang=c>
 +
/*Função para guardar a informação de entrada de um usuário numa lista de log que será mostrada ao administrador quando ele estiver logado*/
 +
void registrar_login(char *userID)
 +
{
 +
int i=0, aux=0;
 +
int algoEncontrado=1;
 +
char *chamadaLog;
 +
 +
time_t lt;
 +
lt = time(NULL);
 +
 +
chamadaLog = ctime(&lt);
 +
 +
/* Loop para encontrar se há algo na tabela de log */
 +
for(i=0;TabelaLog[i].Usuario[0] && i<TAB_LOG;i++)
 +
aux++;
 +
 +
/* Adicionando registro de log */
 +
strcat(TabelaLog[aux].Usuario, userID);
 +
strcat(TabelaLog[aux].Entrada, chamadaLog);
 +
 +
/* Condição para verificar o sucesso da operação.*/
 +
if(strcmp(userID, TabelaLog[aux].Usuario)==0 && strcmp(chamadaLog, TabelaLog[aux].Entrada)==0)
 +
printf("\nEntrada do usuário %s em %s\n\n", TabelaLog[aux].Usuario, TabelaLog[aux].Entrada);
 +
 +
save();
 +
}
 +
</syntaxhighlight>
 +
 +
==== Função para registrar o logout ====
 +
 +
Aqui temos o modelo básico de implementação do registro de dados de saída do usuário no exato momento de saída do mesmo.
 +
 +
<syntaxhighlight lang=c>
 +
/*****FUNÇÃO NÃO IMPLEMENTADA, PORÉM PARCIALMENTE PRONTA, PARA GUARDAR A INFORMAÇÃO DE SÁIDA DE UM USUÁRIO NA LISTA DE LOG TAMBÉM MOSTRADA AO  ADMINISTRADOR*****/
 +
 +
 +
 +
void registrar_logout(char *userID)
 +
{
 +
time_t ltout;
 +
 +
TabelaLog.Usuario = userID;
 +
 +
ltout = time(NULL);
 +
TabelaLog.Saida = ctime(&ltout);
 +
 +
}
 +
</syntaxhighlight>
 +
 +
==== Definição dos itens da Lista de Log ====
 +
 +
<syntaxhighlight lang=c>
 +
/***Definição dos itens na lista de log***/
 +
enum
 +
{
 +
    NAME_COLUMN,
 +
  ENTRY_COLUMN,
 +
  OUT_COLUMN,
 +
  N_COLUMNS
 +
};
 +
const gchar *nome, *in, *out;
 +
</syntaxhighlight>
 +
 +
==== Criação da Lista de Log ====
 +
<syntaxhighlight lang=c>
 +
/***Função de criação da lista de log***/
 +
static void
 +
init_list(GtkWidget *list)
 +
{
 +
  GtkListStore *store;/*Tipo de widget para criar uma lista(modelo) inicialmente não visualizada*/
 +
  GtkTreeViewColumn *column;/*Tipo de widget para visualizar a lista já criada */
 +
  GtkCellRenderer *renderer;
 +
 
 +
 
 +
 
 +
/* Criar um novo título na tabela de log "cell_renderer" */
 +
  renderer = gtk_cell_renderer_text_new ();
 +
/* Criar uma coluna, associando o próximo atributo do "cell_renderer" com a primeira coluna do modelode lista */
 +
  column = gtk_tree_view_column_new_with_attributes ("Nome", renderer, "text", NAME_COLUMN, NULL);
 +
 +
  /* Adicionar a coluna criada ao campo de visualização */
 +
  gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
 +
 +
  /* Segunda coluna ...*/
 +
  renderer = gtk_cell_renderer_text_new ();
 +
  column = gtk_tree_view_column_new_with_attributes ("Entrada", renderer, "text", ENTRY_COLUMN, NULL);
 +
  gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
 +
 +
  /* Última Coluna ...*/
 +
  renderer = gtk_cell_renderer_text_new ();
 +
  column = gtk_tree_view_column_new_with_attributes ("Saída", renderer, "text", OUT_COLUMN, NULL);
 +
  gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
 +
 +
 +
  /* Criação do modelo de lista.  Uso do "store model"*/
 +
  store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 +
 +
   
 +
  gtk_tree_view_set_model(GTK_TREE_VIEW(list),
 +
      GTK_TREE_MODEL(store));
 +
 +
    g_object_unref(G_OBJECT (store));
 +
}
 +
</syntaxhighlight>
 +
 +
==== Composição da Lista de Log ====
 +
<syntaxhighlight lang=c>
 +
/***Função de composição da lista de log***/
 +
static void
 +
add_to_list(GtkWidget *list)
 +
{
 +
  GtkListStore *store;
 +
  GtkTreeIter iter;
 +
 +
  nome = TabelaLog[i].Usuario;
 +
  in = TabelaLog[i].Entrada;
 +
  out = TabelaLog[i].Saida;
 +
 
 +
  store = GTK_LIST_STORE(gtk_tree_view_get_model
 +
      (GTK_TREE_VIEW(list)));
 +
 +
  gtk_list_store_insert_after(store, &iter, NULL);
 +
  gtk_list_store_set(store, &iter, NAME_COLUMN, nome, -1);
 +
  gtk_list_store_set(store, &iter, ENTRY_COLUMN, in, -1);
 +
  gtk_list_store_set(store, &iter, OUT_COLUMN, out, -1);
 +
 +
/** Frame 3 com a lista de log - campo fixo **/
 +
  list = gtk_tree_view_new();
 +
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list), TRUE);
 +
 +
  gtk_container_add(GTK_CONTAINER(frame3), list);
 +
 +
  init_list(list);
 +
 +
  for(i=0;TabelaLog[i].Usuario[0] && i<TAB_LOG;i++)
 +
add_to_list(list);
 +
</syntaxhighlight>

Edição atual tal como às 15h37min de 9 de abril de 2013

Proposta de trabalho:

  • Sistema de controle de acesso;
  • Interface GUI para o administrador;
  • Interface usuário GUI simulando o display LCD;
  • Arquivo de log de entrada/saída de usuários com horário e data;
  • Armazenamento da base de dados em arquivo;
  • Prever possibilidade de vários administradores;


Implementações básicas para a Interface GUI

Criando e configurando a janela do Administrador

Aqui pode-se ver as funções básicas da interface gráfica do administrador: criação de uma janela centralizada de tamanho 800x600, própria para a interface, entre outros. 

 /** Funções para se iniciar e configurar a janela administrador do Controle de Acesso de usuário **/
 	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 	gtk_window_set_title(GTK_WINDOW(window), "Controle de Acesso de Usuário - Administrador");
 	gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
 	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 	gtk_container_set_border_width(GTK_CONTAINER(window), 5);

Criando frames para divisão de espaços para a janela

Através do GTK é preciso criar frames para utilizar da forma mais organizada a janela do programa. Assim pelo exemplo abaixo foi criado três frames: (1) Bem Vindo, (2) Opções de Gerenciamento ao administrador e (3) Log de Acesso. 

  /** Funções para dividir a janela em dois frames: o primeiro (da esquerda) será um campo fixo e o segundo(da direita) conterá as atividades do  administrador **/
 	table1 = gtk_table_new(2, 2, TRUE);
 	gtk_table_set_row_spacings(GTK_TABLE(table1), 10);
 	gtk_table_set_col_spacings(GTK_TABLE(table1), 10);
 	gtk_container_add(GTK_CONTAINER(window), table1);
 
 	frame1 = gtk_frame_new("Bem Vindo");
 	gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_IN);
 	frame2 = gtk_frame_new("Opções de Gerenciamento");
 	gtk_frame_set_shadow_type(GTK_FRAME(frame2), GTK_SHADOW_IN);
 	frame3 = gtk_frame_new("Log de acesso");
 	gtk_frame_set_shadow_type(GTK_FRAME(frame3), GTK_SHADOW_IN);  
 
 	gtk_table_attach_defaults(GTK_TABLE(table1), frame1, 0, 1, 0, 1);
 	gtk_table_attach_defaults(GTK_TABLE(table1), frame2, 1, 2, 0, 2);
 	gtk_table_attach_defaults(GTK_TABLE(table1), frame3, 0, 1, 1, 2);

Botão HOME e mensagen de Boas Vindas

No exemplo abaixo observa-se a implementação de um botão HOME com a função de voltar sempre à página principal quando clicado. Além disso tem-se as funções relacionadas à criação de uma caixa (box) para inserir os botões ordenados das atividades do Admin. Também há uma aplicação básica como mostrar uma mensagem de Boas Vindas. 

 /** Caixa que conterá itens do menu esquerdo - campo fixo **/
 /** Funções para criar o botão HOME **/
 /** Mensagem de boas vindas ao usuário **/
 	vbox2 = gtk_vbox_new(FALSE, 10);	
 	hbox2 = gtk_hbox_new(FALSE, 10);
 	halign2 = gtk_alignment_new (0,1,0,0);
 
 	botaoHome = gtk_button_new_with_label ("Home");
 	gtk_widget_set_size_request(botaoHome, 70, 35);
 	boasvindas = gtk_label_new ("Bom Dia Administrador!");
 
 	gtk_box_pack_start(GTK_BOX (hbox2), botaoHome, FALSE, TRUE, 10);
 	gtk_box_pack_start(GTK_BOX (hbox2), boasvindas, FALSE, TRUE, 10);
 
 	gtk_container_add (GTK_CONTAINER (halign2), hbox2);
 	gtk_box_pack_start(GTK_BOX (vbox2), halign2, FALSE, FALSE, 0);
 
 	gtk_container_add(GTK_CONTAINER(frame1), vbox2);
 
 /** Função do botão HOME **/
 	g_signal_connect(G_OBJECT(botaoHome), "clicked", G_CALLBACK(gtk_widget_show_all), NULL);

Funções para fechar a janela e mostrar todos os seus itens

 g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), G_OBJECT(window));
 
 /** Função para mostrar todos os itens da janela **/
 	gtk_widget_show_all(window);


Sistema de controle de acesso

Configuração da janela de Controle de Acesso

No campo abaixo apresentamos a criação de uma tabela que contém 2 linhas e 2 colunas. No lado esquerdo temos a indicação do Usuário e da Senha e do lado direito temos os campos de preenchimento para os dados de entrada. 

 /** Configurações da estrutura vertical principal da janela **/
 
 	vbox = gtk_vbox_new(FALSE, 10);
 	gtk_container_add(GTK_CONTAINER(janela), vbox);
 	labelInicio = gtk_label_new ("Entre com seu nome de usuário/administrador e senha para fazer login:");
 
 	halignInicio = gtk_alignment_new(0,1,0,0);
 	gtk_container_add(GTK_CONTAINER(halignInicio), labelInicio);
 	gtk_box_pack_start(GTK_BOX(vbox), halignInicio, FALSE, FALSE, 10);
 
 /** Configurações da tabela de Login **/
 	tabLogin = gtk_table_new (3, 3, FALSE);
 	gtk_box_pack_start (GTK_BOX(vbox), tabLogin, FALSE, FALSE, 10);
 
 	labelUsuario = gtk_label_new ("Usuário:");
 	gtk_table_attach(GTK_TABLE(tabLogin), labelUsuario, 0, 1, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 	labelSenha = gtk_label_new ("Senha:");
 	gtk_table_attach(GTK_TABLE(tabLogin), labelSenha, 0, 1, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 
 /**Campo para entrada de nome do usuário/administrador**/
     	entryUser = gtk_entry_new ();
 	gtk_table_attach(GTK_TABLE(tabLogin), entryUser, 1, 2, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 /**Campo para entrada de senha do usuário/administrador**/	
 	entrySenha = gtk_entry_new ();
 	gtk_entry_set_visibility(GTK_ENTRY (entrySenha), FALSE);
 	gtk_table_attach(GTK_TABLE(tabLogin), entrySenha, 1, 2, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 /**Botão "OK" para confirmar login**/
 	buttonOK = gtk_button_new_with_label ("OK");
 	gtk_widget_set_size_request(buttonOK, 35, 25);
 	gtk_table_attach(GTK_TABLE(tabLogin), buttonOK, 2, 3, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
 
 
 	gtk_widget_show_all(janela);
 
 	g_signal_connect(G_OBJECT(buttonOK), "clicked", G_CALLBACK(buttonOK_clicked), NULL);

Função de validação de entrada

Funções básicas para o Controle de Acesso do usuário como validação dos dados de entrada. 

 /** Função que valida um usuário e abre a porta **/
 void tratar_usuario(char *userID, char *senha)
 {
 	int userEncontrado=1;
 	int i=0;
 
 	for (i=0;i<TAB_USER && userEncontrado; i++) {
 		if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 			userEncontrado=0;
 	}
 
 /* Se usuário encontrado abre a porta */
 	if (userEncontrado==0) {
 		i--; /* o indice do sujeito é i-1 */
 		if (TabelaUsuarios[i].ContUser>=3) {
 			printf("\nUsuário Bloqueado! Contate o administrador para desbloquear o usuário.\n");
 		}else {	
 			if(TabelaUsuarios[i].ContUser<3){
 				
 				if(strcmp(senha,TabelaUsuarios[i].Senha)==0) {
 					TabelaUsuarios[i].ContUser=0;
 					printf("\nAbrir porta!!!");
 					printf("\n%s\n%s %s!\n", MsgPadrao, TabelaUsuarios[i].MsgUser, userID);
 					registrar_login(userID);
 				}else {/*Bloquear usuário se a senha dada é errada mais de três vezes*/
 					zerar();
 					TabelaUsuarios[i].ContUser++;
 					if(TabelaUsuarios[i].ContUser<3)
 						printf("Senha Inválida. Tente novamente:\n");
 					else
 						printf("Senha Inválida!\n");
 					}
 			}
 			if(TabelaUsuarios[i].ContUser>=3)
 				printf("\nUsuário Bloqueado!!!\n");
 		}		
 	}else
 		printf("\nUsuário requerido não cadastrado.\n");
 }

Funções de Login de Usuário

Abaixo temos as funções relacionadas ao tratamento de dados de entrada do usuário. Ao extrair os dados dos campos de preenchimento da interface, realiza-se uma conferência com as dados já cadastrados nas listas de usuários. Então só depois é possível o acesso do usuário já cadastrado. 

 /*Funções de Login de usuário e/ou admin*/		
stat ic void buttonOK_clicked(GtkWidget *widget, gpointer data)
 {
 	int i=0, aux=0, adminEncontrado=1, userEncontrado=1;
 		
 	CCusuario = gtk_entry_get_text(GTK_ENTRY (entryUser));
 	CCsenha = gtk_entry_get_text(GTK_ENTRY (entrySenha));
 
 	userID = g_strdup (CCusuario);
 	senha = g_strdup (CCsenha);
 
 	g_printf("\nUsuário=%s\n", userID);
 	g_printf("\nSenha=%s\n", senha);
 
 	/*Analisar no campo de login se é admin, e chamar função de tratamento para admin*/
 	for (aux=0;aux<TAB_ADMIN && adminEncontrado; aux++) {
 		if( strcmp(userID, TabelaAdmin[aux].UserAdmin)==0)
 			adminEncontrado=0;
 	}	
 	if (adminEncontrado==0) {
 		gtk_main_quit();
 		tratar_admin(userID, senha);
 	}
 
 	/*Analisar no campo de login se é usuário comum, e chamar função de tratamento para usuário*/
 	for (i=0;i<TAB_USER && userEncontrado; i++) {
 		if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 			userEncontrado=0;
 	}	
 	if (userEncontrado==0) {
 		gtk_main_quit();
 		tratar_usuario(userID, senha);
 	}
 	gtk_main();

Função zerar campo de preenchimento

Com essa função, apaga-se a senha errada que o próprio usuário fornece. Logo é dada mais uma alternativa para o usuário digitar e fornecer a senha novamente. 

 /*Função para apagar a senha erroneamente digitada no campo de senha*/
 void zerar()
 {
 	gtk_editable_delete_text( GTK_EDITABLE(entrySenha), 0, -1 );
 	
 }

Ações do Administrador

Bloquear Usuário

 case 1: /*** PARA BLOQUEAR USUÁRIO ***/
 		printf("\nPara bloquear usuário:\n");
 		 printf("\nEntre com o nome do usuário a ser bloqueado: ");
 		scanf(" %s", userID);
 		
 		/* Loop para encontrar o usuário na tabela */
 		for (aux=0, userEncontrado=1;aux<TAB_USER && userEncontrado;aux++) {
 			if( strcmp(userID, TabelaUsuarios[aux].UserId)==0)
 				userEncontrado=0;
 		}
 		
 		/* Se o usuário for encontrado será bloqueado */
 		if (userEncontrado==0) {
 			aux--;
 			if (TabelaUsuarios[aux].ContUser>=3) {
 				printf("\nUsuário encontrado já bloqueado!\n");
 			} else{
 				printf("\nBloqueando usuário...\n");
 				TabelaUsuarios[aux].ContUser = 3;
 
 				/* Condição para verificar o sucesso da operação.*/
 				if(TabelaUsuarios[aux].ContUser>=3)
 					printf("\nUsuário bloqueado com sucesso!\n");
 				}
 		} else
 			printf("\nUsuário não cadastrado!\n");
 		break;

Cadastrar novo Usuário

 case 2: /*** PARA CADASTRAR NOVO USUÁRIO ***/
 		printf("\nPara cadastrar novo usuário: ");
 		
 		/* Loop para encontrar o final da tabela */
 		for(i=0;TabelaUsuarios[i].UserId[0] && i<TAB_USER;i++)
 			aux++;
 		
 		/* Condição para novo cadastro.*/
 		if (i==TAB_USER)
 			printf("\nLimite de cadastro de usuários atingido.\n");
 		else {
 
 			printf("\nEntre com um novo nome de Usuário:\n");
 			scanf(" %s", userID);
 	
 			/* Loop para encontrar o usuário na tabela */
 			for (i=0; i<aux && userEncontrado; i++) {
 				if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 					userEncontrado=0;
 			}
 			/* Se o usuário for encontrado já está cadastrado. */
 			if (userEncontrado==0)
 				printf("\nUsuário já cadastrado.Tente novamente com outro usuário.\n");
 			else {
 				strcat(TabelaUsuarios[aux].UserId,userID);
 	
 				printf("\nEntre com uma nova senha para o novo usuário %s:\n", userID);
 				scanf(" %s", senha);
 				strcat(TabelaUsuarios[aux].Senha,senha);
 	
 				strcat(TabelaUsuarios[aux].MsgUser,"Bom Dia");
 				
 				/* Condição para verificar o sucesso da operação.*/
 				if(strcmp(userID, TabelaUsuarios[aux].UserId)==0 && strcmp(senha, TabelaUsuarios[aux].Senha)==0)
 					printf("\nNovo usuário '%s' cadastrado com sucesso!\n", TabelaUsuarios[aux].UserId);
 			}
 		}
 		break;

Desbloquear um Usuário

 case 3: /*** PARA DESBLOQUEAR USUÁRIO ***/
 		printf("\nPara desbloquear usuário:\n");
 		printf("\nEntre com o nome do usuário a ser desbloqueado: ");
 		scanf(" %s", userID);
 		
 		/* Loop para encontrar o usuário na tabela */
 		for (aux=0;aux<TAB_USER && userEncontrado;aux++) {
 			if( strcmp(userID, TabelaUsuarios[aux].UserId)==0)
 				userEncontrado=0;
 		}
 
 		/* Se o usuário for encontrado será desbloqueado */
 		if (userEncontrado==0) {
 			aux--;
 			if (TabelaUsuarios[aux].ContUser>=3) {
 				printf("\nUsuário encontrado bloqueado! Desbloqueando usuário...");
 				TabelaUsuarios[aux].ContUser=0;
 
 				/* Condição para verificar o sucesso da operação.*/
 				if(TabelaUsuarios[aux].ContUser<=3)
 					printf("\nUsuário desbloqueado com sucesso!\n");
 			} else
 				printf("\nUsuário encontrado desbloqueado! Tente novamente com outro usuário.\n");
 		} else
 			printf("\nUsuário não cadastrado!\n");
 		break;

Excluir um Usuário

 case 4: /*** PARA EXCLUIR UM USUÁRIO ***/
 		printf("\nDigite o nome de usuário que deseja excluir: ");
 		scanf(" %s", userID);
 
 		/* Loop para encontrar o usuário na tabela.*/
 		for (i=0;i<TAB_USER && userEncontrado; i++) {
 			if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 				userEncontrado=0;
 		}
 		/* Se usuário for encontrado será deletado */
 		if (userEncontrado==0) {
 			printf("\nExcluindo usuário...\n");
 			i--;
 			TabelaUsuarios[i].UserId[0]='\0';
 			TabelaUsuarios[i].Senha[0]='\0';
 			TabelaUsuarios[i].ContUser=0;
 			TabelaUsuarios[i].MsgUser[0]='\0';
 
 			/* Condição para verificar o sucesso da operação.*/
 			if(TabelaUsuarios[i].UserId[0]==0)
 				printf("\nUsuário excluído com sucesso!\n");
 		} else
 			printf("\nUsuário não cadastrado!\n");
 	
 		break;

Imprimir Tabela de Usuários

 case 5: /*** PARA IMPRIMIR TABELA DE USUÁRIOS. ***/
 		printf("\nListando tabela de usuários cadastrados...\n");
 
 		for(aux=0;TabelaUsuarios[aux].UserId[0] && aux<TAB_USER;aux++) {
 			printf("\n%s",TabelaUsuarios[aux].UserId);
 			cont++;
 		}
 		printf("\n\nNúmero de usuários cadastrados: %d\n", cont);
 		break;

Limpar Lista de Usuários

 case 6: /*** PARA LIMPAR LISTA DE USUÁRIOS ***/
 		printf("\nLimpando tabela de usuários...\n");
          	for(i=0;TabelaUsuarios[i].UserId[0];i++) {
            		TabelaUsuarios[i].UserId[0]='\0';
          		TabelaUsuarios[i].Senha[0]='\0';
            		TabelaUsuarios[i].ContUser=0;
 			TabelaUsuarios[i].MsgUser[0]='\0';
 		}
 		break;

Modificar mensagem particular do Usuário

 case 7: /*** PARA MODIFICAR MENSAGEM PARTICULAR DO USUÁRIO. ***/
 		printf("\nPara modificar mensagem particular do usuário:\n");
 		printf("\nEntre com o nome de usuário que deseja modificar a mensagem: ");
 		scanf(" %s", userID);
 
 		/* Loop para encontrar o usuário na tabela.*/
 		for (i=0;i<TAB_USER && userEncontrado; i++) {
 			if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
 				userEncontrado=0;
 		}
 		/* Se usuário for encontrado será modificado a mensagem particular. */
 		if (userEncontrado==0) {
 			printf("\nEntre com a nova mensagem: ");
 			i--;
 			scanf(" %s", TabelaUsuarios[i].MsgUser);
 		
 			/* Verificação do sucesso da operação.*/
 			printf("\nA nova mensagem é '%s'.\n", TabelaUsuarios[i].MsgUser);	
 			printf("\nMensagem particular modificada com sucesso!\n");
 		}else
 			printf("\nUsuário não cadastrado!\n");
 		break;

Modificar mensagem padrão

 case 13: /*** PARA MODIFICAR MENSAGEM PADRAO ***/
 		printf("\nPara modificar mensagem padrão:\n");
 		printf("\nEntre com a nova mensagem: ");
 		scanf(" %s", MsgPadrao);
 		
 		/* Verificação do sucesso da operação.*/
 		printf("\nA nova mensagem é '%s'.\n", MsgPadrao);	
 		printf("\nMensagem padrão modificada com sucesso!\n");
 		break;

Modificar senha do Administrador

 case 15: /*** PARA MODIFICAR SENHA DO ADMINISTRADOR ***/
 		printf("\nPara modificar senha do administrador:\n");
 		printf("\nEntre com a senha atual do admin: ");
 		scanf(" %s", senha);
 
 		for (i=0;i<TAB_ADMIN && userEncontrado; i++) {
 			if( strcmp(userID, TabelaAdmin[i].UserAdmin)==0)
 				userEncontrado=0;
 		}
 		/* Condição para modificar a atual senha do administrador.*/
 		if (userEncontrado==0) {
 			i--;
 			if (strcmp(senha, TabelaAdmin[i].SenhaAdmin)==0) {
 				printf("\nEntre com a nova senha: ");
 				scanf(" %s", senha);
 				printf("\nConfirme a nova senha: ");
 				scanf(" %s", TabelaAdmin[i].SenhaAdmin);
 			
 				/* Condição para verificar o sucesso da operação.*/
 				if (strcmp(senha, TabelaAdmin[i].SenhaAdmin)==0)
 					printf("\nSenha do administrador modificada com sucesso!\n");
 				else
 					printf("\nFalha ao modificar a senha. Dados incorretos. Tente novamente e verifique a nova senha.\n");
 			} else 
 				printf("\nDados incorretos. Tente novamente e verifique a senha do administrador fornecida.\n");
 		}
 		break;

Interface do Administrador (GUI)

Chamada de funções para Administrar

Abaixo encontra-se um exemplo de chamada de funções do GTK para acessar opções de atividades do Administrador: 

  /** Chamadas funções para usuário **/
 void BloquearUser_clicked(GtkWidget *widget, gpointer data)
 {
 	administrar(1, userID, senha);
 }
 
 /** Chamadas funções para administrador **/
 
 void BloquearAdmin_clicked(GtkWidget *widget, gpointer data)
 {
 	administrar(8, userID, senha);
 }

Tabela contendo os botões de atividades do Administrador

Tais botões estarão chamando os tipos de funções mostrados acima e são criados seguindo o exemplo abaixo: 

 /** Caixa que conterá as atividades do administrador **/
 	vbox1 = gtk_vbox_new(FALSE, 1);
 	  
 	labelopcoes = gtk_label_new("Entre com uma das opções:");
 	gtk_label_set_justify(GTK_LABEL(labelopcoes), GTK_JUSTIFY_CENTER);
 
 	labeluser = gtk_label_new("Para usuário:");
 	labeladmin = gtk_label_new("Para administrador:");
 
 /** Definição dos textos que representam cada botão de ação **/
 	BloquearUser = gtk_button_new_with_label("Bloquear usuário");
 	BloquearAdmin = gtk_button_new_with_label("Bloquear administrador");
 
 /** Criação dos botões para uso nas atividades do admin **/
 	gtk_box_pack_start(GTK_BOX(vbox1), labelopcoes, 0, TRUE, 0);
 	gtk_box_pack_start(GTK_BOX(vbox1), labeluser, 0, TRUE, 0);
 	gtk_box_pack_start(GTK_BOX(vbox1), BloquearUser, 0, TRUE, 0);
 	gtk_box_pack_start(GTK_BOX(vbox1), CadastrarUser, 0, TRUE, 0);
 
 /* Função do botão "Bloquear usuário"*/
 	g_signal_connect(G_OBJECT(BloquearUser), "clicked", G_CALLBACK(BloquearUser_clicked), NULL);
 
 /* Função do botão "Bloquear administrador"*/
 	g_signal_connect(G_OBJECT(BloquearAdmin), "clicked", G_CALLBACK(BloquearAdmin_clicked), NULL);


Log de Acesso

Salvar Log em arquivo de texto no computador

 struct TRegistroLog TabelaLog[TAB_LOG];
 
 /*Função para salvar o log de entrada e/ou saída em um arquivo de texto no computador*/
 void save()
 {
 	FILE *log;
 	int i;
 	register int aux;
 
 	log=fopen("LogAcesso.txt", "w");
 
 	if (log==NULL) {
 		printf("\nO arquivo não pode ser aberto.");
 		return;
 	}
 
 	for(i=0;TabelaLog[i].Usuario[0] && i<TAB_LOG;i++)
 		fprintf(log, "%s %s %s", TabelaLog[i].Usuario, TabelaLog[i].Entrada, TabelaLog[i].Saida);
 	fclose(log);
 }

Abrir o arquivo texto de Log

A função abaixo indica como salvar as informações de uma estrutura em arquivo de texto. 

 /*****FUNÇÃO NÃO IMPLEMENTADA, PORÉM PARCIALMENTE PRONTA, PARA ABRIR O ARQUIVO DE LOG PELO ADMINISTRADOR*****/
    
 void load ()
 {
 	FILE *log;
 	register int i;
 
 	log=fopen("LogAcesso.txt", "r");
 
 	if (log==NULL)
 		prinf("\nO arquivo não pode ser aberto.");
 		return;
 	}
 
 	init_list();
 	for (i=0; i<TAB_LOG; i++)
 		if (fread(&TabelaLog[i], sizeof (struct TRegistroLog), 1, log)!=1) {
 			if (feof (log)) break;
 			printf("\nErro de escrita no arquivo de log.\n");
 		}
 	fclose(log);
 }

Função para registrar o login

No exemplo abaixo é apresentado os passos para registrar os dados de entrada do usuário no exato momento de entrada do mesmo. 

 /*Função para guardar a informação de entrada de um usuário numa lista de log que será mostrada ao administrador quando ele estiver logado*/
 void registrar_login(char *userID)
 {
 	int i=0, aux=0;
 	int algoEncontrado=1;
 	char *chamadaLog;
 	
 	time_t lt;
 	lt = time(NULL);
 
 	chamadaLog = ctime(&lt);
 
 	/* Loop para encontrar se há algo na tabela de log */
 	for(i=0;TabelaLog[i].Usuario[0] && i<TAB_LOG;i++)
 		aux++;
 
 	/* Adicionando registro de log */
 	strcat(TabelaLog[aux].Usuario, userID);
 	strcat(TabelaLog[aux].Entrada, chamadaLog);
 				
 	/* Condição para verificar o sucesso da operação.*/
 	if(strcmp(userID, TabelaLog[aux].Usuario)==0 && strcmp(chamadaLog, TabelaLog[aux].Entrada)==0)
 		printf("\nEntrada do usuário %s em %s\n\n", TabelaLog[aux].Usuario, TabelaLog[aux].Entrada);
 
 	save();	
 }

Função para registrar o logout

Aqui temos o modelo básico de implementação do registro de dados de saída do usuário no exato momento de saída do mesmo. 

 /*****FUNÇÃO NÃO IMPLEMENTADA, PORÉM PARCIALMENTE PRONTA, PARA GUARDAR A INFORMAÇÃO DE SÁIDA DE UM USUÁRIO NA LISTA DE LOG TAMBÉM MOSTRADA AO  ADMINISTRADOR*****/
 
 
 
 void registrar_logout(char *userID)
 {
 	time_t ltout;
 
 	TabelaLog.Usuario = userID;
 	
 	ltout = time(NULL);
 	TabelaLog.Saida = ctime(&ltout);
 
 }

Definição dos itens da Lista de Log

 /***Definição dos itens na lista de log***/
 enum
 {
    NAME_COLUMN,
   ENTRY_COLUMN,
   OUT_COLUMN,
   N_COLUMNS
 };
 const gchar *nome, *in, *out;

Criação da Lista de Log

 /***Função de criação da lista de log***/
 static void
 init_list(GtkWidget *list)
 {
   GtkListStore *store;/*Tipo de widget para criar uma lista(modelo) inicialmente não visualizada*/
   GtkTreeViewColumn *column;/*Tipo de widget para visualizar a lista já criada */
   GtkCellRenderer *renderer;
  
   
   
 /* Criar um novo título na tabela de log "cell_renderer" */
   renderer = gtk_cell_renderer_text_new ();
 /* Criar uma coluna, associando o próximo atributo do "cell_renderer" com a primeira coluna do modelode lista */
   column = gtk_tree_view_column_new_with_attributes ("Nome", renderer, "text", NAME_COLUMN, NULL);
 
   /* Adicionar a coluna criada ao campo de visualização */
   gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
 
   /* Segunda coluna ...*/
   renderer = gtk_cell_renderer_text_new ();
   column = gtk_tree_view_column_new_with_attributes ("Entrada", renderer, "text", ENTRY_COLUMN, NULL);
   gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
 
   /* Última Coluna ...*/
   renderer = gtk_cell_renderer_text_new ();
   column = gtk_tree_view_column_new_with_attributes ("Saída", renderer, "text", OUT_COLUMN, NULL);
   gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
 
 
   /* Criação do modelo de lista.  Uso do "store model"*/
   store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 
     
   gtk_tree_view_set_model(GTK_TREE_VIEW(list), 
      GTK_TREE_MODEL(store));
 
    g_object_unref(G_OBJECT (store));
 }

Composição da Lista de Log

 /***Função de composição da lista de log***/
 static void
 add_to_list(GtkWidget *list)
 {
  GtkListStore *store;
  GtkTreeIter iter;
 
  nome = TabelaLog[i].Usuario;
  in = TabelaLog[i].Entrada;
  out = TabelaLog[i].Saida;
  
  store = GTK_LIST_STORE(gtk_tree_view_get_model
      (GTK_TREE_VIEW(list)));
 
  gtk_list_store_insert_after(store, &iter, NULL);
  gtk_list_store_set(store, &iter, NAME_COLUMN, nome, -1);
  gtk_list_store_set(store, &iter, ENTRY_COLUMN, in, -1);
  gtk_list_store_set(store, &iter, OUT_COLUMN, out, -1);
 
 /** Frame 3 com a lista de log - campo fixo **/
  list = gtk_tree_view_new();
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list), TRUE);
 
  gtk_container_add(GTK_CONTAINER(frame3), list);
 
  init_list(list);
 
  for(i=0;TabelaLog[i].Usuario[0] && i<TAB_LOG;i++)
 	add_to_list(list);
Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Projeto_de_Programação_1_-_Programa_Controle_de_Acesso&oldid=52080”