Pesquisa de site

Crie aplicativos GUI mais avançados usando a ferramenta PyGobject no Linux

Os aplicativos de interface gráfica do usuário (GUI) tornaram-se uma parte essencial do desenvolvimento de software moderno. As GUIs fornecem uma interface visualmente atraente e amigável para os usuários interagirem com o aplicativo. No Linux, PyGObject é uma ferramenta poderosa para desenvolver aplicativos GUI usando a biblioteca de introspecção GObject. PyGObject é um módulo Python que fornece ligações para bibliotecas baseadas em GObject, incluindo GTK, GStreamer e outras. Neste artigo, discutiremos como criar aplicativos GUI mais avançados usando PyGObject no Linux.

O que é PyGObject?

GObject é um sistema de objetos fundamental usado por GTK, GStreamer e outras bibliotecas para criar software orientado a objetos em C. PyGObject permite que os desenvolvedores criem aplicativos GUI usando Python enquanto aproveitam o poder das bibliotecas baseadas em GObject.

Requisitos

Antes de começarmos a desenvolver aplicativos GUI usando PyGObject, precisamos instalar algumas dependências. Neste tutorial, usaremos a biblioteca GTK para criar aplicativos GUI. Para instalar a biblioteca GTK, execute o seguinte comando em seu terminal -

sudo apt-get install libgtk-3-dev

Também precisamos instalar o módulo PyGObject, que fornece as ligações Python para a biblioteca GTK. Para instalar o PyGObject, execute o seguinte comando -

sudo apt-get install python3-gi

Depois de instalarmos as dependências necessárias, podemos começar a desenvolver nosso aplicativo GUI usando PyGObject.

Criando um aplicativo PyGObject simples

Vamos começar criando um aplicativo PyGObject simples que exibe uma janela. Abra seu editor de texto favorito e crie um novo arquivo chamado simple_app.py. Neste arquivo, adicione o seguinte código -

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class MyWindow(Gtk.Window):

   def __init__(self):
      Gtk.Window.__init__(self, title="My Window")

win = MyWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()

Vamos examinar esse código passo a passo. Primeiro importamos o módulo gi e especificamos que necessitamos da versão 3.0 da biblioteca GTK. Em seguida, importamos o módulo Gtk, que fornece as principais classes e funções para a criação de aplicações GUI usando PyGObject.

A seguir, criamos uma nova classe chamada MyWindow, que herda da classe Gtk.Window. No método __init__, chamamos o construtor pai e definimos o título da janela como “Minha Janela”.

Criamos então uma instância da classe MyWindow e conectamos o sinal “destroy” à função Gtk.main_quit, que será chamada quando o usuário fechar a janela. Por fim, mostramos a janela usando o método show_all e iniciamos o loop principal usando a função Gtk.main.

Para executar este aplicativo, abra seu terminal e navegue até o diretório que contém o arquivo simple_app.py. Em seguida, execute o seguinte comando -

python3 simple_app.py

Isto abrirá uma janela com o título “Minha Janela”.

Adicionando widgets à janela

Agora que criamos um aplicativo PyGObject simples, vamos adicionar alguns widgets à janela. Widgets são os blocos de construção de um aplicativo GUI e podem incluir botões, rótulos, caixas de texto e muito mais.

Vamos adicionar um rótulo à nossa janela. Modifique a classe MyWindow no arquivo simple_app.py para ficar assim -

class MyWindow(Gtk.Window):

   def __init__(self):
      Gtk.Window.__init__(self, title="My Window")

      # Create a label widget
        self.label = Gtk.Label()

      # Add the label to the window
        self.add(self.label)

No método __init__ , primeiro criamos uma instância da classe Gtk.Label e a atribuímos ao atributo self.label. Em seguida, adicionamos o widget de rótulo à janela usando o método add da classe Gtk.Window. Agora, quando criarmos uma instância da classe MyWindow e mostrarmos a janela, o widget de rótulo será exibido no canto superior esquerdo da janela. A seguir, vamos definir o texto do rótulo como “Hello, World!” e adicione-o à janela. Modifique o método __init__ para ficar assim -

class MyWindow(Gtk.Window):

   def __init__(self):
      Gtk.Window.__init__(self, title="My Window")

      # Create a label
      self.label = Gtk.Label()
      self.label.set_text("Hello, World!")
      self.add(self.label)

Adicionamos duas linhas de código para definir o texto do rótulo como "Hello, World!" e adicione-o à janela usando o método add.

Agora, ao executar o aplicativo, você deverá ver uma janela com o rótulo "Hello, World!".

Adicionando um botão

Vamos adicionar um botão à nossa janela que altera o texto do rótulo quando ele é clicado. Modifique o método __init__ da classe MyWindow para ficar assim -

class MyWindow(Gtk.Window):

   def __init__(self):
      Gtk.Window.__init__(self, title="My Window")

      # Create a label
      self.label = Gtk.Label()
      self.label.set_text("Hello, World!")
      self.add(self.label)

      # Create a button
      self.button = Gtk.Button(label="Click me")
      self.button.connect("clicked", self.on_button_clicked)
      self.add(self.button)

   def on_button_clicked(self, widget):
      self.label.set_text("Button clicked")

Adicionamos um novo widget Gtk.Button e o atribuímos à variável de instância self.button. Também conectamos o sinal “clicado” do botão a um novo método chamado on_button_clicked. Este método será chamado quando o botão for clicado.

No método on_button_clicked, definimos o texto do rótulo como “Botão clicado”.

Agora, ao executar o aplicativo, você deverá ver uma janela com um rótulo que diz “Hello, World!” e um botão que diz "Clique em mim". Ao clicar no botão, o texto do rótulo deverá mudar para “Botão clicado”.

A seguir, vamos explorar alguns aplicativos GUI mais avançados e complexos que podem ser criados usando PyGObject.

Criando um aplicativo de calculadora

Vamos criar um aplicativo de calculadora que execute operações aritméticas básicas.

Primeiro, definimos uma nova classe CalculatorWindow que herda da classe Gtk.Window. Esta classe é usada para criar a janela principal do aplicativo.

class CalculatorWindow(Gtk.Window):

   def __init__(self):
      Gtk.Window.__init__(self, title="Calculator")

A seguir, criamos um layout de grade para organizar os widgets em uma estrutura semelhante a uma grade.

   # Create a grid
   grid = Gtk.Grid()
   self.add(grid)

Criamos um widget Gtk.Label para exibir os resultados dos cálculos.

# Create the display label
   self.display = Gtk.Label()
   self.display.set_hexpand(True)
   self.display.set_vexpand(True)
   self.display.set_alignment(1, 0)
   self.display.set_text("0")
   grid.attach(self.display, 0, 0, 4, 1)

Em seguida, criamos os botões da calculadora. Cada botão é criado usando a classe Gtk.Button e rotulado com o número ou operador correspondente.

# Create the buttons
   button_7 = Gtk.Button(label="7")
   button_8 = Gtk.Button(label="8")
   button_9 = Gtk.Button(label="9")
   button_divide = Gtk.Button(label="/")
   button_4 = Gtk.Button(label="4")
   button_5 = Gtk.Button(label="5")
   button_6 = Gtk.Button(label="6")
   button_multiply = Gtk.Button(label="*")
   button_1 = Gtk.Button(label="1")
   button_2 = Gtk.Button(label="2")
   button_3 = Gtk.Button(label="3")
   button_subtract = Gtk.Button(label="-")
   button_0 = Gtk.Button(label="0")
   button_decimal = Gtk.Button(label=".")
   button_equal = Gtk.Button(label="=")
   button_add = Gtk.Button(label="+")

Conectamos o sinal clicado de cada botão ao método on_button_clicked, que é responsável por anexar o número ou operador correspondente à expressão atual que está sendo inserida.

# Connect the button signals to the handlers
   button_7.connect("clicked", self.on_button_clicked, "7")
   button_8.connect("clicked", self.on_button_clicked, "8")
   button_9.connect("clicked", self.on_button_clicked, "9")
   button_divide.connect("clicked", self.on_button_clicked, "/")
   button_4.connect("clicked", self.on_button_clicked, "4")
   button_5.connect("clicked", self.on_button_clicked, "5")
   button_6.connect("clicked", self.on_button_clicked, "6")
   button_multiply.connect("clicked", self.on_button_clicked, "*")
   button_1.connect("clicked", self.on_button_clicked, "1")
   button_2.connect("clicked", self.on_button_clicked, "2")
   button_3.connect("clicked", self.on_button_clicked, "3")
   button_subtract.connect("clicked", self.on_button_clicked, "-")
   button_0.connect("clicked", self.on_button_clicked, "0")
   button_decimal.connect("clicked", self.on_button_clicked, ".")
   button_equal.connect("clicked", self.on_equal_clicked)
   button_add.connect("clicked", self.on_button_clicked, "+")

Adicionamos os botões ao layout da grade, organizando-os em uma grade 4x4.

  # Add the buttons to the grid
grid.attach(button_7, 0, 1, 1, 1)
grid.attach(button_8, 1, 1, 1, 1)
grid.attach(button_9, 2, 1, 1, 1)
grid.attach(button_divide, 3, 1, 1, 1)
grid.attach(button_4, 0, 2, 1, 1)
grid.attach(button_5, 1, 2, 1, 1)
grid.attach(button_6, 2, 2, 1, 1)
grid.attach(button_multiply, 3, 2, 1, 1)
grid.attach(button_1, 0, 3, 1, 1)
grid.attach(button_2, 1, 3, 1, 1)
grid.attach(button_3, 2, 3, 1, 1)
grid.attach(button_subtract, 3, 3, 1, 1)
grid.attach(button_0, 0, 4, 1, 1)
grid.attach(button_decimal, 1, 4, 1, 1)
grid.attach(button_equal, 2, 4, 1, 1)
grid.attach(button_add, 3, 4, 1, 1)

Definimos o método on_button_clicked que trata o evento click para cada botão. Este método anexa o caractere correspondente à expressão atual que está sendo inserida.

# Handler for the button click event
   def on_button_clicked(self, widget, char):
      self.expression += char
      self.display.set_text(self.expression)

Também definimos o método on_equal_clicked que avalia a expressão atual e exibe o resultado no rótulo.

# Handler for the equal button click event
   def on_equal_clicked(self, widget):
      try:
         result = str(eval(self.expression))
         self.display.set_text(result)
         self.expression = result
      except:
         self.display.set_text("Error")
         self.expression = ""

Finalmente, criamos uma instância da classe CalculatorWindow e mostramos a janela principal.

if __name__ == "__main__":
   win = CalculatorWindow()
   win.connect("destroy", Gtk.main_quit)
   win.show_all()
   Gtk.main()

Isso cria um aplicativo de calculadora básico com uma GUI. Você pode personalizá-lo ainda mais adicionando mais funcionalidades ou alterando o layout e design dos widgets.

Conclusão

PyGObject é uma ferramenta poderosa para criar aplicativos GUI no Linux. Ele fornece uma API Pythonic para a biblioteca GObject, que é a biblioteca C subjacente para GTK+. Com PyGObject, os desenvolvedores podem criar facilmente aplicativos GUI complexos e sofisticados para ambientes de desktop em Linux.

Neste artigo, cobrimos os fundamentos do PyGObject e demonstramos como criar um editor de texto simples e um aplicativo de calculadora usando a ferramenta. Também exploramos alguns recursos avançados do PyGObject, incluindo a criação de widgets personalizados e o uso de CSS para estilização.

PyGObject oferece uma ampla gama de possibilidades para a criação de aplicativos GUI em Linux. Os desenvolvedores podem aproveitar os recursos da ferramenta para criar aplicativos de desktop avançados e interativos que melhoram a experiência do usuário. Ao combinar a simplicidade e facilidade de uso do Python com o poder e a flexibilidade da biblioteca GObject, o PyGObject oferece uma solução robusta para a criação de aplicativos GUI avançados no Linux.

Artigos relacionados: