[Gd-hackers] gtk interface: shorten identifiers, ... ?

[Danny Milosavljevic]

Hi,

I wonder how to modify the gtk interface in
svn://anonsvn.gwydiondylan.org/scm/svn/dylan/trunk/duim/platform/gtk+/gtk2
to make an example like this possible:

module: hello-world
use-libraries: dylan, common-dylan, io, gtk-2
use-modules: common-dylan, streams, standard-io, format-out, gtk

define method hello(widget :: <widget>)
  format-out("Hello, World, %=!\n", widget);
  force-output(*standard-output*);
  let dialog = make(<message-dialog>, get-parent(widget),
                           #"destroy-with-parent",
                           #"warning",
                           #"yes-no",
                           "foo!");
  dialog.response.connect(method(widget, data)
                       format-out("Response event occurred: %= got %=\n",
                                   widget, data);
                       force-output(*standard-output*);
                       destroy(widget);
                   end method);
  show(dialog);
end method hello;

define method delete-event(widget :: <widget>, event :: <gdk-event>)
  => (deny-deletion? :: <boolean>)
  format-out("Delete event occurred: %= got %=\n", widget, event);
  force-output(*standard-output*);
  #t
end method delete-event;

define method destroy-event(widget :: <widget>) => ()
  format-out("Destroy event occurred: %=\n", widget);
  force-output(*standard-output*);
  gtk-main-quit()
end method destroy-event;

begin
  gtk-init(application-name(), application-arguments());

  let window = make(<window>, #"toplevel");
  g-signal-connect(window, "delete_event", delete-event);
  g-signal-connect(window, "destroy", destroy-event);
  set-border-width(window, 10);

  let button = make(<button>, label: "Hello, world!");
  button.clicked.connect(hello);
/*
  g-signal-connect(button, "clicked", method(#rest args) 
                                           destroy(window);
                                       end method);
*/
  add(window, button);

  show(button);
  show(window);

  gtk-main();
end;

That is,
1) use short identifiers for "object methods"
2) use symbols for flags
3) add actual slots for signals (so that it isn't so easy to specify
non-existant signals)
4) add support for "make(<window>" etc

For 1), I started to look into adding a "name-mapper:
g-object-strip-object-prefix" to melange. However, I'm not sure at what
phase the name mapping is done. (If it were done too early, obviously the
gtk wrapper code itself wouldn't find its own functions)

For 2), I have no idea... that would be some kind of flag mapper :)

Hmm...

cheers,
  Danny (newbie)