Com raras exceções, toda nova aplicação visará uma versão web e/ou mobile. Aplicativos Desktop foram relegados a segundo plano. Entretanto, mesmo não sendo voltada para estas áreas, ao se analisar o TIOBE index, veremos que C se encontra entre as linguagens mais propulares. Isso na publicação deste artigo, mas ela se mantém entre as linguagens mais populares há muitos anos. Indicando que ainda há um grande mercado além da dualidade web-mobile. Uma das áreas onde o C é muito utilizado são em sistemas Unix, principalmente na criação de aplicações Desktops.
Neste sistema, existem várias bibliotecas para a criação de interfaces gráficas, por ser multiplataforma, veremos como criar uma utilizando o GTK.
O que é o GTK?
GTK é um toolkit open-source e multiplataforma para a criação de interfaces gráficas (GUI). Foi criado inicialmente para o GIMP, por isso era chamado de GIMP toolkit, com abreviação GTK+. Posteriormente, foi adotado pela GNOME Foundation e com o tempo passou a ser conhecido apenas como GTK.
Hoje o GTK é um dos tookits mais utilizados para a criação de aplicações gráficas para o Unix, principalmente em distribuições que fazem uso do gerenciador de Desktop GNOME. Mas por ser multiplataforma não fica limitado a este sistema.
O já citado GIMP é desenvolvido com GTK e está disponível para todos os sistemas operacionais.
Curso C Intermediário
Conhecer o cursoWidgets do GTK
Antes de vermos um exemplo de uma aplicação com interface gráfica, é importante compreender o que é um widget.
Este termo não é exclusivo do GTK, ele é utilizado para designar um componente em uma interface gráfica. Seja um componente visível, como um botão, campo, texto, etc.; até um componente “invisível”, que auxilia na estruturação do layout, como alinhamento.
Instalando o GTK
Aqui abordarei em detalhes apenas o processo de instalação do GTK no Windows 10, pois neste sistema o processo é mais complexo. Caso esteja utilizando uma distribuição Linux, para instalá-lo basta adicionar o pacote gtk3, junto com as suas dependências.
No MacOS, basta executar o script de instalação, ele irá se encarregar de analisar o sistema e baixar as bibliotecas necessárias.
No caso do Windows, antes de instalar o GTK, é necessário instalar o MSYS2. O MSYS2 é uma coleção de ferramentas de desenvolvimento para sistemas Windows e nesta coleção há o gerenciador de pacotes Pacman, que nos permitirá instalar o GTK.
Então vamos colocar a mão na massa.
Instalando o MSYS2
O MSYS2 pode ser obtido no seu repositório. Sempre opte pelo último executável criado, eles são nomeados no padrão “msys2-x86_64-[yyyymmdd].exe”. Assim, no momento a última versão disponível, a que utilizarei, é msys2-x86_64-20210228.exe.
Após o download do arquivo, o execute. Basta seguir o processo de instalação, mas procure não instalá-lo dentro dos arquivos de programa. Você pode instalá-lo na raiz do disco:
Ao final da instalação marque a opção “Run MSYS2 64bit now”:
Com isso, será aberto o terminal do MSYS2:
Caso não tenha marcado esta opção, você pode abri-lo no menu iniciar do sistema:
Instalando o GTK com o Pacman
Com o MSYS2 instalado, podemos utilizar o Pacman, inicialmente é necessário atualizar seus pacotes. Para isso, execute no terminal o comando abaixo:
pacman -Syu
Caso algo esteja desatualizado, ele irá perguntar se a nova versão do pacote poderá ser instalada:
Com os pacotes atualizados, podemos iniciar a instalação das ferramentas que o GTK necessitará. Isso será feito com o comando abaixo:
pacman -S mingw-w64-x86_64-toolchain
Este comando irá listar uma série de ferramentas, onde devem ser selecionadas as abaixo:
- mingw-w64-x86_64-binutils;
- mingw-w64-x86_64-crt-git;
- mingw-w64-x86_64-gcc;
- mingw-w64-x86_64-gcc-libs;
- mingw-w64-x86_64-headers-git;
- mingw-w64-x86_64-libmangle-git;
- mingw-w64-x86_64-libwinpthread-git;
- mingw-w64-x86_64-make;
- mingw-w64-x86_64-pkgconfig (ou mingw-w64-x86_64-pkg-config);
- mingw-w64-x86_64-tools-git;
- mingw-w64-x86_64-winpthread-git;
- mingw-w64-x86_64-winstorecompat-git.
Essas ferramentas estarão numeradas:
Mas estes números podem ser diferentes no seu ambiente, então é necessário prestar atenção se as ferramentas corretas estão sendo selecionadas.
Em seguida, execute o comando:
pacman -S base-devel
Que também irá listar uma série de ferramentas e neste caso devem ser selecionadas apenas duas:
- make;
- pkgconfig (ou pkg-config).
Essas ferramentas também estarão numeradas:
Com a instalação das ferramentas, o GTK poderá ser instalado com o comando abaixo:
pacman -S mingw-w64-x86_64-gtk3
Também é recomendado a instalação do Glade:
pacman -S mingw-w64-x86_64-glade
Para verificar se tudo deu certo, feche o terminal padrão do MSYS e abra a versão de 64bits:
E nela, execute o comando abaixo:
pkg-config --cflags gtk+-3.0
Caso não seja apresentado nenhum erro:
Significa que o ambiente está configurando corretamente.
Curso C Avançado
Conhecer o cursoHello World
Com o ambiente configurado, vamos criar o famoso “Hello World” com o GTK:
#include <gtk/gtk.h>
static void print_hello (GtkWidget *widget, gpointer data)
{
g_print ("Hello World\n");
}
static void activate (GtkApplication *app, gpointer user_data)
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *button_box;
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "Olá Mundo");
gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window), button_box);
button = gtk_button_new_with_label ("Hello World");
g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
gtk_container_add (GTK_CONTAINER (button_box), button);
gtk_widget_show_all (window);
}
int main (int argc, char **argv)
{
GtkApplication *app;
int status;
app = gtk_application_new ("treinaweb.helloworld", G_APPLICATION_FLAGS_NONE);
g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
status = g_application_run (G_APPLICATION (app), argc, argv);
g_object_unref (app);
return status;
}
Este código é bem simples, contendo apenas uma tela com um botão.
Inicialmente o GTK é importado:
#include <gtk/gtk.h>
No código são definidos três funções, sendo que na main, uma aplicação do GTK é definida:
GtkApplication *app;
//...
app = gtk_application_new ("treinaweb.helloworld", G_APPLICATION_FLAGS_NONE);
É importante que o nome da aplicação seja definido em letras minúsculas, tenha ao menos duas palavras, separadas por ponto. Caso contrário, será apresentado um erro quando for executada.
Quando esta aplicação é ativada:
g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
É chamada a função activate:
static void activate (GtkApplication *app, gpointer user_data)
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *button_box;
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "Olá Mundo");
gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window), button_box);
button = gtk_button_new_with_label ("Hello World");
g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
gtk_container_add (GTK_CONTAINER (button_box), button);
gtk_widget_show_all (window);
}
Onde são definidos três widgets:
GtkWidget *window;
GtkWidget *button;
GtkWidget *button_box;
A tela, que contém o título “Olá Mundo” e o tamanho 200x200:
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "Olá Mundo");
gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
Em seguida, é definido um container:
button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window), button_box);
Onde o botão é adicionado:
button = gtk_button_new_with_label ("Hello World");
g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
gtk_container_add (GTK_CONTAINER (button_box), button);
Ao ser pressionado, o botão chamará a função print_hello:
static void print_hello (GtkWidget *widget, gpointer data)
{
g_print ("Hello World\n");
}
Que exibirá “Hello World” no output da aplicação.
Para executar este código, será utilizado o comando abaixo no terminal de 64bits do MSYS:
gcc helloworld.c -o helloworld `pkg-config --cflags gtk+-3.0` `pkg-config --libs gtk+-3.0`
Este comando irá criar um executável chamado helloworld, deve ser invocado pelo terminal:
./helloworld.exe
E com isso, a aplicação será exibida:
Por hoje é só. No próximo artigo mostrarei como configurar o MSYS em uma IDE.
