C Criando interfaces gráficas no C com GTK

Aplicações Desktop ainda são muito utilizadas. Neste artigo aprenda como utilizar o GTK para criar interfaces gráficas no C.

Wladimilson M. Nascimento 19 de março de 2021


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.

C Intermediário
Curso de C Intermediário
CONHEÇA O CURSO

Widgets 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:

Tela de instalação do MSYS2, mostrando o local de instalação

Ao final da instalação marque a opção “Run MSYS2 64bit now“:

Tela final da instalação do MSYS2

Com isso, será aberto o terminal do MSYS2:

Terminal do MSYS2

Caso não tenha marcado esta opção, você pode abri-lo no menu iniciar do sistema:

Menu iniciar do Windows mostrando o MSYS2 selecionado

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:

Menu iniciar do Windows mostrando o MSYS2 64bits selecionado

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.

C Avançado
Curso de C Avançado
CONHEÇA O CURSO

Hello 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 200×200:

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:

Janela do GTK mostrando um botão

Por hoje é só. No próximo artigo mostrarei como configurar o MSYS em uma IDE.

Deixe seu comentário

Conheça o autor desse artigo

  • Foto Autor Wladimilson M. Nascimento
    Wladimilson M. Nascimento

    Instrutor, nerd, cinéfilo e desenvolvedor nas horas vagas. Graduado em Ciências da Computação pela Universidade Metodista de São Paulo.

    Posts desse Autor

Artigos relacionados