wxruby 1.9.9-x86-mswin32-60 → 1.9.10-x86-mswin32-60

data/samples/dialogs/dialogs.rb

@@ -38,6 +38,7 @@ DIALOGS_PROGRESS = 22
 DIALOGS_BUSYINFO = 23
 DIALOGS_FIND = 24
 DIALOGS_REPLACE = 25
+DIALOGS_PREFS = 26
 
 $my_canvas = nil
 
@@ -125,6 +126,71 @@ class MyModelessDialog < Dialog
   end
 end
 
+# PropertySheetDialog is specialised for doing preferences dialogs; it
+# contains a BookCtrl of some sort
+class MyPrefsDialog < Wx::PropertySheetDialog
+  def initialize(parent)
+    # Using Book type other than Notebook needs two-step construction
+    super()
+    self.sheet_style = Wx::PROPSHEET_BUTTONTOOLBOOK
+    self.sheet_outer_border = 1
+    self.sheet_inner_border = 2
+    img_list = Wx::ImageList.new(32, 32)
+    img_list << std_bitmap(Wx::ART_NORMAL_FILE)
+    img_list << std_bitmap(Wx::ART_CDROM)
+    img_list << std_bitmap(Wx::ART_REPORT_VIEW)
+
+    create(parent, -1, "Preferences")
+    create_buttons(Wx::ID_OK|Wx::ID_CANCEL)
+    book_ctrl.image_list = img_list
+    book_ctrl.add_page(file_panel(book_ctrl), "File", false, 0)
+    book_ctrl.add_page(cdrom_panel(book_ctrl), "CD ROM", false, 1)
+
+    layout_dialog
+  end
+
+  # Gets one of the rather ugly standard bitmaps from ArtProvider
+  def std_bitmap(art_id)
+    Wx::ArtProvider.bitmap(art_id, Wx::ART_TOOLBAR, [32, 32])
+  end
+
+  def file_panel(book)
+    panel = Wx::Panel.new(book)
+    panel.sizer = Wx::VBoxSizer.new
+
+    cb1 = Wx::CheckBox.new(panel, :label => 'Show hidden files')
+    panel.sizer.add(cb1, 0, Wx::ALL, 5)
+
+    cb2 = Wx::CheckBox.new(panel, :label => 'Always show extensions')
+    panel.sizer.add(cb2, 0, Wx::ALL, 5)
+
+    cb3 = Wx::CheckBox.new(panel, :label => 'Show icons')
+    panel.sizer.add(cb3, 0, Wx::ALL, 5)
+
+    cb4 = Wx::CheckBox.new(panel, :label => 'Show owner')
+    panel.sizer.add(cb4, 0, Wx::ALL, 5)
+
+    st = Wx::StaticText.new(panel, :label => "Sort by:")
+    panel.sizer.add(st, 0, Wx::ALL, 5)
+
+    cb1 = Wx::Choice.new(panel, :choices => %w|Name Created Modified Size|)
+    panel.sizer.add(cb1, 0, Wx::ALL, 5)
+    panel
+  end
+
+  def cdrom_panel(book)
+    panel = Wx::Panel.new(book)
+    panel.sizer = Wx::VBoxSizer.new
+
+    choices = [ 'Show files', 'Play media', 'Run CD', 'Do nothing' ]
+    rb = Wx::RadioBox.new( panel, 
+                           :label => 'When opening CD',
+                           :choices => choices,
+                           :major_dimension => 1)
+    panel.sizer.add(rb, 0, Wx::GROW|Wx::ALL, 5)
+    panel
+  end
+end
 
 class MyCanvas < ScrolledWindow
   def initialize(parent)
@@ -185,6 +251,7 @@ class MyFrame < Frame
     evt_menu(DIALOGS_TIP) {|event| on_show_tip(event) }
     evt_menu(DIALOGS_PROGRESS) {|event| on_show_progress(event) }
     evt_menu(DIALOGS_BUSYINFO) {|event| on_show_busy_info(event) }
+    evt_menu(DIALOGS_PREFS) {|event| on_show_prefs(event) }
     evt_menu(DIALOGS_FIND) {|event| on_show_find_dialog(event) }
     evt_menu(DIALOGS_REPLACE) {|event| on_show_replace_dialog(event) }
     evt_find(-1) {|event| on_find_dialog(event) }
@@ -521,6 +588,11 @@ class MyFrame < Frame
   end
 
 
+  def on_show_prefs(event)
+    dialog = MyPrefsDialog.new(self)
+    dialog.show_modal
+  end
+
   def on_show_progress(event)
 
     dialog = ProgressDialog.new("Progress dialog example",
@@ -697,8 +769,10 @@ class MyApp < App
     file_menu.append(DIALOGS_DIR_CHOOSE,  "&Choose a directory\tCtrl-D")
     file_menu.append(DIALOGS_PROGRESS, "Pro&gress dialog\tCtrl-G")
     file_menu.append(DIALOGS_BUSYINFO, "&Busy info dialog\tCtrl-B")
+    file_menu.append(DIALOGS_PREFS, "Propert&y sheet dialog\tCtrl-Y")
     file_menu.append(DIALOGS_FIND, "&Find dialog\tCtrl-F", "", ITEM_CHECK)
     file_menu.append(DIALOGS_REPLACE, "Find and &replace dialog\tShift-Ctrl-F", "", ITEM_CHECK)
+
     file_menu.append_separator()
     file_menu.append(DIALOGS_MODAL, "Mo&dal dialog\tCtrl-W")
     file_menu.append(DIALOGS_MODELESS, "Modeless &dialog\tCtrl-Z", "", ITEM_CHECK)

data/samples/etc/toolbar_sizer_additem.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+
+require 'rubygems' rescue LoadError
+
+require 'wx'
+
+# Simple test application for keyword arguments to Sizer#add_item and
+# ToolBar#add_item. Originally contributed by Chauk-Mean P
+
+Wx::App.run do
+  frame = Wx::Frame.new( nil, 
+                         :title => 'ToolBar and Sizer API enhancements') do
+    
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    
+    button1 = Wx::Button.new(self, :label => 'Button 1')
+    button2 = Wx::Button.new(self, :label => 'Button 2')
+    button3 = Wx::Button.new(self, :label => 'Button 3')
+
+    # Sizer#add_item usage
+    # use of positional arguments
+    sizer.add_item(button1, -1, 1, Wx::EXPAND)
+    # use of a spacer
+    sizer.add_item([20, 15])
+    # use of keyword arguments without index
+    sizer.add_item(button3, :proportion => 1, :flag => Wx::EXPAND)
+    # use of keyword arguments with index specified
+    sizer.add_item(button2, :index => 1, :proportion => 1, :flag => Wx::EXPAND)
+    self.sizer = sizer
+
+    # ToolBar#add_item usage
+    toolbar = create_tool_bar( Wx::TB_HORIZONTAL|Wx::TB_FLAT )
+    # provide only a bitmap
+    new_item_id = toolbar.add_item( Wx::ArtProvider.bitmap(Wx::ART_NEW) )
+    # use of keyword arguments without pos
+    save_item_id = toolbar.add_item( Wx::ArtProvider.bitmap(Wx::ART_FILE_SAVE), 
+                                     :short_help => "Save")
+    # use of keyword arguments with pos
+    open_item_id = toolbar.add_item( Wx::ArtProvider.bitmap(Wx::ART_FILE_OPEN), 
+                                     :position => 1, 
+                                     :short_help => "Open")
+    toolbar.realize
+    
+    # tool item event handling
+    evt_tool new_item_id do
+      Wx::message_box "New clicked"
+    end
+    
+  end
+
+  frame.show
+end
+

data/samples/event/update_ui_event.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+# Demonstrating the use of evt_update_ui to keep menu items and controls
+# in sync in being enabled/disabled, checked/unchecked.
+# 
+# evt_update_ui is called repeatedly whenever the item is (or is about
+# to become) visible; by calling methods on the passed event object, the
+# state of the control is updated. For complex applications, this can be
+# a lot simpler (less code, more reliable) than having to remember to
+# update all the relevant controls and items whenever the state changes.
+#
+# In the example below, the application is globally in edit mode. This
+# mode can be changed either from a menu item, or via a
+# checkbox. Whichever is used to change, the state of the other should
+# be kept in sync
+class UpdateUIFrame < Wx::Frame
+  def initialize
+    super(nil, :title => 'Update UI example', :size => [ 400, 300 ])
+    @edit_mode = false
+
+    # First, set up the menus
+    self.menu_bar = Wx::MenuBar.new
+    menu_edit = Wx::Menu.new
+
+    # Toggle case-change menu item
+    menu_edit.append_check_item(Wx::ID_EDIT, 'Allow case change')
+    # When the item is called, toggle edit mode
+    evt_menu(Wx::ID_EDIT) { @edit_mode = ! @edit_mode }
+    # Give the menu item a check or not, depending on mode
+    evt_update_ui(Wx::ID_EDIT) { | evt | evt.check(@edit_mode) }
+
+    # Upcase menu item
+    up_case = menu_edit.append('Upper case')
+    evt_menu(up_case) { @txt.value = @txt.value.upcase }
+    evt_update_ui(up_case) { | evt | evt.enable(@edit_mode) }
+
+    # Lowercase menu item
+    up_case = menu_edit.append('Lower case')
+    evt_menu(up_case) { @txt.value = @txt.value.downcase }
+    evt_update_ui(up_case) { | evt | evt.enable(@edit_mode) }
+
+    menu_bar.append(menu_edit, "&Edit")
+
+    # Second, the frame contents
+    self.sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+
+    # A text control
+    @txt = Wx::TextCtrl.new( self, 
+                             :value => 'Welcome to wxRuby',
+                             :style => Wx::TE_MULTILINE )
+    sizer.add(@txt, 1, Wx::GROW|Wx::ALL, 5)
+
+    # A checkbox, use the Wx::ID_EDIT id to share evt code with the
+    # corresponding menu item
+    @cbx = Wx::CheckBox.new( self, 
+                             :id => Wx::ID_EDIT, 
+                             :label => 'Allow case change')
+    evt_checkbox(@cbx) { @edit_mode = ! @edit_mode }
+
+    sizer.add(@cbx, 0, Wx::RIGHT|Wx::ALL, 5)
+    sizer.layout
+  end
+end
+
+Wx::App.run { UpdateUIFrame.new.show }

data/samples/grid/gridtablebase.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# wxRuby2 Sample Code. Copyright (c) 2004-2009 wxRuby development team
 # Freely reusable code: see SAMPLES-LICENSE.TXT for details
 begin
   require 'rubygems' 
@@ -24,9 +24,12 @@ class MyGridTable < Wx::GridTableBase
     super()
     @rows = rows
     @cols = cols
-    @val = 'a'
+    @number_col = 1
   end
 
+  # Letter labels for columns
+  COLS = ('AA' .. 'ZZ').to_a
+
   # Firstly, a GridTableBase must indicate the size of the grid in
   # terms of rows ...
   def get_number_rows
@@ -41,9 +44,25 @@ class MyGridTable < Wx::GridTableBase
   # Most importantly, it should be able to return any given cell's
   # contents, given its row and column reference
   def get_value(row, col)
-    "#{@val} - #{row}"
+    if col == @number_col
+      (row * 5).to_s
+    else
+      "#{row}:#{COLS[col]}"
+    end
   end 
 
+  # This is not needed if the cell contents are simply strings. However,
+  # if you wish to use custom GridCellRenderers and/or GridCellEditors,
+  # this should return a type name which has the correct renderer /
+  # editor defined for it in the Grid, using register_
+  def get_type_name(row, col)
+    if col == @number_col
+      "NUMBER"
+    else
+      "STRING"
+    end
+  end
+
   # It should also return the attributes that should apply to any given
   # cell; this example give alternate rows red text letters
   def get_attr(row, col, attr_kind)
@@ -61,7 +80,7 @@ class MyGridTable < Wx::GridTableBase
 
   # It may also provide labels for the columns and rows
   def get_col_label_value(col)
-    "Col: #{col}"
+    COLS[col]
   end
 
   # If the Grid is to support write as well as read operations,
@@ -73,23 +92,27 @@ class MyGridTable < Wx::GridTableBase
   end
 end
 
-# A derivative class illustrating that it is possible to change
-# parameters of the GridTable and have the main control update.
-class MyMutableGridTable < MyGridTable
-  def increment_value
-    @val = @val.succ
-  end
-end
-
-
 class GridFrame < Wx::Frame
   def initialize()
-    super(nil, :title => 'GridTableBase demo')
-    main_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    super(nil, :title => 'GridTableBase demo', :size => [600, 300])
+    main_sizer = Wx::VBoxSizer.new
     # Create a grid and associate an instance of the GridTable as the
     # data provider for the grid
     @grid = Wx::Grid.new(self)
-    @grid.table = MyMutableGridTable.new(10, 10)
+
+    # Define the renderers and editors used by the different data types
+    # displayed in this Grid. The type of a given cell is determined by
+    # calling the source's get_type_name method; see above.
+    @grid.register_data_type( "STRING", 
+                              Wx::GridCellStringRenderer.new,
+                              Wx::GridCellTextEditor.new )
+    @grid.register_data_type( "NUMBER", 
+                              Wx::GridCellNumberRenderer.new,
+                              Wx::GridCellNumberEditor.new(0, 500) )
+
+    # Set the data source
+    @grid.table = MyGridTable.new(10, 10)
+    
 
     main_sizer.add(@grid, 1, Wx::EXPAND|Wx::ALL, 5)
 
@@ -100,29 +123,20 @@ class GridFrame < Wx::Frame
     # When resizing the grid to have a new number of rows or columns,
     # need to allocate a new grid table source
     evt_button(butt_1) do
-      @grid.table = MyMutableGridTable.new( @grid.table.rows + 1, 
-                                            @grid.table.cols)
+      @grid.table = MyGridTable.new( @grid.table.rows + 1, 
+                                     @grid.table.cols)
       @grid.refresh
     end
     butt_sizer.add(butt_1)
 
     butt_2 = Wx::Button.new(self, :label => "Add column")
     evt_button(butt_2) do
-      @grid.table = MyMutableGridTable.new( @grid.table.rows, 
-                                            @grid.table.cols + 1)
+      @grid.table = MyGridTable.new( @grid.table.rows, 
+                                     @grid.table.cols + 1)
       @grid.refresh
     end
     butt_sizer.add(butt_2)
 
-    # For other changes, can just change a value in the existing
-    # GridTable
-    butt_3 = Wx::Button.new(self, :label => "Increment letter")
-    evt_button(butt_3) do
-      @grid.table.increment_value
-      @grid.refresh
-    end
-    butt_sizer.add(butt_3)
-    
     main_sizer.add(butt_sizer, 0, Wx::EXPAND|Wx::ALL, 5)
     self.sizer = main_sizer
   end

data/samples/mdi/mdi.rb

@@ -7,14 +7,22 @@ rescue LoadError
 end
 require 'wx'
 
-# Simple MDI-based parent frame with menus to create, cycle through and
-# close child frames within in.
+# Demonstrates a simple MDI (Multiple Document Interface) parent frame
+# with menus to create, cycle through and close child frames within in.
 #
-# NB: MDI is only properly implemented on Windows, and is simulated by
-# using a Notebook on Linux and OS X. Therefore its use is not
-# recommended for cross-platform applications. An alternative interface
-# strategy may be to use separate frames, or possibly the AUI classes.
-class MyFrame < Wx::MDIParentFrame
+# Note that MDI is only properly natively implemented on Windows, and
+# even there it is deprecated by Microsoft as an application interface
+# style.
+#
+# On Linux/GTK, Wx simulates an MDI by using a Notebook. On OS X, MDI is
+# simulated simply by ordinary separate frames, and Next/Preview and
+# Tile/Cascade are unimplemented.
+# 
+# For these reasons, MDI is not recommended for cross-platform
+# development. Alternative interface strategies include using separate
+# frames, or the AUI classes.
+
+class MDIFrame < Wx::MDIParentFrame
   def initialize(title)
     super(nil, :title => title, :size => [ 500, 400 ] )
     
@@ -63,15 +71,15 @@ class MyFrame < Wx::MDIParentFrame
   def create_child
     @child_number += 1
     name = "Child #{@child_number.to_s}"
-    Wx::MDIChildFrame.new(self, -1, name)
+    child = Wx::MDIChildFrame.new(self, :title => name)
+    # Note that this is required on OS X; if no child frames are shown,
+    # then nothing is shown at all.
+    child.show 
   end
 end
 
-class MDIApp < Wx::App
-  def on_init
-    frame = MyFrame.new("MDI App")
-	frame.show
-  end
+Wx::App.run do
+  MDIFrame.new("MDI Application").show # may return false on OS X
+  true
 end
 
-MDIApp.new.main_loop

data/samples/minimal/minimal.rb

@@ -18,10 +18,10 @@ class MinimalFrame < Wx::Frame
     # The main application frame has no parent (nil)
     super(nil, :title => title, :size => [ 400, 300 ])
 
-    # PNG can be used on all platforms, but icon type must be specified
-    # to work on Windows. Note that OS X doesn't have "Frame" icons. 
+    # Give the frame an icon. PNG is a good choice of format for
+    # cross-platform images. Note that OS X doesn't have "Frame" icons.
     icon_file = File.join( File.dirname(__FILE__), "mondrian.png")
-    self.icon = Wx::Icon.new(icon_file, Wx::BITMAP_TYPE_PNG)
+    self.icon = Wx::Icon.new(icon_file)
 
     menu_bar = Wx::MenuBar.new
     # The "file" menu

data/samples/text/rich_textctrl.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+
+# RichTextCtrl sample by Chauk-Mean P 
+#
+# RichTextCtrl is a sophisticated styled text editing component. This
+# short sample shows the basics, but RichTextCtrl supports numerous
+# other text characteristics (font, size, colour, super/subscript), as
+# well as paragraph alignment and spacing, and bullets. It permits named
+# text styles to be created and organised in stylesheets. It can output
+# to HTML and XML, and facilities are provided for printing.
+#
+# Icons are taken from the Tango Icon Theme.
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+require 'wx'
+
+class RichTextFrame < Wx::Frame
+
+  def initialize
+    super( nil, :title => "RichTextCtrl sample", :size => [800, 600] )
+
+    toolbar = create_tool_bar( Wx::TB_HORIZONTAL|Wx::NO_BORDER| 
+                               Wx::TB_FLAT|Wx::TB_TEXT )
+    toolbar.tool_bitmap_size = [ 32, 32 ]
+
+    bold_bmp = bmp_from_png("format-text-bold.png")
+    toolbar.add_check_tool( Wx::ID_BOLD, "Bold", 
+                            bold_bmp, bold_bmp, "Apply bold")
+
+    italic_bmp = bmp_from_png("format-text-italic.png")
+    toolbar.add_check_tool( Wx::ID_ITALIC, "Italic",
+                            italic_bmp, italic_bmp, "Apply italic")
+                            
+    underline_bmp = bmp_from_png("format-text-underline.png")
+    toolbar.add_check_tool( Wx::ID_UNDERLINE, "Underline",
+                            underline_bmp, underline_bmp, "Apply underline")
+    toolbar.realize
+
+    editor = Wx::RichTextCtrl.new(self, :style => Wx::WANTS_CHARS)
+    editor.begin_font_size(18)
+
+    editor.begin_bold
+    editor.write_text "Simple RichTextCtrl sample"
+    editor.end_bold
+    editor.newline
+    editor.begin_italic
+    editor.write_text "Use the formatting buttons then type some text or "
+    editor.write_text "select some text and use the buttons to apply the formatting.\n"
+    editor.end_italic
+
+    # Apply / unapply bold to selection
+    evt_tool(Wx::ID_BOLD) do
+      editor.apply_bold_to_selection
+    end
+
+    # Keep the pressed / unpressed state of the button in sync with the
+    # current selection in the text ctrl
+    evt_update_ui(Wx::ID_BOLD) do |evt|
+      evt.check(editor.selection_bold?)
+    end
+
+    evt_tool(Wx::ID_ITALIC) do
+      editor.apply_italic_to_selection
+    end
+
+    evt_update_ui(Wx::ID_ITALIC) do |evt|
+      evt.check(editor.selection_italics?)
+    end
+
+    evt_tool(Wx::ID_UNDERLINE) do
+      editor.apply_underline_to_selection
+    end
+
+    evt_update_ui(Wx::ID_UNDERLINE) do |evt|
+      evt.check(editor.selection_underlined?)
+    end
+  end
+
+  # Return a new bitmap corresponding to the specified PNG filename
+  def bmp_from_png(filename)
+    img_file = File.join( File.dirname(__FILE__), filename)
+    Wx::Bitmap.new(img_file, Wx::BITMAP_TYPE_PNG)
+  end
+end
+
+
+# The Application
+Wx::App.run do 
+  self.app_name = 'RichTextCtrl sample'
+  frame = RichTextFrame.new
+  frame.centre
+  frame.show
+end