Re: [gtk-list] Glade - Suggestions

[James Dean Palmer <jpalmer agnews tamu edu>]

Mark Probst <schani@unix.cslab.tuwien.ac.at> writes:

> it should be possible to easily extend glade by providing additional
> widgets, along with a little bit of linkage code, which can be plugged
> in at run-time, i.e. by loading a shared library.

Yes, that would be a nice feature.  I like the way that Borland C++
builder is extensible in this way.

> the program using the generated interface should only need to link
> against the same shared library and the widget should work.

The translater(s) to other languages would have to be extensible to
support these new widgets as well.  But that shouldn't be a problem
with a well designed translater and a format to describe widgets for
future translation.

> [ snipped some stuff ]
> my arguments in favor of using lisp-syntax are these:
> 
>   + the syntax is clear and easy to understand. just look at 'gimprc'
>     or 'pluginrc'.

I actually do like guile/scheme, but I think that an SGML/XML style format
would be more appropriate.  If one came up with a schemeish format for
Glade it would no doubt be very reminiscent of the guile-gtk bindings
(if not directly compatible), and in my opinion such a format would be
far too implementation focused.  I think the translation from a meta
format like SGML would be easier to do a translation to a multitude of 
very different language bindings.

>   + it is easy to implement. i'd actually say, there is not even anything
>     to implement as there should be plenty of code to reuse in gimp etc.

There are also a lot of existing SGML/XML tools.  And with a good format,
the output code could also be somewhat self documenting (especially since 
a lot of SGML/XML parsers/printers already exist).

A danger in using guile-gtk directly, is that if there is a widget
feature which for some reason isn't currently supported in guile-gtk 
(or doesn't make sense for a guile binding) then the output code 
would either not be compatible (aka runable) or would have to be added
in as a comment or something else just as unelegant.

>   + gnome uses scheme as an extension language. scheme uses lisp-syntax
>     (it's a lisp dialect after all). so why not use the same syntax?

>From my own guile-gtk experience I am inclined to beleive their is a
lispish quality to the code that could be avoided by an SGML-style
format.  Avoiding a function model for a data representation model
could possibly make translation to other bindings easier (especially
class based bindings like gtk--, or other non functional bindings).
Although a translation from something like guile-gtk to gtk-- is far
from impossible, I think the translation would benefit from further
abstration.

> but, before i get a bunch of replies/flames: the first two points
> (extensibility and parameterization) are far more important to me.

No flame intended  :-)  I like scheme too, but prefer SGML for 
representing information.  And I hope that we can keep Glade (which
has the potential to be a "universal" gtk interface builder)
away from any particular binding of the gtk libraries.

--
James Dean Palmer
Crossroads Graphics Editor
Computer Engineering Undergrad @ Texas A&M
email: jpalmer@agnews.tamu.edu
www: http://agnews.tamu.edu/~jpalmer