has anyone gotten a chance to take a look at the GUtopIa code yet?
there’s something very strange about it. something i can’t figure out. i
mean i wrote it and all, but i never explictly told it how to update the
widget when the object changes. yet it does! how? i keep coming back to
this and looking for some place in the code that does it, but i can’t
find it. very spooky.
~transami
On Tue, 2002-07-23 at 18:31, Tom Sawyer wrote:
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 
GUtopIa Example - Application Layer
Copyright (c) 2002 Thomas Sawyer, Ruby License
class FruitApp
attr_accessor :appname
attr_reader :fruitbasket, :fruit, :basketname
def initialize
@appname = ‘Fruity Fun’
@fruitbasket = FruitBasket.new
@fruit = Fruit.new
end
def pickafruit
puts “You got a #{@fruit.isa}!”
end
end
class FruitBasket
attr_accessor :name, :contains
def initialize
@name = ‘Fruit Basket’
@contains = [“None”, “Apple”, “Orange”, “Banana”]
end
end
class Fruit
attr_accessor :isa
def initialize
@isa = “None”
end
end
GUtopIa Daemon Example - Client
Copyright (c) 2002 Thomas Sawyer, Ruby License
require ‘drb’
require ‘example-app’
require ‘example-pre’
Configure interface
INTERFACE = ‘PDA’
puts “\nINTERFACE: #{INTERFACE}\n”
Make GUI App
fruitapp = FruitApp.new
DRb.start_service()
mygui = DRbObject.new(nil, ‘druby://localhost:8080’)
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
Run some tests
puts
puts "MYGUI "
p mygui
puts
puts “MYGUI WIDGETS”
mygui.widgets.each_key do |k|
puts k
end
puts
puts “THE WINDOW”
p mygui.widgets[fruitapp.appname].class.superclass
puts “name: #{fruitapp.appname}”
puts “width: #{mygui.widgets[fruitapp.appname].width}”
puts “height: #{mygui.widgets[fruitapp.appname].height}”
puts
puts “THE RADIO”
p mygui.widgets[fruitapp.fruitbasket.name].class.superclass
puts “name: #{fruitapp.fruitbasket.name}”
puts “items: #{mygui.widgets[fruitapp.fruitbasket.name].items.join(', ')}”
puts “value: #{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts
puts “TRY OUT!”
puts
puts “Current state of fruit and its widget:”
puts “fruit=#{fruitapp.fruit.isa}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Changing widget to: #{mygui.widgets[fruitapp.fruitbasket.name].value = ‘Banana’}”
puts “fruit=#{fruitapp.fruit.isa}”
puts
puts “Changing fruit to: #{fruitapp.fruit.isa = ‘Orange’}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Trigger event_change event:”
mygui.widgets[fruitapp.fruitbasket.name].event_change
puts
puts “Changing fruit to: #{fruitapp.fruit.isa = ‘Apple’}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Changing widget to: #{mygui.widgets[fruitapp.fruitbasket.name].value = ‘Banana’}”
puts “fruit=#{fruitapp.fruit.isa}”
puts
GUtopIa Example - Models
Copyright (c) 2002 Thomas Sawyer, Ruby License
require ‘gutopia’
module MyModels
def MyModels.pick_model(gui, which)
case which
when ‘PC’
return MyModels.pc_model(gui)
when ‘PDA’
return MyModels.pda_model(gui)
end
end
private
PC model using serial notatation (slower)
def MyModels.pc_model(gui)
Proc.new {
# RadioBox
r = gui.widgetFactory(:RadioBox, 'aradio')
# Window
w = gui.widgetFactory(:Window, 'awindow')
w.width = 640
w.height = 400
w.grid = [ [ r ] ]
}
end
PDA model using parallel notation (faster)
def MyModels.pda_model(gui)
Proc.new {
# RadioBox
r = gui.widgetFactory(:RadioBox, 'aradio')
# Window
w = gui.widgetFactory(:Window, 'awindow',
:width => 320,
:height => 240,
:grid => [ [ r ] ]
)
}
end
end # MyModels
GUtopIa Daemon Example - Client
Copyright (c) 2002 Thomas Sawyer, Ruby License
require ‘romp/romp’
require ‘example-app’
require ‘example-pre’
Configure interface
INTERFACE = ‘PDA’
puts “\nINTERFACE: #{INTERFACE}\n”
Make GUI App
fruitapp = FruitApp.new
client = ROMP::Client.new(‘tcpromp://localhost:8080’)
mygui = client.resolve(‘gutopia-romp’)
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
Run some tests
puts
puts "MYGUI "
p mygui
puts
puts “MYGUI WIDGETS”
mygui.widgets.each_key do |k|
puts k
end
puts
puts “THE WINDOW”
p mygui.widgets[fruitapp.appname].class.superclass
puts “name: #{fruitapp.appname}”
puts “width: #{mygui.widgets[fruitapp.appname].width}”
puts “height: #{mygui.widgets[fruitapp.appname].height}”
puts
puts “THE RADIO”
p mygui.widgets[fruitapp.fruitbasket.name].class.superclass
puts “name: #{fruitapp.fruitbasket.name}”
puts “items: #{mygui.widgets[fruitapp.fruitbasket.name].items.join(', ')}”
puts “value: #{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts
puts “TRY OUT!”
puts
puts “Current state of fruit and its widget:”
puts “fruit=#{fruitapp.fruit.isa}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Changing widget to: #{mygui.widgets[fruitapp.fruitbasket.name].value = ‘Banana’}”
puts “fruit=#{fruitapp.fruit.isa}”
puts
puts “Changing fruit to: #{fruitapp.fruit.isa = ‘Orange’}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Trigger event_change event:”
mygui.widgets[fruitapp.fruitbasket.name].event_change
puts
puts “Changing fruit to: #{fruitapp.fruit.isa = ‘Apple’}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Changing widget to: #{mygui.widgets[fruitapp.fruitbasket.name].value = ‘Banana’}”
puts “fruit=#{fruitapp.fruit.isa}”
puts
GUtopIa Example - Presentation
Copyright (c) 2002 Thomas Sawyer, Ruby License
require ‘gutopia’
require ‘example-app’
require ‘example-pre’
Configure interface
INTERFACE = ‘PDA’
puts “\nINTERFACE: #{INTERFACE}\n”
Make GUI App
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
Run some tests
puts
puts "MYGUI "
p mygui
puts
puts “MYGUI WIDGETS”
mygui.widgets.each_key do |k|
puts k
end
puts
puts “THE WINDOW”
p mygui.widgets[fruitapp.appname].class.superclass
puts “name: #{fruitapp.appname}”
puts “width: #{mygui.widgets[fruitapp.appname].width}”
puts “height: #{mygui.widgets[fruitapp.appname].height}”
puts
puts “THE RADIO”
p mygui.widgets[fruitapp.fruitbasket.name].class.superclass
puts “name: #{fruitapp.fruitbasket.name}”
puts “items: #{mygui.widgets[fruitapp.fruitbasket.name].items.join(', ')}”
puts “value: #{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts
puts “TRY OUT!”
puts
puts “Current state of fruit and its widget:”
puts “fruit=#{fruitapp.fruit.isa}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Changing widget to: #{mygui.widgets[fruitapp.fruitbasket.name].value = ‘Banana’}”
puts “fruit=#{fruitapp.fruit.isa}”
puts
puts “Changing fruit to: #{fruitapp.fruit.isa = ‘Orange’}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Trigger event_change event:”
mygui.widgets[fruitapp.fruitbasket.name].event_change
puts
puts “Changing fruit to: #{fruitapp.fruit.isa = ‘Apple’}”
puts “widget=#{mygui.widgets[fruitapp.fruitbasket.name].value}”
puts
puts “Changing widget to: #{mygui.widgets[fruitapp.fruitbasket.name].value = ‘Banana’}”
puts “fruit=#{fruitapp.fruit.isa}”
puts
GUtopIa - ROMP Daemon
Copyright (c) 2002 Thomas Sawyer, Ruby License
require ‘drb’
require ‘gutopia’
gutopia_drb = GUtopIa::GUI.new(‘DRb’)
DRb.start_service(‘druby://localhost:8080’, gutopia_drb)
DRb.thread.join
GUtopIa - ROMP Daemon
Copyright (c) 2002 Thomas Sawyer, Ruby License
require ‘romp/romp’
require ‘gutopia’
gutopiad = GUtopIa::GUI.new(‘Romp’)
server = ROMP::Server.new(‘tcpromp://localhost:8080’, nil, true)
server.bind(gutopiad, ‘gutopia-romp’)
server.thread.join
GUtopIa API
Copyright (c)2002 Thomas Sawyer, Ruby License
module GUtopIa
Returns a GUIFactory object
class GUI
attr_reader :name, :widgets
def initialize(name)
@name = name
#
@widgets = {}
@names = {}
@bindings = {}
@transactions = []
end
# Method used to prefab GUI
def transaction(bindings={}, names={}, &model)
@names = names
@bindings = bindings
@transactions << Proc.new {
#commit
#begin
model.call #(self)
#commit
#rescue ScriptError
#rollback
#rescue StandardError
#rollback
#end
}
end
# Method used to build GUI
# This runs the all pending transactions
def build
@transactions.each do |transaction|
transaction.call(@bindings)
end
@transactions.clear # all done with those
end
# Widget Factory
# Returns a new widget object of specialized widget class
def widgetFactory(widget, name, attributes={})
# a widget string name will work too
widget = widget.intern if widget.is_a?(String)
# makes an anoynomous class as subclass of desired widget
widgetClass = Class.new(GUtopIa.const_get(widget))
# specialize class via bindings
if @bindings[@names[name] || name]
@bindings[@names[name] || name].each do |k, v|
widgetClass.class_eval {
define_method(k, v)
}
end
end
w = widgetClass.new(attributes)
w.name = @names[name] || name
@widgets[w.name] = w
return w
end
#
def alert(msg)
puts msg
end
#
def stop
puts "stopping...#{@name}"
exit
end
# Useful Class Methods?
def GUI.screen_realestate
# { :height => , :width => , :depth => }
end
end # GUI
Widgets
ToDo: add a whole bunch more super widgets
attributes require validation
class Widget
attr_accessor :name
end
class Window < Widget
attr_accessor :height, :width, :colordepth, :flags
attr_accessor :caption, :icon, :background, :grid
def initialize(attributes={})
@height = attributes[:height] ? attributes[:height] : 200
@width = attributes[:width] ? attributes[:width] : 200
@colordepth = attributes[:colordepth] ? attributes[:colordepth] : 16
@flags = attributes[:flags] ? attributes[:flags] : 0
@caption = attributes[:caption] ? attributes[:caption] : nil
@icon = attributes[:icon] ? attributes[:icon] : nil
@background = attributes[:background] ? attributes[:background] : nil
@grid = attributes[:grid] ? attributes[:grid] : []
#
super()
end
def show
puts "showing window....#{@caption}"
end
def hide
puts "hiding window...#{@caption}"
end
end # Window
class Panel < Widget
attr_accessor :height, :width
attr_accessor :background, :grid
def initialize(attributes={})
@height = attributes[:height] ? attributes[:height] : 200
@width = attributes[:width] ? attributes[:width] : 200
@background = attributes[:background] ? attributes[:background] : nil
@grid = attributes[:grid] ? attributes[:grid] : []
#
super()
end
end # Panel
class Label < Widget
attr_accessor :text
def initialize(attributes={})
@text = attributes[:text] ? attributes[:text] : nil
#
super()
end
end # Label
class TextField < Widget
attr_accessor :text, :value
def initialize(attributes={})
@text = attributes[:text] ? attributes[:text] : nil
@value = attributes[:value] ? attributes[:value] : nil
#
super()
end
end # TextField
class TextArea < Widget
attr_accessor :text, :value, :cols, :lines
def initialize(attributes={})
@text = attributes[:text] ? attributes[:text] : nil
@value = attributes[:value] ? attributes[:value] : nil
@cols = attributes[:cols] ? attributes[:cols] : nil
@lines = attributes[:lines] ? attributes[:lines] : nil
#
super()
end
end # TextArea
class Button < Widget
attr_accessor :text
attr_accessor :event_pressed
def initialize(attributes={})
@text = attributes[:text] ? attributes[:text] : nil
# events
@event_pressed = attributes[:event_pressed] ? attributes[:event_pressed] : nil
#
super()
end
end # Button
class RadioBox < Widget
attr_accessor :value, :items
attr_accessor :event_change
def initialize(attributes={})
@value = attributes[:value] ? attributes[:value] : nil
@items = attributes[:content] ? attributes[:content] : nil
# events
@event_change = attributes[:event_change] ? attributes[:event_change] : nil
#
super()
end
end # RadioBox
class MenuBar < Widget
attr_accessor :items
def initialize(attributes={})
@items = attributes[:items] ? attributes[:items] : nil
#
super()
end
end # MenuBar
class Menu < Widget
attr_accessor :text, :items
def initialize(attributes={})
@text = attributes[:text] ? attributes[:text] : nil
@items = attributes[:items] ? attributes[:items] : nil
#
super()
end
end # Menu
class MenuItem < Widget
attr_accessor :text
attr_accessor :event_selected
def initialize(attributes={})
@text = attributes[:text] ? attributes[:text] : nil
# events
@event_selected = attributes[:event_selected] ? attributes[:event_selected] : nil
#
super()
end
end # MenuItem
end # GUtopIa
GUtopIa Example - Presentation
Copyright (c) 2002 Thomas Sawyer, Ruby License
require ‘gutopia’
app = GUtopIa::GUI.new(‘My Application’)
here you must refer to widgets with app.widgets[‘widget’s name’]
bindings = {
‘quit’ => {
:event_selected => Proc.new {
app.stop
}
},
‘about’ => {
:event_selected => Proc.new {
app.widgets[‘aboutWindow’].show
}
},
‘submit’ => {
:event_pressed => Proc.new {
app.alert(“And the fruit is…#{app.widgets[‘favoriteFruit’].text}”)
app.widgets[‘mainWindow’].hide
app.stop
}
},
‘clear’ => {
:event_pressed => Proc.new {
app.widgets[‘favoriteFruit’].text = nil
}
},
‘close’ => {
:event_pressed => Proc.new {
app.widgets[‘aboutWindow’].hide
}
}
}
here you can refer to widgets with local name
or the app.widgets[‘widget’s name’]
app.transaction(bindings) {
quit = app.widgetFactory(:MenuItem, ‘quit’,
:text => ‘Quit’
)
about = app.widgetFactory(:MenuItem, ‘about’,
:text => ‘About’
)
file = app.widgetFactory(:Menu, ‘file’,
:text => ‘File’,
:items => [ app.widgets[‘quit’] ]
)
help = app.widgetFactory(:Menu, ‘help’,
:text => ‘Help’,
:items => [ about ]
)
menu = app.widgetFactory(:MenuBar, ‘menu’,
:items => [ file, help ]
)
firstName = app.widgetFactory(:TextField, ‘firstName’,
:label => ‘First Name’,
:label_position => :left
)
lastName = app.widgetFactory(:TextField, ‘lastName’,
:label => ‘Last Name’,
:label_position => :left
)
favoriteFruit = app.widgetFactory(:TextArea, ‘favoriteFruit’,
:text => ‘Banana’,
:cols => 5,
:lines => 4,
:readonly => false,
:label => ‘Favorite Fruit’,
:label_position => :top
)
submit = app.widgetFactory(:Button, ‘submit’,
:text => ‘Update’,
:image => ‘check.png’
)
clear = app.widgetFactory(:Button, ‘clear’,
:text => ‘Clear’
)
fruit_panel = app.widgetFactory(:Panel, ‘fruit_panel’,
:grid => [ [ firstName ],
[ lastName ],
[ favoriteFruit ],
[ submit ],
[ clear ] ]
)
mainWindow = app.widgetFactory(:Window, ‘mainWindow’,
:caption => ‘My Cool Window’,
:icon => ‘myIcon.ico’,
:grid => [ [ menu ],
[ fruit_panel ] ]
)
aboutLbl = app.widgetFactory(:Label, ‘aboutLbl’,
:text => <<-DATA
This is a very cool application
that I created using the GUtopIa
GUI API.
DATA
)
close = app.widgetFactory(:Button, ‘close’,
:text => ‘Close’
)
aboutWindow = app.widgetFactory(:Window, ‘aboutWindow’,
:caption => ‘About My Cool App’,
:grid => [ [ aboutLbl ],
[ close ] ]
)
}
app.build
puts
puts “select about from menu”
app.widgets[‘about’].event_selected
puts “click on close”
app.widgets[‘close’].event_pressed
puts “click on submit”
app.widgets[‘submit’].event_pressed
puts
–
~transami