In article <ma************ *************** ***********@pyt hon.org>, Hugh Macdonald wrote:
I've recently been trying out various different GUI frameworks in Python and
was wondering if I could get your input on the pros and cons of the
different ones...
I would take a strong, close look at Tkinter again. In my opinion,
people have dismissed Tk as 'old technology', but I have seen
nothing else that remotely approaches the power of Tk.
First, a few points:
1) Tk at the moment looks ugly. There is a major
effort undergoing (tile--look on sourceforge) to
develop a themable Tk, and they already have
some very good-looking Windows-looking screenshots.
This won't be available in the immediate future,
but I think it won't be too too far off either.
The Tk community understands that the ugly,
nonstandard look is hurting Tk use.
2) Tkinter is a (relatively) thin layer over
Tk calls. The best way to use it is to build
some functions over it to do what you want
to do, and then reuse those functions.
3) Tkinter does make Tk into an object oriented
paradigm. So as you mention, you can subclass
a Tk widget and then pass in appropriate methods
of that class as functions. However, you often
don't even need to do this. A complex widget is
almost certainly going to be declared as a class
so just do:
class MyWidget(Frame) :
def __init__(self)
button1=Button( command=self.fo o1)
button2=Button( command=self.fo o2)
def foo1(event):...
def foo2(event):...
I can't remember if 'command' is the right option to Button,
but you get the idea.
3) People often complain about the Tk widget set not
being powerful enough. This is nonsense. First, read
through all of the man pages for the Text and Canvas
widgets--nothing else even comes close. (If something
does, please let me know). I've looked at QScintilla,
and it is far less flexible than Text. Then, download
the BLT addon package for Tcl/Tk and read through
its graph widget documentation. As for basic widget
sets, There may be a few widget types missing, but
it is very few, and what is missing can usually
be found in an Python extension (MegaWidgets) or
somewhere else, or coded fairly quickly using Tkinter.
4) The event-handling mechanism in Tk is awesome
It is very easy to specify not just single events,
but also "event sequences"; so, for example, you
can specify that ^X^S (the emacs save command)
saves your files.
5) As I mentioned above, it is often best to put
a nicer wrapper around some of the Tkinter stuff.
For example, here is the way I put things into a
gridded layout:
button = Button(...)
label = Label(...)
subframe = Frame(...)
mywidget = MyWidget(...)
grid([
[button, '-', label],
[subframe, 'x', '^'],
['^', mywidget, '-']
])
Which, using the captalized first letter of each
widget's variable, result in a layout like this:
BBL
S L
SMM
with the middle cell empty. The ^ and - characters
simply indicate that the cell in the previous
row/column should be carred into this cell. This
grid function (not method)
took me about 8 lines to write, and I've
put it up on the Tkinter mailing list hosted on
the Python web site.
Likewise, I'm in the process of writing something
to make event binding easier, and will put that
up when it's done. It will look something like:
bindevents(widg et,
ca_x_space_b1=f un1,
m_backspace=fun 2,
Y=fun3,
)
Which indicates that fun1 should be invoked on the
event sequence ctrl-alt-x ctrl-alt-space ctrl-mousebutton1;
fun2 on meta-backspace; and fun3 on the single key 'Y'.
There are a few problems with Tk. To use much of the
Tkinter stuff, you need to have the Tk man pages
handy, which is why writing more pythonic wrappers
is a good idea. There is a third-party table widget
available which is useful for relatively simple
applications, but which lacks the flexibility and
power of the Text and Canvas widgets. (Still, it's
better than a lot of other table implementations
I've seen.) However, once you've gotten over the
initial learning curve (which mostly has to do
with learning the Tk side, and isn't really that
bad--Brent Welch and a co-author have a brand new
book out which is just great), you can throw a
powerful UI together in an amzingly short time.
Cheers,
Ken
