Pythonic gui format?

[Gregory Petrosyan]

Buenos dias, amigos!
I have to write _simple_ gui library, for embedding into game. My
first attempt was to use XML: isn't it cute to describe ui in such a
way:

<window>
<title>Hello World!</title>
<image text="nice picture here" pos=... src=... />
<text opts=...>
(some text here)
</text>
<list>
<item>first element</item>
<item>second one...</item>
</list>
<button action=... text="Click Me!" />
</window>

(or something similar)

But after reading "Python Is Not Java"
http://dirtsimple.org/2004/12/python-is-not-java.html (BTW I'm not a
Java programmer) I realised that it is actually not cute at all :) (am
I wrong here?)
I am currently seeking for pythonic alternative for XML. One possible
way is to create a class for every (type of?) window, like

class SomeDlg(Window) :
def __init__(self, dict?):
self.setdict(di ct)
self.add_text(" $friend would like to speak to you. $question")
self.add_button (action=self.on click,
text="Yeah, I'd like to $action !")
...

def onclick(self):
# process data here, send some messages etc.
Isn't it ugly a bit? Another variant is

dlg = Window(dict, [opts])
dlg.text("text here", [opts])
dlg.image(src, pos, text [etc])
.....

or possibly

dlg = Window(...)
dlg.text = Text(...)
dlg.button = Button(...)
....
dlg.display(sur face)
These styles of course can be combined... But IMHO looks not very nice
:( Maybe I shall not rely on introspection? Any suggestions, comments,
thoughts and links are welcome.
Thanks.

[Ivan Voras]

Gregory Petrosyan wrote:

I have to write _simple_ gui library, for embedding into game. My
first attempt was to use XML
....
But after reading "Python Is Not Java"
http://dirtsimple.org/2004/12/python-is-not-java.html (BTW I'm not a
Java programmer) I realised that it is actually not cute at all :) (am
I wrong here?)

Don't do that :)

Don't listen to recommendations for or against a technology based only
on vague "this is not how we do things around here" reasons. If XML
suits your need, than use it. It seems it will work fine in situations
where you need to edit/extend the GUI by external means. If you do it in
code, you risk that you'll need to change the code every time you want
to reposition a GUI element. It doesn't matter much if you invent your
own file format because eventually you'll have to extend it, or write
support for it, so you could as well use XML from the start.

XML parsing can be a little tedious, but there are many tools that make
it easier (I've even written one: http://ivoras.sharanet.org/xmldict.py.gz).

[Gregory Petrosyan]

Thanks for your reply.
But isn't python code more flexible than XML? I think it's not harder
to edit py file than xml file. Also python can give me more speed than
xml, and possibly python code can be integrated better with rest of app
(because of absence of extra layer called "XML"). Has anybody have had
(how many grammar errorrs can you find here? :) some experience in
writing gui systems/formats "from scratch"?

IMO the strength of XML here is that it provides one, almost obvious,
format for gui description. And with Python, I can imagine hundreds of
them :) (but maybe there are real gems, and after finding one I'll be
very happy?)

[Georg Brandl]

Gregory Petrosyan wrote:

Buenos dias, amigos!
I have to write _simple_ gui library, for embedding into game. My
first attempt was to use XML: isn't it cute to describe ui in such a
way:

<window>
<title>Hello World!</title>
<image text="nice picture here" pos=... src=... />
<text opts=...>
(some text here)
</text>
<list>
<item>first element</item>
<item>second one...</item>
</list>
<button action=... text="Click Me!" />
</window>

One could imagine to model this with Python, like this:

class FooDlg(Window):
title = "Hello World!"
size = (400, 300)

class WelcomeImg(Imag e):
filename = "..."
pos = (0, 0)

class Box(Frame):
text = "My Controls"

class NameLbl(Label):
text = "Name:"

class NameField(TextB ox):
length = 100
pos = ...
def onClick(self):
MessageBox(self .text)

class TestList(ListBo x):
items = ['First', 'Second']

_Slight_ misuse of "class" though...

Georg

[Gregory Petrosyan]

Nice, thanks!
BTW, maybe decorators could do good job here (something like @expose in
TG?)

[James Stroud]

Ivan Voras wrote:

Gregory Petrosyan wrote:

But after reading "Python Is Not Java"
http://dirtsimple.org/2004/12/python-is-not-java.html (BTW I'm not a
Java programmer) I realised that it is actually not cute at all :) (am
I wrong here?)

Don't do that :)

Don't listen to recommendations for or against a technology based only
on vague "this is not how we do things around here" reasons.

The reasons given in the blog were fairly precise. I think "only on
vague[...]" is misleading here. The idea of the article was to educate a
Java user how to change his or her frame of reference to better use Python.

The author was not being territorial as you are implying.

[Paul Boddie]

Gregory Petrosyan wrote:

Thanks for your reply.
But isn't python code more flexible than XML? I think it's not harder
to edit py file than xml file.

It's all about integration with tools, and while there are various
situations where avoiding tools is often better than extensive use of
tools (Python vs. Java-plus-Eclipse being an example that springs to my
mind, at least), there are some very good tools for certain kinds of
GUI design; it's better in such situations to make use of those tools
rather than eschew them in favour of something "Pythonic" but, in
various respects, less usable.

Once upon a time, it may have been the case that GUI design tools
(typically for forms-based applications) only produced program code - I
think SpecTcl, for example, was admired for its capabilities but
criticised for its Tcl-centric nature, ultimately forcing many to look
elsewhere despite variants such as SpecPython - but most design tools
now seem to produce some kind of XML description of widgets and
dialogues. How usable to other languages would Glade or Qt Designer be
if they respectively produced just C and C++ code? (Actually, unlike
Tcl, consuming C or C++ produced from the same tools would be an
annoyance in itself, I'd imagine.)

Paul

[Gregory Petrosyan]

I need format, specialised for manual editing.
(And in this case a) I don't want/need to develop/find GUI forms
editors etc; b) maybe python is better for manual work? XML is pretty
nice for machines, but what about human mind: what is closer to it?)

Anyway, thanks for your help & attention.

[Bruno Desthuilliers]

Gregory Petrosyan a écrit :

Buenos dias, amigos!
I have to write _simple_ gui library, for embedding into game. My
first attempt was to use XML: isn't it cute to describe ui in such a
way:

<window>
<title>Hello World!</title>
<image text="nice picture here" pos=... src=... />
<text opts=...>
(some text here)
</text>
<list>
<item>first element</item>
<item>second one...</item>
</list>
<button action=... text="Click Me!" />
</window>

(or something similar)

But after reading "Python Is Not Java"
http://dirtsimple.org/2004/12/python-is-not-java.html (BTW I'm not a
Java programmer) I realised that it is actually not cute at all :) (am
I wrong here?)
Well, XML is a bit on the verbose side (but less than Java, which is why
Javaers love XML), and we usually have better ways to express things in
Python. But this doesn't mean that you shouldn't use it when appropriate.
I am currently seeking for pythonic alternative for XML.
A pretty obvious one is dicts and lists. What about (Q&D):

window = {
'title' : 'Hello World!'
'image' : {'text' :"nice picture here",
'pos' : ...,
'src' : .. },
'text_opts' : """
(some text here)
""",
'items' : [
'first-element',
'second-one',
...
]
'button' : {
'action': ...
'text' :"Click Me!"
},
}
well... It sure needs more work, but you get the idea...
One possible
way is to create a class for every (type of?) window, like
(snip ugly code)
Isn't it ugly a bit?
I'd even say 'ugly 16-bits' !-)
These styles of course can be combined... But IMHO looks not very nice
:( Maybe I shall not rely on introspection?
Why not ?
Any suggestions, comments,
thoughts and links are welcome.

You may want to have a look at JSON. It's 'JavaScript Object Notation' -
but Python and javascript are close enough, so the translation process
is a no-brainer - and it's used as a replacement for XML in most
Pythonic AJAX implementations . One of the potential plus of JSON (vs
more python-specific solutions) is that it's language-independant.

Else, there was a quite interesting configuration module by Vinay Sajip
that could fit your needs:

http://www.red-dove.com/python_config.html
http://www.red-dove.com/config/

(BTW, is this module still maintained ?)

[DH]

Bruno Desthuilliers wrote:

I am currently seeking for pythonic alternative for XML.

A pretty obvious one is dicts and lists. What about (Q&D):

That's like JSON: http://www.json.org/example.html