wxruby 1.9.10-universal-darwin-9 → 2.0.0-universal-darwin-9

data/lib/wx/accessors.rb

@@ -5,16 +5,21 @@
 #  * get_position()
 #  * set_size(a_size)
 #  * is_checked()
+#  * can_undo()
+#  * has_style(a_style)
 # 
 # and so on. Methods that retrieve set, or query attributes of an object
-# are more normally in Ruby called simply by the attribute name:
+# are more normally in Ruby called simply by the attribute name, or, in
+# other cases, with a predicate method:
 #
-#  * position()
-#  * size = a_size
-#  * checked?
+#  * pos = my_widget.position
+#  * my_widget.size = a_size
+#  * my_widget.checked?
+#  * my_widget.can_undo?
+#  * my_widget.has_style?
 #
 # This extension creates an alias for every WxRuby instance method that
-# begins with +get_+, +set_+ or +is_+. Note that if you are calling a
+# begins with +get_+, +set_+, +is_+, +can_+ and +has_+. Note that if you are calling a
 # 'setter' method on self, you must explicitly send the message to self:
 # 
 #  # set's self size to be 100px by 100px
@@ -23,11 +28,18 @@
 #  size = Wx::Size.new
 
 module WxRubyStyleAccessors
+  # Ruby-style method named are implemented by method-missing; if an
+  # unknown method is called, see if it is a rubyish name for a real
+  # method. In principle it would be possible to set up real aliases for
+  # them at start-up, but in practice this is far too slow for all the
+  # classes that need to be started up.
   def method_missing(sym, *args)
     case sym.to_s
-    when /^(.*)\=$/
+    when /^(\w+)\=$/ 
       meth = "set_#{$1}"
-    when /^(.*)\?$/
+    when /^((?:has|can)\w+)\?$/
+      meth = $1
+    when /^(\w+)\?$/
       meth = "is_#{$1}"
     else
       meth = "get_#{sym}"

data/lib/wx/classes/bitmap.rb

@@ -25,6 +25,9 @@ class Wx::Bitmap
     new(img, depth)
   end
 
+  # Ruby methods that switch class are conventionally named to_foo
+  alias :to_image :convert_to_image
+
   # Redefine the initialize method so it raises an exception if a
   # non-existent file is given to the constructor; otherwise, wx Widgets
   # just carries on with an empty bitmap, which may cause faults

data/lib/wx/classes/clipboard.rb

@@ -1,8 +1,4 @@
 class Wx::Clipboard
-  # See if we like these better
-  alias :place :set_data
-  alias :fetch :get_data
-
   class << self
     # This is provided internally by the SWIG interface file, but all
     # public access should be via Clipboard.open; see below
@@ -29,4 +25,32 @@ class Wx::Clipboard
        clip.close if clip
     end
   end
+
+  # Need to do some internal record-keeping to protect data objects on
+  # the clipboard from garbage collection
+  @@__clip_data = []
+
+  # These methods affect the clipboard contents; each time, update the
+  # record with the changed data contents
+  wx_add_data = instance_method(:add_data)
+  define_method(:add_data) do | the_data |
+    @@__clip_data << the_data
+    wx_add_data.bind(self).call(the_data)
+  end
+
+  wx_clear = instance_method(:clear)
+  define_method(:clear) do 
+    @@__clip_data.clear
+    wx_clear.bind(self).call
+  end
+
+  wx_set_data = instance_method(:set_data)
+  define_method(:set_data) do | the_data |
+    @@__clip_data = [ the_data ]
+    wx_set_data.bind(self).call(the_data)
+  end
+
+  # Aliases, more clearly expressive?
+  alias :place :set_data
+  alias :fetch :get_data
 end

data/lib/wx/classes/image.rb

@@ -17,6 +17,11 @@ class Wx::Image
     bmp.convert_to_image
   end
 
+  # Ruby methods that switch class are conventionally named to_foo
+  def to_bitmap
+    Wx::Bitmap.from_image(self)
+  end
+
   # Redefine the initialize method so it raises an exception if a
   # non-existent file is given to the constructor; otherwise, wx Widgets
   # just carries on with an invalid image, which may cause faults

data/lib/wx/classes/toolbar.rb

@@ -2,20 +2,23 @@
 class Wx::ToolBar
   # Generic method to add items, supporting positional and named
   # arguments
-  ADD_ITEM_PARAMS = [ Wx::Parameter[ :position, -1 ], 
+  ADD_ITEM_PARAMS = [ 
+                      Wx::Parameter[ :bitmap2, Wx::NULL_BITMAP ],
+                      Wx::Parameter[ :position, -1 ], 
                       Wx::Parameter[ :id, -1 ],
                       Wx::Parameter[ :label, "" ], 
-                      Wx::Parameter[ :bitmap2, Wx::NULL_BITMAP ],
                       Wx::Parameter[ :kind, Wx::ITEM_NORMAL ], 
                       Wx::Parameter[ :short_help, "" ], 
                       Wx::Parameter[ :long_help, "" ], 
                       Wx::Parameter[ :client_data, nil ] ]
   
-  def add_item(bitmap, *mixed_args)
+  def add_item(bitmap1, *mixed_args)
     args = Wx::args_as_list(ADD_ITEM_PARAMS, *mixed_args)
 
+    bitmap2 = args.shift
     pos = args.shift
-    args.insert(2, bitmap)
+    args.insert(2, bitmap1)
+    args.insert(3, bitmap2)
 
     # Call add_tool to append if default position
     if pos == -1

data/lib/wx/classes/validator.rb

@@ -0,0 +1,7 @@
+class Wx::Validator
+  # Default implementation of clone, may need to be over-ridden in
+  # custom subclasses should state variables need to be copied
+  def clone
+    self.class.new
+  end
+end

data/lib/wx/keyword_defs.rb

@@ -246,8 +246,25 @@ Wx::define_keyword_ctors('FindReplaceDialog') do
   wx_ctor_params :style
 end
 
-# wxMultiChoiceDialog 	Dialog to get one or more selections from a list
-# wxSingleChoiceDialog 	Dialog to get a single selection from a list and return the string
+# Dialog to get one or more selections from a list
+Wx::define_keyword_ctors('MultiChoiceDialog') do
+  wx_ctor_params :message => ''
+  wx_ctor_params :caption => ''
+  wx_ctor_params :choices => []
+  wx_ctor_params :style => Wx::DEFAULT_DIALOG_STYLE|Wx::RESIZE_BORDER|
+                           Wx::OK|Wx::CANCEL|Wx::CENTRE
+  wx_ctor_params :pos
+end
+
+# Dialog to get a single selection from a list and return the string
+Wx::define_keyword_ctors('SingleChoiceDialog') do
+  wx_ctor_params :message => ''
+  wx_ctor_params :caption => ''
+  wx_ctor_params :choices => []
+  wx_ctor_params :style => Wx::DEFAULT_DIALOG_STYLE|Wx::RESIZE_BORDER|
+                           Wx::OK|Wx::CANCEL|Wx::CENTRE
+  wx_ctor_params :pos
+end
 
 # Dialog to get a single line of text from the user
 Wx::define_keyword_ctors('TextEntryDialog') do

data/lib/wx/version.rb

@@ -1,3 +1,3 @@
 module Wx
-  WXRUBY_VERSION    = '1.9.10'
+  WXRUBY_VERSION    = '2.0.0'
 end

data/samples/aui/aui.rb

@@ -169,37 +169,37 @@ class SettingsPanel < Wx::Panel
 
 
   def update_colours()
-    art = @frame.get_dock_art
+    art = @frame.dock_art
 
-    col = art.get_color(Wx::AUI_DOCKART_BACKGROUND_COLOUR)
-    @bckg_colour.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_BACKGROUND_COLOUR)
+    @bckg_colour.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_SASH_COLOUR)
-    @sash_colour.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_SASH_COLOUR)
+    @sash_colour.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_INACTIVE_CAPTION_COLOUR)
-    @capt_colour.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_INACTIVE_CAPTION_COLOUR)
+    @capt_colour.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR)
-    @capt_gradnt.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR)
+    @capt_gradnt.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR)
-    @capt_text.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR)
+    @capt_text.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_ACTIVE_CAPTION_COLOUR)
-    @acap_colour.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_ACTIVE_CAPTION_COLOUR)
+    @acap_colour.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR)
-    @acap_gradnt.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR)
+    @acap_gradnt.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR)
-    @acap_text.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR)
+    @acap_text.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_SASH_COLOUR)
-    @brdr_colour.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_SASH_COLOUR)
+    @brdr_colour.bitmap_label = ( create_colour_bitmap(col) )
 
-    col = art.get_color(Wx::AUI_DOCKART_GRIPPER_COLOUR)
-    @grip_colour.set_bitmap_label( create_colour_bitmap(col) )
+    col = art.colour(Wx::AUI_DOCKART_GRIPPER_COLOUR)
+    @grip_colour.bitmap_label = ( create_colour_bitmap(col) )
   end
 
   def on_pane_border_size(event)

data/samples/calendar/calendar.rb

@@ -41,7 +41,7 @@ class MyCalendar < CalendarCtrl
 
   def on_calendar_change(event)
     @date = event.date
-    log_status("Selected date: #{@date.strftime('%Y-%M-%D')}")
+    log_status("Selected date: #{@date.strftime('%A %d %B %Y')}")
   end
 
   def on_cal_month_change

data/samples/drawing/{images.rb → bitmap.rb}

@@ -11,14 +11,20 @@ require 'wx'
 # This sample demonstrates how to draw an image from a file onto a
 # window. This one uses a small PNG file, but other formats such as JPEG
 # are supported - see documentation for more details.
+# 
+# This sample uses the Wx::Bitmap class, which is a platform-specific
+# representation of an image. This is the class that must be used to
+# display an image, but see also Wx::Image, which allows a much wider
+# range of manipulations (such as rescaling) and writing to files.
+
 
 class ImageFrame < Wx::Frame
   def initialize
     super(nil, :title => 'Simple image demo')
 
     # Load a PNG bitmap from a file for drawing
-    img_file = File.join( File.dirname(__FILE__), 'paperclip.png')
-    @bitmap = Wx::Bitmap.new(img_file, Wx::BITMAP_TYPE_PNG)
+    img_file = File.join( File.dirname(__FILE__), 'wxruby-logo.png')
+    @bitmap = Wx::Bitmap.new(img_file)
 
     # Set up the drawing to be done when the frame needs re-painting
     evt_paint :on_paint
@@ -26,7 +32,8 @@ class ImageFrame < Wx::Frame
 
   def on_paint
     paint do | dc |
-      dc.draw_bitmap(@bitmap, 0, 0, false)
+      # Draw the bitmap at offset 10px, 10px, with no transparency
+      dc.draw_bitmap(@bitmap, 10, 10, false)
     end
   end
 end

data/samples/drawing/bitmap_image.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+# Bitmap sample (rewritten by Chauk-Mean Proum)
+
+# This sample demonstrates how to draw the same image in various forms
+# (original, mirrored, greyscaled and blurred).
+# 
+# This sample uses :
+# - Wx::Image, which allows a wide range of manipulations such as rescaling
+# and writing to files.
+# - Wx::Bitmap, which is a platform-specific representation of an image.
+# This is the class that must be used to actually display an image.
+
+class ImageFrame < Wx::Frame
+  def initialize
+    super(nil, :title => 'Simple image demo', :size => [600, 600])
+
+    # Create the various images from the bitmap file
+    img_file = File.join( File.dirname(__FILE__), 'ruby-logo.jpg')
+    @image = Wx::Image.new(img_file)
+    @mirrored_image = Wx::Image.new(img_file).mirror
+    @greyscaled_image = Wx::Image.new(img_file).convert_to_greyscale
+    @blurred_image = Wx::Image.new(img_file).blur(15)
+
+    # Create the corresponding bitmaps
+    compute_bitmaps
+
+    # Set up event handling
+    evt_size :on_size
+    evt_idle :on_idle
+    evt_paint :on_paint
+  end
+
+  # Create a bitmap for the specified image and size
+  def compute_bitmap image, width, height
+    rescaled_image = Wx::Image.new(image).rescale(width, height)
+    rescaled_image.to_bitmap
+  end
+
+  # Create the bitmaps corresponding to the images and with half the size of the frame
+  def compute_bitmaps
+    width = client_size.x / 2
+    height = client_size.y / 2
+    @bitmap1 = compute_bitmap(@image, width, height)
+    @bitmap2 = compute_bitmap(@mirrored_image, width, height)
+    @bitmap3 = compute_bitmap(@greyscaled_image, width, height)
+    @bitmap4 = compute_bitmap(@blurred_image, width, height)
+    @done = true
+  end
+
+  # Note to recompute the bitmaps on a resize
+  def on_size(event)
+    @done = false
+    event.skip
+  end
+
+  # Recompute the bitmaps if needed, then do a refresh
+  def on_idle
+    if not @done
+      compute_bitmaps
+      refresh
+    end
+  end
+
+  # Paint the frame with the bitmaps
+  def on_paint
+    paint do | dc |
+
+      if @done
+        width = client_size.x / 2
+        height = client_size.y / 2
+        dc.draw_bitmap(@bitmap1, 0, 0, false)
+        dc.draw_bitmap(@bitmap2, width, 0, false)
+        dc.draw_bitmap(@bitmap3, 0, height, false)
+        dc.draw_bitmap(@bitmap4, width, height, false)
+      end
+
+    end
+  end
+end
+
+Wx::App.run do
+  ImageFrame.new.show
+end
+

data/samples/drawing/maths_images.rb

@@ -0,0 +1,265 @@
+#!/usr/bin/env ruby
+
+# wxRuby2 Sample Code. Copyright (c) 2004-2009 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+
+require 'wx'
+include Wx
+include Math
+
+# This sample was originally written by Alex Fenton as an answer to Ruby
+# Quiz #191, which challenged entrants to create an application which
+# could draw images based on mathematical functions:
+#
+# http://rubyquiz.strd6.com/quizzes/191/
+#
+# To use the application, enter functions which take input values of x
+# and y from 0 to 1, and return intensities of red, green and blue. If a
+# bad function is entered, a cross is displayed; hover over this to get
+# a hint on the problem.
+#
+# The sample demonstrates some uses of the Wx::Image class, a
+# platform-independent representation of an image which can be
+# manipulated (for example, resizing) and written to files in various
+# formats. It also shows how an image's data can be written directly, by
+# using Array#pack.
+
+# A canvas that draws and displays a mathematically generated image
+class MathsDrawing < Window
+  # The functions which return the colour components at each pixel
+  attr_writer :red, :green, :blue
+  # The time taken to render, whether re-rendering is needed, and the
+  # source image
+  attr_reader :render_time, :done, :img
+  
+  def initialize(parent)
+    super(parent)
+    # Create a dummy image 
+    @default_image = Image.new(1, 1)
+    @default_image.data = [255, 255, 255].pack('CCC')
+    @img = @default_image
+
+    @red   = lambda { | x, y | 1 }
+    @green = lambda { | x, y | 1 }
+    @blue  = lambda { | x, y | 1 }
+
+    @done = true
+
+    evt_size :on_size
+    evt_paint :on_paint
+    evt_idle :on_idle
+  end
+
+  # Paint the image on the screen. The actual image rendering is done in
+  # idle time, so that the GUI is responsive whilst redrawing - eg, when
+  # resized. Painting is done by quickly rescaling the cached image.
+  def on_paint
+    paint do | dc |
+      draw_img = @img.scale(client_size.x, client_size.y)
+      dc.draw_bitmap(draw_img.convert_to_bitmap, 0, 0, true)
+    end
+  end
+
+  # Regenerate the image if needed, then do a refresh
+  def on_idle
+    if not @done
+      @img = make_image
+      refresh
+    end
+    @done = true
+  end
+
+  # Note to regenerate the image if the canvas has been resized
+  def on_size(event)
+    @done = false
+    event.skip
+  end
+
+  # Call this to force a re-render - eg if the functions have changed
+  def redraw
+    @done = false
+  end
+
+  # Actually make the image
+  def make_image
+    size_x, size_y = client_size.x, client_size.y
+    if size_x < 1 or size_y < 1
+      return @default_image
+    end
+
+    start_time = Time.now
+    # The string holding raw image data
+    data = ''
+    x_factor = size_x.to_f
+    y_factor = size_y.to_f
+
+    # Input values from the range 0 to 1, with origin in the bottom left
+    (size_y - 1).downto(0) do | y |
+      the_y = y.to_f / y_factor
+      0.upto(size_x - 1) do | x |
+        the_x = x.to_f / x_factor
+        red   = @red.call(the_x, the_y) * 255
+        green = @green.call(the_x, the_y) * 255
+        blue  = @blue.call(the_x, the_y) * 255
+        data << [red, green, blue].pack("CCC")
+      end
+    end
+    img = Image.new(size_x, size_y)
+    img.data = data
+    @render_time = Time.now - start_time
+    img
+  end
+end
+
+# A helper dialog for saving the image to a file
+class SaveImageDialog < FileDialog
+  # The image file formats on offer
+  TYPES = [ [ "PNG file (*.png)|*.png", BITMAP_TYPE_PNG ],
+            [ "TIF file (*.tif)|*.tif", BITMAP_TYPE_TIF ],
+            [ "BMP file (*.bmp)|*.bmp", BITMAP_TYPE_BMP ] ]
+  
+  WILDCARD = TYPES.map { | type | type.first }.join("|")
+  
+  def initialize(parent)
+    super(parent, :wildcard => WILDCARD,
+                  :message => 'Save Image',
+                  :style => FD_SAVE|FD_OVERWRITE_PROMPT)
+  end
+
+  # Returns the Wx identifier for the selected image type. 
+  def image_type
+    TYPES[filter_index].last
+  end
+end
+
+# A Panel for displaying the image and controls to manipulate it
+class MathsPanel < Panel
+  # Set functions to some nice initial values
+  RED_INITIAL   = "cos(x)"
+  GREEN_INITIAL = "cos(y ** x)"
+  BLUE_INITIAL  = "(x ** 4) + ( y ** 3 ) - (4.5 * x ** 2 ) + ( y * 2)"
+
+  # Symbols to show correct and incorrect functions
+  TICK  = "\xE2\x9C\x94"
+  CROSS = "\xE2\x9C\x98"
+
+  attr_reader :drawing
+
+  def initialize(parent)
+    super(parent)
+    self.sizer = VBoxSizer.new
+    # The canvas
+    @drawing = MathsDrawing.new(self) 
+    sizer.add @drawing, 1, GROW
+
+    sizer.add Wx::StaticLine.new(self)
+    
+    # The text controls for entering functions
+    grid_sz = FlexGridSizer.new(3, 8, 8)
+    grid_sz.add_growable_col(1, 1)
+
+    grid_sz.add StaticText.new(self, :label => "Red")
+    @red_tx = TextCtrl.new(self, :value => RED_INITIAL)
+    grid_sz.add @red_tx, 0, GROW
+    @red_err = StaticText.new(self, :label => TICK)
+    grid_sz.add @red_err, 0, ALIGN_CENTRE
+
+    grid_sz.add StaticText.new(self, :label => "Green")
+    @green_tx = TextCtrl.new(self, :value => GREEN_INITIAL)
+    grid_sz.add @green_tx, 0, GROW
+    @green_err = StaticText.new(self, :label => TICK)
+    grid_sz.add @green_err, 0, ALIGN_CENTRE
+
+    grid_sz.add StaticText.new(self, :label => "Blue")
+    @blue_tx = TextCtrl.new(self, :value => BLUE_INITIAL)
+    grid_sz.add @blue_tx, 0, GROW
+    @blue_err = StaticText.new(self, :label => TICK)
+    grid_sz.add @blue_err, 0, ALIGN_CENTRE
+
+    # Buttons to save and render
+    grid_sz.add nil
+    butt_sz = HBoxSizer.new
+    render_bt = Button.new(self, :label => "Render")
+    butt_sz.add render_bt, 0, Wx::RIGHT, 8
+    evt_button render_bt, :on_render
+
+    save_bt = Button.new(self, :label => "Save Image")
+    butt_sz.add save_bt, 0, Wx::RIGHT, 8
+    evt_button save_bt, :on_save
+
+    # Disable the buttons whilst redrawing
+    evt_update_ui(render_bt) { | evt | evt.enable(@drawing.done) }
+    evt_update_ui(save_bt) { | evt | evt.enable(@drawing.done) }
+    grid_sz.add butt_sz
+
+    # Add the controls sizer to the whole thing
+    sizer.add grid_sz, 0, GROW|ALL, 10
+
+    on_render
+  end
+  
+  # Update the functions that generate the image, then re-render it
+  def on_render
+    @drawing.red   = make_a_function(@red_tx.value, @red_err)
+    @drawing.green = make_a_function(@green_tx.value, @green_err)
+    @drawing.blue  = make_a_function(@blue_tx.value, @blue_err)
+    @drawing.redraw
+  end
+
+  # Display a dialog to save the image to a file
+  def on_save
+    dlg = SaveImageDialog.new(parent)
+    if dlg.show_modal == ID_OK
+      @drawing.img.save_file(dlg.path, dlg.image_type)
+    end
+  end
+
+  # A function which doesn't do anything
+  NULL_FUNC = lambda { | x, y | 1 }
+
+  # Takes a string source +source+, returns a lambda. If the string
+  # source isn't valid, flag this in the GUI static text +error_outlet+
+  def make_a_function(source, error_outlet)
+    return NULL_FUNC if source.empty?
+    func = nil
+    begin
+      # Create the function and test it, to check for wrong names
+      func = eval "lambda { | x, y | #{source} }"
+      func.call(0, 0)
+    rescue Exception => e
+      error_outlet.label = CROSS
+      error_outlet.tool_tip = e.class.name + ":\n" +
+                              e.message.sub(/^\(eval\):\d+: /, '')        
+      return NULL_FUNC
+    end
+    
+    # Things are good, note this and return the function
+    error_outlet.label = TICK
+    error_outlet.tool_tip = ''
+    func
+  end
+end
+
+class MathsFrame < Frame
+  def initialize
+    super(nil, :title => 'Maths drawing', 
+               :size => [400, 500], 
+               :pos => [50, 50])
+    sb = create_status_bar(1)
+    evt_update_ui sb, :on_update_status
+    @panel = MathsPanel.new(self)
+  end
+
+  def on_update_status
+    if @panel.drawing.done
+      pixels = @panel.drawing.client_size
+      msg = "[#{pixels.x} x #{pixels.y}] drawing completed in " +
+            "#{@panel.drawing.render_time}s"
+      status_bar.status_text = msg
+    end
+  end
+end
+
+App.run do
+  MathsFrame.new.show
+end