CalculadoraTkGtkQt

by JoaoBueno

Nunca programei muita coisa em GUI. Hoje inventei de criar uma calculadora como exemplo para um amigo que está aprendendo python.

É impressionante como os kits GUI - todos - são anti-pythonicos. Nas chamadas, acesso a atributos, etc... No quesito ser Pythonico, o Tkinter de fato ganha de longe.

Agora GTK e Qt...nota -5 em documentação. Para conseguir fazer o exemplo, não achei sequer um tutorial dos bindings de python que tivesse coisas tão simples quando o que fazer para acessar o texto de um widget de entrada de texto de uma linha (no Qt até pra saber que esse Widget se chamava QLineEdit sambei). O remédio para Qt e GTK é consultar a documentação na raiz mesmo - do GTK+ em C e do QT4 em C++. O Tkinter tem a referência completa em python (pdf) e dá mais luz quando tentamos usar "help" no console interativo.

Mas, esperoq eu minah calculadorinha 4 operações possa salvar uma ou outra alma por ai, com dicas de como conectar botões em ter que criar uma função para cada botão. (Nesse critério, o mais esotérico é o Tk :-) )- o Qt tá mal documentado pra caramba, mas pelo menos tem só "um jeito óbvi de fazer". Alias - teoricamente, a gambiarra que fiz no Tkinter deveria ter funcionado no Qt também - mas não funciona. Coisas de nossos amigos em C++.

Por fim, desculpas aos puristas de algum desses toolkits - provavelmente passei longe de "fazer do jeito certo" em qualquer das três implementações. O Tkinter sofreu muito por não estar redimensionável (tem como fazer).

Mas por outro lado, o fato do Qt estar mais bonito é culpa, sim, do GTK e do Tk - nesses, para espaçar os botões, por exemplo, eu teria que ficar fazendo ajustes manuais do layout que não sãp do escopo dessa aplicação.

Atualização: o código antes era "bonitnho" e rodava uma calculadora por vez. Alguém na lista PyGTK me deu a idéia de mandar as três rpa tela ao mesmo tempo. (Mas os mainloops da gtk+ e da Tkinter são auto-excludentes dentro do mesmo processo, tive que apelar para o fork)

Coisas que deram mais trabalho:

* descobrir como deixar os botões do GTK+ do mesmo tamanho (tem que se configurar uma fonte mono-espaçada para o label implicito dentro dos botões. Mudar a fonte em GTK, uma vez que tem que usar chamadas de Pango, também não é algo óbvio.)

* conectar os botões do Qt4 sem precisar criar uma função para cada um (é necessario que descobrir qual botão disparou o sinal com uma chamada a self.sender. Parece fácil vendo aqui, mas vá procurar outro exemplo disso na web)

* No TkInter eu já sabia da questão da função callback - então não me estressou hoje. E criar a factorizinha foi divertido.

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 """
   4 Copyright João S. O. Bueno (2008)
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 3 of the License, or (at your option) any later version.
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  * You should have received a copy of the GNU  General
  14  * Public License along with this program; if not, see
  15  * <http://www.gnu.org/licenses/>.
  16 """
  17 import sys
  18 
  19 class Calculator(object):
  20     def __init__(self):
  21         self.reset()
  22 
  23     def reset(self):
  24         self.set_displayed(0.)
  25         self.operator = None
  26         self.operand_1 = 0.
  27         self.clear_display = True
  28 
  29     def keypress(self, arg):
  30         if arg in ("+", "-", "X", "/"):
  31             if not self.operator:
  32                 self.operand_1 = self.get_displayed()
  33             else:
  34                 self.operand_2 = self.get_displayed()
  35                 self.operate()
  36             self.operator = arg
  37             self.clear_display = True
  38         elif arg == "%":
  39             if not self.operand_1:
  40                 return
  41             operand_2 = self.get_displayed()
  42             result = self.operand_1 / 100.0 * operand_2
  43             self.set_displayed(result)
  44         elif arg == "=":
  45             if not self.operator:
  46                 return
  47             self.operand_2 = self.get_displayed()
  48             self.operate()
  49             self.operator = None
  50             self.clear_display = True
  51         elif arg == "C":
  52             self.reset()
  53         else:
  54             self.insert_number(arg)
  55 
  56 
  57     def set_displayed(self, number):
  58         self.set_displayed_str(("%f" % number).strip("0"))
  59 
  60     def get_displayed(self):
  61         try:
  62             result = float(self.get_displayed_str())
  63         except ValueError:
  64             result = 0.0
  65         return result
  66 
  67     def insert_number(self, digit):
  68         if not self.clear_display:
  69             text = self.get_displayed_str()
  70         else:
  71             text = ""
  72         text += digit
  73         self.set_displayed_str(text)
  74         self.clear_display = False
  75 
  76     def operate (self):
  77         if self.operator == "+":
  78             result = self.operand_1 + self.operand_2
  79         elif self.operator == "-":
  80             result = self.operand_1 - self.operand_2
  81         elif self.operator == "X":
  82             result = self.operand_1 * self.operand_2
  83         elif self.operator == "/":
  84             if not self.operand_2:
  85                 self.set_displayed_str("Error")
  86                 self.operand_1 = 0
  87                 return
  88             result = self.operand_1 / self.operand_2
  89         self.operand_1 = result
  90         self.set_displayed(result)
  91 
  92 try:
  93     import gtk
  94     import pango
  95 except ImportError:
  96     sys.stderr.write("PyGTK not found\n")
  97     #create a dummy gtk window class so the program parses
  98     class gtk(object):
  99         class Window(object):
 100             pass
 101 
 102 class GtkCalculator(Calculator, gtk.Window):
 103     def __init__(self):
 104         gtk.Window.__init__(self)
 105         self.connect("destroy", self.destroy)
 106         mainbox = gtk.VBox()
 107         self.add(mainbox)
 108         self.display = gtk.Entry()
 109         mainbox.add(self.display)
 110         self.display.set_editable(False)
 111         self.display.set_alignment(1.0)
 112         count = 0
 113         font = pango.FontDescription("monospace 16")
 114         buttons = "789+456-123X0.%/C="
 115         for button in buttons:
 116             if count % 4 == 0:
 117                 row = gtk.HBox()
 118                 mainbox.pack_start(row)
 119             b = gtk.Button(button)
 120             #b is a GTK Button - it has no text
 121             # it contains a single "gtk label"
 122             # to set the button font we have to change the font
 123             # in this contained label instead
 124             b.get_child().modify_font(font)
 125             b.connect("clicked", self.keypress, button)
 126             row.pack_start(b)
 127 
 128             count += 1
 129         self.show_all()
 130         Calculator.__init__(self)
 131 
 132     def keypress(self, widget, arg):
 133         Calculator.keypress(self, arg)
 134 
 135     def set_displayed_str(self, number):
 136         self.display.set_text(number)
 137     def get_displayed_str(self):
 138         return self.display.get_text()
 139 
 140 
 141     def destroy(self, *args):
 142         gtk.main_quit()
 143 
 144 try:
 145     import Tkinter
 146 except ImportError:
 147     sys.stderr.write("Tkinter not found\n")
 148     #create a dummy Tkinter.Tk class so the program parses
 149     class Tkinter(object):
 150         class Tk(object):
 151             pass
 152 
 153 class TkCalculator(Calculator, Tkinter.Tk):
 154     def __init__(self):
 155         Tkinter.Tk.__init__(self)
 156         self.title("Calculadora")
 157         self.displayed = Tkinter.StringVar()
 158         self.display = Tkinter.Entry(self,
 159                                      textvar = self.displayed,
 160                                      state = "readonly",
 161                                      justify = Tkinter.RIGHT,
 162                                      background="#dddddd",
 163                                      readonlybackground="#dddddd",
 164                                      borderwidth=5)
 165         self.display.grid(row=0, columnspan=4)
 166         buttons = "789+456-123X0.%/C="
 167         count = 0
 168         row = 0
 169         for button in buttons:
 170             if count % 4 == 0:
 171                 row += 1
 172             b = Tkinter.Button(self,
 173                                text = button,
 174                                command = self.command_factory(button),
 175                                width=2 )
 176             b.grid(column=count % 4, row=row)
 177             count += 1
 178         Calculator.__init__(self)
 179 
 180     def command_factory(self, button):
 181         class Command(object):
 182             def __init__(self, calculator, button):
 183                 self.calculator = calculator
 184                 self.button = button
 185             def command(self):
 186                 return self.calculator.keypress(self.button)
 187         return Command(self, button).command
 188 
 189 
 190     def set_displayed_str(self, string):
 191         self.displayed.set(string)
 192 
 193     def get_displayed_str(self):
 194         return self.displayed.get()
 195 
 196 try:
 197     from PyQt4 import QtGui
 198     from PyQt4 import QtCore
 199 except ImportError:
 200     sys.stderr.write("PyQt4 not found\n")
 201     #create a dummy QtGui.QWidget class so the program parses
 202     class QtGui(object):
 203         class QWidget(object):
 204             pass
 205 class QtCalculator(Calculator, QtGui.QWidget):
 206     def __init__(self):
 207         QtGui.QWidget.__init__(self)
 208         self.setWindowTitle("Calculator")
 209         grid = QtGui.QGridLayout()
 210         #FIXME: find single line widget
 211         self.display = QtGui.QLineEdit()
 212         self.display.setReadOnly(True)
 213         self.display.setAlignment(QtCore.Qt.AlignRight)
 214         grid.addWidget(self.display,0,0,1, 5)
 215         buttons = "789+456-123X0.%/C="
 216         counter = 0
 217         row = 0
 218         self.clear_display = False
 219         for button in buttons:
 220             if counter % 4 == 0:
 221                 row += 1
 222             b = QtGui.QPushButton()
 223             b.setText(button)
 224             self.connect(b, QtCore.SIGNAL("clicked()"), self.keypress)
 225             grid.addWidget(b, row, counter % 4)
 226             counter += 1
 227         self.setLayout(grid)
 228         self.show()
 229         Calculator.__init__(self)
 230 
 231     def keypress(self, *args):
 232         button = self.sender()
 233         if not isinstance(button, QtGui.QPushButton):
 234             return
 235         key = str(button.text().toUtf8())
 236         Calculator.keypress(self,key)
 237 
 238     def set_displayed_str(self, string):
 239         self.display.setText(string)
 240 
 241     def get_displayed_str(self):
 242         return str(self.display.text().toUtf8())
 243 
 244 if __name__ == "__main__":
 245     if len(sys.argv) >= 2 and sys.argv[1] in ("tk", "gtk", "qt", "all"):
 246         if sys.argv[1] == "gtk":
 247             GtkCalculator()
 248             gtk.main()
 249         elif sys.argv[1] == "tk":
 250             TkCalculator()
 251             Tkinter.mainloop()
 252         elif sys.argv[1] == "qt":
 253             app = QtGui.QApplication(sys.argv[1:])
 254             c = QtCalculator()
 255             sys.exit(app.exec_())
 256         elif sys.argv[1] == "all":
 257             import os
 258             if os.fork()==0:
 259                 app = QtGui.QApplication(sys.argv[1:])
 260                 c = QtCalculator()
 261                 GtkCalculator()
 262                 gtk.main()
 263             else:
 264                 TkCalculator()
 265                 Tkinter.mainloop()
 266             #sys.exit(app.exec_())
 267 
 268     else:
 269         sys.stderr.write("Usage: calc_tk_gtk [tk|gtk|qt|all]\n")
 270         sys.exit(1)

CalculadoraTkGtkQt (editada pela última vez em 2008-09-26 14:07:44 por localhost)