wxruby64 2.0.1-x64-mingw32

data/samples/grid/grid.rb

@@ -0,0 +1,198 @@
+#!/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'
+
+class GridFrame < Wx::Frame
+
+  def initialize(parent, id = -1, title = "MyFrame", 
+                  pos   = Wx::DEFAULT_POSITION,
+                  size  = Wx::DEFAULT_SIZE,
+                  style = Wx::DEFAULT_FRAME_STYLE)
+
+    super(parent, id, title, pos, size, style)
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    create_status_bar()
+    set_status_text(Wx::VERSION_STRING)
+
+    # panel = Wx::Panel.new(self)
+    sel_menu = Wx::Menu.new
+    sel_menu.append(1002, 'Select all', 'Select all')
+    evt_menu(1002) { @grid.select_all }
+    sel_menu.append(1003, 'Select row 2', 'Select row 2')
+    evt_menu(1003) { @grid.select_row(1) }
+    sel_menu.append(1004, 'Select column 4', 'Select col 4')
+    evt_menu(1004) { @grid.select_col(3) }
+    sel_menu.append(1005, 'Select block', 'Select block')
+    evt_menu(1005) { @grid.select_block(1, 1, 6, 3) }
+    menu_bar = Wx::MenuBar.new
+    menu_bar.append(sel_menu, 'Select')
+    set_menu_bar(menu_bar)
+
+    make_grid(self)
+    sizer.add(@grid, 1, Wx::ALL|Wx::GROW, 4)
+    set_sizer(sizer)
+
+    evt_grid_cell_left_click() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} is clicked")
+      evt.skip
+    end 
+
+    evt_grid_cell_right_click() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} is right clicked")
+      evt.skip
+    end 
+
+    evt_grid_cell_left_dclick() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} is double clicked")
+      evt.skip
+    end 
+
+    evt_grid_cell_right_dclick() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} is right double clicked")
+      evt.skip
+    end 
+
+    evt_grid_label_left_click() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} label is clicked")
+      evt.skip
+    end 
+
+    evt_grid_label_right_click() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} label is right clicked")
+      evt.skip
+    end 
+
+    evt_grid_label_left_dclick() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} labelis double clicked")
+      evt.skip
+    end 
+
+    evt_grid_label_right_dclick() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} label is right double clicked")
+      evt.skip
+    end 
+
+    evt_grid_select_cell() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} cell is selected")
+      evt.skip
+    end
+    
+    evt_grid_row_size do |evt|
+      set_status_text("Row #{evt.get_row_or_col} size changed")
+      evt.skip
+    end
+
+    evt_grid_col_size do |evt|
+      set_status_text("Column #{evt.get_row_or_col} size changed")
+      evt.skip
+    end
+
+    evt_grid_editor_shown do |evt|
+      set_status_text("Begin editing")
+      evt.skip
+    end
+
+    evt_grid_editor_hidden do |evt|
+      set_status_text("End editing")
+      evt.skip
+    end
+
+    evt_grid_range_select do |evt|
+      top = evt.get_top_left_coords
+      bottom = evt.get_bottom_right_coords
+      set_status_text("[ #{top[0].to_s} x #{top[1].to_s} ] to [ #{bottom[0].to_s} x #{bottom[1].to_s} ] is selected")
+    end 
+
+    evt_grid_editor_created do |evt|
+      set_status_text("Control #{evt.get_control} created")
+      evt.skip
+    end
+
+    evt_grid_cell_change() do |evt|
+      set_status_text("Cell #{evt.get_row} x #{evt.get_col} has changed")
+    end
+  end
+
+  # Create a wxGrid object
+  def make_grid(panel)
+    @grid = Wx::Grid.new(panel, -1)
+
+    # Then we call CreateGrid to set the dimensions of the grid
+    # (11 rows and 12 columns in this example)
+    @grid.create_grid( 20, 12 )
+    @grid.set_default_cell_background_colour(Wx::WHITE)
+    # We can set the sizes of individual rows and columns
+    # in pixels, and the label value string
+    @grid.set_row_size( 0, 60 )
+    @grid.set_row_label_value( 0, "Row1" )
+    @grid.set_row_label_alignment(Wx::ALIGN_CENTRE, Wx::ALIGN_CENTRE)
+    
+    @grid.set_col_size( 0, 120 )
+    @grid.set_col_label_value( 0, "Col1" )
+    @grid.set_col_label_alignment(Wx::ALIGN_CENTRE, Wx::ALIGN_CENTRE)
+    
+    # And set grid cell contents as strings
+    @grid.set_cell_value( 0, 0, "wxGrid is good" )
+
+    # We can specify that some cells are read-only
+    @grid.set_cell_value( 0, 2, "Read-only" )
+    @grid.set_read_only( 0, 2 )
+
+    # Colours can be specified for grid cell contents
+    @grid.set_cell_value(1, 1, "white on red")
+    @grid.set_cell_text_colour(1, 1, Wx::WHITE)
+    @grid.set_cell_background_colour(1, 1, Wx::RED)
+
+    # We can specify the some cells will store numeric 
+    # values rather than strings. Here we set grid column 6 
+    # to hold floating point values displayed with width 
+    # of 2 and precision of 2. The column is highlighted in light grey
+    cell_attr = Wx::GridCellAttr.new
+    cell_attr.set_background_colour( Wx::LIGHT_GREY )
+    cell_attr.set_renderer( Wx::GridCellFloatRenderer.new(2, 2) )
+
+    @grid.set_col_attr(5, cell_attr)
+    @grid.set_cell_value(0, 5, "3.1415")
+    @grid.set_cell_value(0, 6, 
+                         "The whole column to the left uses float format")
+    
+    # Custom Editors Can be used
+    editor = Wx::GridCellNumberEditor.new(5, 20)
+    @grid.set_cell_value(3, 1, 'Number editor below')
+    @grid.set_cell_editor(4, 1, editor)
+
+    editor = Wx::GridCellFloatEditor.new(4, 2)
+    @grid.set_cell_value(3, 2, 'Float editor below')
+    @grid.set_cell_editor(4, 2, editor)
+
+    editor = Wx::GridCellChoiceEditor.new(['foo', 'bar', 'baz'])
+    @grid.set_cell_value(3, 3, 'Choice editor below')
+    @grid.set_cell_editor(4, 3, editor)
+
+    @grid.auto_size_row(3, true)
+
+    # Display of cells can be customised
+    @grid.set_cell_editor(6, 0, Wx::GridCellBoolEditor.new)
+    @grid.set_cell_renderer(6, 0, Wx::GridCellBoolRenderer.new)
+    @grid.set_cell_value(6, 1, 'Cell to the left displayed as boolean')
+  end
+  
+end
+
+class GridApp < Wx::App
+  def on_init
+    frame = GridFrame.new(nil, -1, "Grid Sample",
+                         Wx::Point.new(10, 100),
+                         Wx::Size.new(630,400))
+
+    set_top_window(frame)
+    frame.show()
+  end
+end
+
+GridApp.new.main_loop()

data/samples/grid/gridtablebase.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2009 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+# GridTableBase is an alternative way to provide data to a Wx::Grid. A
+# subclass of Wx::GridTableBase is created which is reqiured to provide
+# methods to report the total size of the Grid in rows and columns, and
+# the contents and style of individual cells.
+# 
+# Then, when creating the Grid, instead of calling create_grid and
+# set_value to populate it, the GridTableBase-derived class is
+# associated with the Grid, and provides these functions (see below)
+# 
+# This approach is typically useful for dealing with very large sets of
+# data, as each cell's value is only requested as it becomes visible.v
+class MyGridTable < Wx::GridTableBase
+  attr_reader :cols, :rows
+  def initialize(rows, cols)
+    super()
+    @rows = rows
+    @cols = cols
+    @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
+    @rows
+  end
+
+  # ... and columns
+  def get_number_cols
+    @cols
+  end
+
+  # Most importantly, it should be able to return any given cell's
+  # contents, given its row and column reference
+  def get_value(row, col)
+    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)
+    attr = Wx::GridCellAttr.new
+    if (row % 2).zero?
+      attr.text_colour = Wx::RED
+    end
+    attr
+  end
+
+  # It should indicate whether any given cell is empty
+  def is_empty_cell(row, col)
+    false
+  end
+
+  # It may also provide labels for the columns and rows
+  def get_col_label_value(col)
+    COLS[col]
+  end
+
+  # If the Grid is to support write as well as read operations,
+  # set_value should also be implemented. In this case, the change is
+  # merely echoed back and doesn't alter the underlying value; a real
+  # implementation could, for example, write back to a database
+  def set_value(x, y, val)
+    puts "Changing the value of cell (#{x}, #{y}) to '#{val}'"
+  end
+end
+
+class GridFrame < Wx::Frame
+  def initialize()
+    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)
+
+    # 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)
+
+    # Add some buttons that can change the contents
+    butt_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+
+    butt_1 = Wx::Button.new(self, :label => "Add row")
+    # 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 = 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 = MyGridTable.new( @grid.table.rows, 
+                                     @grid.table.cols + 1)
+      @grid.refresh
+    end
+    butt_sizer.add(butt_2)
+
+    main_sizer.add(butt_sizer, 0, Wx::EXPAND|Wx::ALL, 5)
+    self.sizer = main_sizer
+  end
+end
+
+Wx::App.run do 
+  GridFrame.new.show
+end
+

data/samples/html/html.rb

@@ -0,0 +1,262 @@
+#!/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'
+
+require 'net/http'
+require 'uri'
+
+class MyHtmlWindow < Wx::HtmlWindow
+  attr_reader :html_src
+  def initialize(*args)
+    super
+    evt_html_link_clicked self, :on_link_clicked
+    evt_html_cell_hover self, :on_hover
+  end
+
+  def load_page_from_uri(uri)
+    case uri
+    when URI::HTTP
+      Wx::BusyCursor.busy do
+        begin
+          res = Net::HTTP.start(uri.host, uri.port) do | http |
+            http.get(uri.path)
+          end
+          @loaded_uri = uri
+          set_page(res.body)
+        rescue => err
+          msg = "Could not load page:\n#{err}"
+          Wx::MessageDialog.new(nil, msg, 'Error loading page', 
+                                 Wx::OK|Wx::ICON_ERROR).show_modal
+          return ''
+        end
+      end
+      return @loaded_uri
+    when URI::Generic
+      if @loaded_uri and @loaded_uri.kind_of?(URI::HTTP)
+        return load_page_from_uri( @loaded_uri.merge(uri) )
+      elsif @loaded_uri # current viewing a file
+        if uri.to_s =~ /^\//
+          return load_file(uri.path)
+        elsif not uri.path.empty?
+          local_file = File.join( File.dirname(@loaded_uri.path), uri.path)
+          return load_file( local_file )
+        end
+      end
+    end
+
+    dlg = Wx::MessageDialog.new(nil, "Can't load link",
+                                 "Unable to load the link #{uri}",
+                                 Wx::ICON_ERROR)
+    dlg.show_modal
+  end
+
+  def load_file(file)
+    @loaded_uri = URI.parse("file:////" + file)
+    super file
+    @loaded_uri
+  end
+  
+  def set_page(html)
+    super html
+    @html_src = html
+    related_frame.addr_bar.value = @loaded_uri.to_s
+  end
+
+  def on_link_clicked(event)
+    href = event.link_info.href
+    return if href =~ /^#/
+    link_uri = URI.parse(href)
+    @loaded_uri = load_page_from_uri(link_uri)
+  end
+
+  def on_hover(event)
+    if link = event.cell.link
+      related_frame.set_status_text(link.href)
+    else
+      related_frame.status_text = ''
+    end
+  end
+end
+
+# The frame or self-contained window for this application
+class HtmlFrame < Wx::Frame
+  attr_reader :html_win, :addr_bar
+
+  def initialize(title, pos, size, style = Wx::DEFAULT_FRAME_STYLE)
+    # A main application frame has no parent (nil)
+    # -1 means this frame will be supplied a default id
+    super(nil, -1, title, pos, size, style)
+    setup_menus
+    setup_panel
+    create_status_bar
+    self.status_text = "Welcome to wxRuby!"
+  end
+
+  def setup_panel
+    panel = Wx::Panel.new(self, -1)
+
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    top_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+    
+    @go_butt  = Wx::StaticText.new(panel, -1, 'Location:')
+    top_sizer.add(@go_butt, 0, Wx::ALL, 4)
+    @addr_bar = Wx::TextCtrl.new(panel, -1, 'HOME', Wx::DEFAULT_POSITION,
+                                Wx::DEFAULT_SIZE, Wx::TE_READONLY)
+    top_sizer.add(@addr_bar, 1, Wx::ALL, 4)
+    sizer.add(top_sizer, 0, Wx::EXPAND|Wx::TOP|Wx::BOTTOM, 4)
+
+    @html_win = MyHtmlWindow.new(panel, -1)
+    @html_win.set_related_frame(self, 'HTML Window: %s')
+
+    @html_win.set_page(DATA.read)
+    sizer.add(@html_win, 1, Wx::ALL|Wx::GROW, 4)
+    panel.set_sizer(sizer)
+  end
+
+  def setup_menus
+    menu_file = Wx::Menu.new()
+    menu_help = Wx::Menu.new()
+    # Using Wx::ID_ABOUT default id means the menu item will be placed
+    # in the correct platform-specific place
+    menu_help.append(Wx::ID_ABOUT, "&About...\tF1", "Show about dialog")
+    menu_file.append(Wx::ID_OPEN, "&Open File...\tCtrl-O", "Open File")
+    menu_file.append(Wx::ID_HIGHEST + 1, "&Open URL...\tCtrl-U", "Open URL")
+    menu_file.append(Wx::ID_PRINT, "&Print...\tCtrl-P", "Print")
+
+    menu_file.append(Wx::ID_PREVIEW, "&Preview...\tCtrl-Shift-P", 
+                     "Print Preview")
+    menu_file.append(Wx::ID_EXIT, "E&xit\tAlt-X", "Quit this program")
+
+    menu_bar = Wx::MenuBar.new()
+    menu_bar.append(menu_file, "&File")
+    menu_bar.append(menu_help, "&Help")
+    # Assign the menus to this frame
+    self.menu_bar = menu_bar
+    # handle menu events
+    evt_menu Wx::ID_OPEN, :on_open_file
+    evt_menu Wx::ID_HIGHEST + 1, :on_open_url
+    evt_menu Wx::ID_PRINT, :on_print
+    evt_menu Wx::ID_PREVIEW, :on_preview
+    evt_menu Wx::ID_EXIT, :on_quit
+    evt_menu Wx::ID_ABOUT, :on_about
+  end
+
+  # end the application
+  def on_quit
+    close
+  end
+
+  def on_open_file
+    f_dlg = Wx::FileDialog.new(self, "Open an HTML file", "", "", 
+                                "HTML files (*.html;*.htm)|*.html;*.htm)", 
+                                Wx::OPEN)
+    if not f_dlg.show_modal == Wx::ID_OK
+      return
+    end
+    html_file = f_dlg.get_path
+    if html_file.index("\\")
+      html_file = html_file.split("\\").join("/")
+    end
+    @html_win.load_file(html_file)
+  end
+
+  def on_open_url
+    url = Wx::get_text_from_user('Enter URL to open', 'Enter URL')
+    if not url.empty?
+      uri = URI.parse(url)
+      uri.path = '/' if uri.path.empty?
+      @html_win.load_page_from_uri(uri)
+    end
+  end
+
+  # show an 'About' dialog
+  def on_about
+    msg =  sprintf("This is the About dialog of the HTML sample.\n" \
+                   "Welcome to wxRuby, version %s", Wx::WXRUBY_VERSION)
+
+    # create a simple message dialog with OK button
+    about_dlg = Wx::MessageDialog.new( self, msg, 'About WxRuby HTML',
+                                       Wx::OK|Wx::ICON_INFORMATION )
+    about_dlg.show_modal()
+	about_dlg.destroy()
+  end
+
+  def on_preview
+    print = Wx::HtmlEasyPrinting.new('Print HTML', self)
+    print.preview_text(@html_win.html_src)
+  end
+
+  def on_print
+    print = Wx::HtmlEasyPrinting.new('Print HTML', self)
+    print.print_text(@html_win.html_src)
+  end
+
+  # utility function to find an icon relative to this ruby script
+  def local_icon_file(icon_name)
+    File.join( File.dirname(__FILE__), icon_name) 
+  end
+end
+
+# Wx::App is the container class for any wxruby app - only a single
+# instance is required
+class HtmlApp < Wx::App
+  def on_init
+    frame = HtmlFrame.new("Minimal wxRuby App",
+                             Wx::Point.new(50, 50), 
+                             Wx::Size.new(450, 340))
+    set_app_name('HtmlDemo')
+    # required
+    frame.show()
+  end
+end
+
+# Create an instance ...
+app = HtmlApp.new
+# ... and run the application
+app.main_loop()
+
+__END__
+<html>
+<head>
+<title>WxRuby HTML Demo</title>
+</head>
+
+<body bgcolor="#ffffff">
+<h1>The HtmlWindow widget</h1>
+<p>This is a very simple demonstration of
+<strong>Wx::HtmlWindow</strong>, a control for displaying hypertext. The
+  control understands most HTML tags, including links, tables, images,
+  lists and the venerable FONT tag. It does not know about CSS or
+  Javascript; it is not really intended for building a general-purpose
+  web browser.</p>
+<h2>This demo</h2>
+<p>In this demo you can open local files for viewing (by choosing the
+File / Open). If you have an internet connection http:// links will be
+downloaded as well. Its features are otherwise limited - for example,
+this example doesn't know about HTML anchor targets, because it has
+over-ridden default link handling to show how to subclass and
+specialise HtmlWindow in Ruby.</a>
+<h2>Html Easy Printing</h2>
+<p>A useful feature included with WxRuby is a simple interface for
+printing HTML. You can see this in action by choosing 'Print' or
+'Preview' from the File menu.</p>
+<h3>Further information</h3>
+<p>Here's a table with some links</p>
+<table border="1">
+<tr>
+<td>WxRuby online documentation</td>
+<td><a href="http://wxruby.rubyforge.org/doc/">http://wxruby.rubyforge.org/doc/</a></td>
+</tr>
+<tr>
+<td>WxRuby Wiki</td>
+<td><a href="http://wxruby.rubyforge.org/wiki/wiki.pl">http://wxruby.rubyforge.org/wiki/wiki.pl</a></td>
+</tr>
+</table>
+
+</body>
+</html>