From: Gregory Ewing on
Terry Reedy wrote:
> pygui ... has its own problems. ... the api sytle is not standard
> in Python (get_xx and set_xx methods instead of direct access or
> properties);

That was only true in a very early version of PyGUI. Properties
are used very extensively now.

(It uses get_xxx and set_xxx methods to *implement* properties,
but you don't call those from outside, you use normal attribute
access.)

--
Greg
From: rantingrick on
On Jun 7, 1:29 pm, Terry Reedy <tjre...(a)udel.edu> wrote:
> Ant
> I agree that the current tk situation is not completely satisfactory. In
> particular, the IO facilities are inadequate and have not, to my
> knowledge, changed in a decade. Image input formats are limited. There
> is no canvas output as an image. (Output of the canvase display list as
> a dialect of postscript that not everything can read is not a substitute
> for this.)
>
> However...
> I think it important that Python come with a minimal IDE that is
> adequate for someone like me doing Python-only development. I thank the
> programmers of IDLE. So merely deleting tk/tkinter is not an option.
> Indeed, having something similar to and at least as good as IDLE for any
> candidate gui replacememt should and I think would be a requirement for
> consideration.
>
> The problem with the big gui application frameworks are that they are
> too big. The two I have glanced at -- wx... and qt -- have much more
> than gui stuff and duplicate parts of the Python stdlib and other 3rd
> party libs.
>
> As for a small gui written in Python, you seem to have ignored the link
> to pygui. Of course that has its own problems. Among others: it is
> incomplete; it ignore Python 3 (requires 2.3+ should be 2.3 to 2.6),
> which is the only place it could be added; the api sytle is not standard
> in Python (get_xx and set_xx methods instead of direct access or
> properties); and there is nothing yet like IDLE.
>
> What would be required is a Python3 GUI project with multiple contributors.
>
> Terry Jan Reedy

I STRONGLY agree with Terry here! We need a very lightweight GUI in
the stdlib that is NOT Tkinter but IS roughly the very same basic
widget set, only better!. Yes this is 2010 and any GUI should support
all the major image types out-of-the-box!! But we damn sure don't want
100mb of bloated wx killing download times of Python either!

Improving Tkinter IMO is a lost cause. We need to find a better base
and build from it. Maybe a stripped down version of wx, or something
else...? But we sure don't need an embedded TCL interpretor packaged
with Python either *YUCK*!!!

The problem is getting a large enough group of Python users to agree
on anything about GUIs. I don't think the numbers will ever be big
enough because people are only worried about getting "their preferred"
GUI into Python. But the focus should not be on getting the most
cutting edge GUI into Python --size and maintainability issues forbid
that-- no the focus should be on these qualities...

- cross platform
- lightweight
- simple to use
- not an antiquity
- no embedded interpretors

However as i have mentioned before there will NEVER be a crowd of us
marching in the streets behind one GUI. People are just too busy to
get involved. This has to be an executive decision. The powers that be
must make the change themselves or it will never happen -- i can
guarantee that! And if this change is made python will be better off
in the end. You have my vote for change but unless someone with more
influence steps up then our laments will be but in vain.

psst, hey Guido, it's time to make your triumphant comeback to c.l.p.
We are waiting...
From: rantingrick on
On Jun 7, 5:05 pm, Michael Torrie <torr...(a)gmail.com> wrote:

> Thus for Python to really be successful in a broader sense, we need
> good, solid, bindings for Cocoa, or Windows forms (whatever they are
> using these days), as well as the most popular windows toolkits.  We
> don't need another Swing.  As someone else mentioned, web-based
> interfaces are increasingly important.  That means you have to write
> your apps in a modular way that separates the GUI from the business
> logic.  That way you can develop a nice GUI app and then, when there is
> demand, give it a web front end.

Micheal makes a good point about the future web based interfaces. The
momentum is building fast for this type of thing and GUI may be
obsolete very soon. What options do we have in this arena? If were
going to move forward we should at least move in the right direction.
Seems that web based would help to satisfy the size requirement at
least. Pythoninic API, hmm, ain't seen one yet? Anybody have
suggestions...?
From: Michael Torrie on
On 06/07/2010 09:19 PM, rantingrick wrote:
> On Jun 7, 5:05 pm, Michael Torrie <torr...(a)gmail.com> wrote:
>
>> Thus for Python to really be successful in a broader sense, we need
>> good, solid, bindings for Cocoa, or Windows forms (whatever they are
>> using these days), as well as the most popular windows toolkits. We
>> don't need another Swing. As someone else mentioned, web-based
>> interfaces are increasingly important. That means you have to write
>> your apps in a modular way that separates the GUI from the business
>> logic. That way you can develop a nice GUI app and then, when there is
>> demand, give it a web front end.
>
> Micheal makes a good point about the future web based interfaces. The
> momentum is building fast for this type of thing and GUI may be
> obsolete very soon. What options do we have in this arena? If were
> going to move forward we should at least move in the right direction.
> Seems that web based would help to satisfy the size requirement at
> least. Pythoninic API, hmm, ain't seen one yet? Anybody have
> suggestions...?

What I do is to make the bulk of my code in modules that I can import
into a web-based front end (say in Django), or in a GTK-based front-end
or what have you. In other words everything is abstracted as best I can
to be independent of the GUI. If I was writing a file manager, for
example, I'd abstract all the operations that read and wrote
directories, performed file ops, etc, so that the frontend code just
simply calls my high-level functions and methods. Then it becomes much
easier to build a PyGTK front end, or PyQt frontend. There's obviously
a certain amount of work that goes into the frontend, but not quite as
much as if I'd glommed everything together.

Another tactic we're trying at my work is to build web apps in Django
and then ensure that all of our apps export business logic over XMLRPC,
so we can write non-web frontends to our apps, or even scripts. I think
RPC-like mechanisms are the key to an agile app, at least if the app is
a network-oriented app to begin with.

From: alex23 on
rantingrick <rantingr...(a)gmail.com> wrote:
> The problem is getting a large enough group of Python users to agree
> on anything about GUIs.

No, the problem is it's a lot easier to find fault than it is to
provide a solution. And that maybe, just maybe, other people don't
want to have to do your dirty work for you.

> I don't think the numbers will ever be big
> enough because people are only worried about getting "their preferred"
> GUI into Python.

And in what way is that different from _your_ preference for not-
Tkinter?

> People are just too busy to
> get involved. This has to be an executive decision. The powers that be
> must make the change themselves or it will never happen -- i can
> guarantee that!

No. That is _not_ how open source works. This has to be _your_
decision to _do something_. It's your itch, no one else is under any
obligation to scratch it. If it's so obvious to you what is wrong
here, it should be very clear to you how to fix it. Of course, someone
who wasn't labouring under the Dunning-Kruger effect might think that
perhaps the very fact that there are so many GUI libs out there might
indicate that this isn't a readily solved problem space...

Alternatively: how much is this change worth to you? How much are you
willing to pay to see it happen?

> psst, hey Guido, it's time to make your triumphant comeback to c.l.p.
> We are waiting...

You know, you _could_ drop the incessant cult of personality obsession
and rely on yourself to resolve the problems you see....

What gets me is the implicit attitude in some of these posts that it's
just so _obvious_ that something needs to be done and it's simply that
_everyone else_ is either stupid, lazy or biased towards actually
existing code.