Re: GUI's and the Rouge, Part III (grand finally) 2/2

well, i just read over my last post. sorry about all the typos. i needed
a break and didn't bother to proofread. but i'm sure you can make out
what i was trying to say where i blurbed. okay, now to the good stuff! 

i spent the last few days hacking out the first steps in the creation of
a super-duper ruby gui api, which i have dubbed GUtopIa (thanks rich).
just to kick things off here's a small clip of one of my examples (note
MyModels is drawn from an unshown require):

  INTERFACE = 'PDA'
  fruitapp = FruitApp.new
  mygui = GUtopIa::GUI.new('Fruity Fun Time')
  names = {
    'awindow' => fruitapp.appname,
    'aradio'  => fruitapp.fruitbasket.name
  }
  bindings = {
    fruitapp.fruitbasket.name => { 
      :value        => Proc.new { fruitapp.fruit.isa },
      :value=       => Proc.new { |x| fruitapp.fruit.isa = x },
      :items        => Proc.new { fruitapp.fruitbasket.contains },
      :event_change => Proc.new { fruitapp.pickafruit }
    }
  }
  model = MyModels.pick_model(mygui, INTERFACE)
  mygui.transaction(bindings, names, &model)
  mygui.build

the idea is that you take an instance of your application (FruitApp in
this case), completely untouched --you don't have to add or change a
single line of code (unless you want too ;-) you then create a model. a
model (not shown in example) is an executable description of the fixed
aspects of your gui. it has no references to any part of your app
(although you can do so if you don't care about SOC) it is a completely
independent entity and as such can be reused in other fitting contexts.
you can also draw on multiple sub-models. then you create a binding (as
seen above). this describes how an instance of your application
"interfaces" with your model. and then presto out comes you gui-ized
app.

also note that GUtopIa uses a transaction mechinism. this effectivly
bundles an executable model into a single execution. not only does this
increase speed, but also offers a means to rollback the effects of a
transaction should there be an error, adding much greater stability to
your gui-ized application.

some other things to note: bindings are actually integrated directly
into the class models of the widgets. when a widget is created it is
subclassed into a specialized class of that widget which includes
methods to react to the bindings described.

i've attached my work thus far so you can checkout all of this in
detail. be sure to run example.rb (the snipet above) and check out
orig-example.rb, which is a non-SOC version of the original Rouge/Utopia
example. then check out gutopia.rb which is the heart of the matter.

so that's the the word on implementation. i've taken the advice of
others and i have worked out what i think is shaping up to be the best
gui api design in existence. Curt Hibbs has offered me a wiki for this
project. (thanks curt) i will take him up on it. now i hope i can get
YOU enthused enough to help. there's real potential here, to not only
create an awsome gui api for ruby that is unique and powerful, but also
create a full-fledge game sdk! this thing looks to be awesome indeed.

i need people to take on a few tasks. a ruby wrapper needs to be created
for ClanLib and we need to build a Themes and Behaviors manager. someone
needs to hack out the communications layer (i've tried it with DRb and
ROMP but they bomb). and i could use some help finishing off the main
api. if we can pull together on this, ruby, our favorite little
scripting language, will have its very own GUI to rival all others!

as you might be able to tell, i'm very excited! i hope you are too!

thanks for your time and hope to hear from you,

~transami :-)