wxruby64 2.0.1-x64-mingw32

data/samples/dialogs/tips.txt

@@ -0,0 +1,18 @@
+Startup tips are documented in the "Startup tips overview" section of wxWindows documentation.
+These tips are being read from the tips.txt text file in this directory. Each line of the file contains a single tip.
+If you close and open this tips dialog, you will notice that the tip numbers start at the point you were at when you closed the dialog last time. This allows easy cycling through the entire list of tips, instead of always showing the initial tips over and over.
+Often you will want to save to the application's wxConfig, the last tip that the user saw, as well as whether they want to see tips on startup.
+Comments in the tips file have a # as the first character. Comments are automatically skipped over. See the tips.txt file in this directory for the example.
+# This line is a comment since it started with a #, and is skipped.
+Blank lines in the tip file are also automatically skipped over. Lines with only spaces are also considered empty.
+The next line in this tip file is empty, so it will be automatically skipped.
+
+The next line in this tip file is just empty spaces, so it is considered empty too, and is also automatically skipped.
+  
+You can easily add translations to your startup tips via the usual gettext methods by wrapping a string in a gettext macro, which is _(""). See next tip for example.
+_("This tip is marked as a translatable string by wrapping it inside the usual gettext macro, so it can be collected by gettext and added to a translation catalog. Your application can then use this catalog and serve out a translated version of the tip.")
+Translatable strings must strictly begin with _(", not _( " or wxGetTranslation(" or something else.
+If you are using gettext translatable strings, don't forget to escape to replace any " characters within the tip with a \" instead
+_("This is a translatable tip with the quoted words \"Escape me\" properly escaped.")
+If you have very specialized needs, you can derive your own wxTipProvider and use that instead.
+If you want to modify the tip content at runtime for purposes other than translation (for example, variable expansion), one easy option is to use a custom tip provider derived from wxFileTipProvider. Your custom tip provider would contain a single virtual function to override: PreprocessTip().

data/samples/dragdrop/dragdrop.rb

@@ -0,0 +1,177 @@
+#!/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'
+
+# This sample demonstrates the use of the Clipboard and Drag and Drop
+# classes. Whilst the functionality of these is slightly different, they
+# are both based around the use of the DataObject classes to exchange
+# data of various sorts between applications (i.e. into and out of
+# wxRuby)
+
+# A ListBox that collects file names dropped onto it
+class FileDropList < Wx::ListBox
+  def initialize(*args)
+    super
+    # Set the handler for drag and drop actions
+    self.drop_target = ListFileDropTarget.new(self)
+  end
+
+  # The class that actually handles the dropped files; it keeps a
+  # reference to the ListBox, and appends items as they are added
+  class ListFileDropTarget < Wx::FileDropTarget
+    def initialize(list)
+      super()
+      @list = list
+    end
+
+    # This method is overridden to specify what happens when a file is
+    # dropped 
+    def on_drop_files(x, y, files)
+      files.each { | file | @list.append(file) }
+      true # currently need to return boolean from this method
+    end
+  end
+end
+
+class FileDropPane < Wx::Panel
+  LABEL = "Drag and drop files from Explorer/Finder/etc to here\n" +
+          "to add them to the list."
+  def initialize(parent)
+    super
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    txt = Wx::StaticText.new( self, :label => LABEL)
+    sizer.add(txt, 0, Wx::ALL, 4)
+
+    @drop = FileDropList.new(self)
+    sizer.add(@drop, 1, Wx::GROW|Wx::ALL, 4)
+    self.sizer = sizer
+  end
+end
+
+# A canvas which can display a pasted image
+class PasteCanvas < Wx::Window
+  attr_accessor :bitmap
+  def initialize(parent)
+    super(parent, :style => Wx::SUNKEN_BORDER)
+    self.size = [ 200, 200 ]
+    @bitmap = Wx::NULL_BITMAP
+    evt_paint :on_paint
+  end
+
+  def on_paint(evt)
+    paint do | dc  | 
+      dc.clear
+      if bitmap.ok?
+        dc.draw_bitmap(bitmap, 0, 0, false)
+      end 
+      dc.pen = Wx::BLACK_PEN
+    end
+  end
+end
+
+# A Notebook panel to hold an image-paste canvas
+class PastePane < Wx::Panel
+  LABEL = "Use the buttons below to paste text and images from\n" +
+          "the system clipboard, and then to copy them back."
+  def initialize(parent)
+    super
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    txt = Wx::StaticText.new( self, :label => LABEL)
+    sizer.add(txt, 0, Wx::ALL, 4)
+
+    # Sizer for displaying text and image from the clipboard
+    paste_sizer = Wx::FlexGridSizer.new(2, 2, 2, 2)
+    paste_sizer.add_growable_col(0, 1)
+    paste_sizer.add_growable_col(1, 1)
+    paste_sizer.add_growable_row(1)
+
+    paste_sizer.add( Wx::StaticText.new(self, :label => 'Clipboard text') )
+    paste_sizer.add( Wx::StaticText.new(self, :label => 'Clipboard image') )
+    
+    # Target for displaying text from the clipboard
+    @text = Wx::TextCtrl.new(self, :style => Wx::TE_MULTILINE)
+    paste_sizer.add(@text, 1, Wx::GROW)
+
+    # Target for displaying images from the clipboard
+    @canvas = PasteCanvas.new(self)
+    paste_sizer.add(@canvas, 1, Wx::GROW)
+    
+    sizer.add(paste_sizer, 1, Wx::ALL|Wx::GROW, 4)
+    
+    button_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+
+    @paste_bt    = Wx::Button.new(self, :label => 'Paste')
+    evt_button @paste_bt, :on_paste
+    button_sizer.add(@paste_bt, 0, Wx::ALL, 4)
+
+    @copy_img_bt = Wx::Button.new(self, :label => 'Copy image')
+    evt_button @copy_img_bt, :on_copy_image
+    button_sizer.add(@copy_img_bt, 0, Wx::ALL, 4)
+
+    @copy_txt_bt = Wx::Button.new(self, :label => 'Copy text')
+    evt_button @copy_txt_bt, :on_copy_text
+    button_sizer.add(@copy_txt_bt, 0, Wx::ALL, 4)
+
+    sizer.add(button_sizer, 0)
+    self.sizer = sizer
+  end
+
+  # Receive data from the clipboard
+  def on_paste(evt)
+    # Temporarily open the clipboard 
+    Wx::Clipboard.open do | clip |
+      # Test if bitmap data is available on the clipboard; if so, copy
+      if clip.supported?(Wx::DF_BITMAP)
+        bmp = Wx::BitmapDataObject.new
+        clip.get_data(bmp) # Fill the data object with bitmap`
+        @canvas.bitmap = bmp.bitmap
+        @canvas.refresh
+      end      
+      # Test if text data is available on the clipboard; if so, copy
+      if clip.supported?(Wx::DF_TEXT)
+        txt = Wx::TextDataObject.new
+        clip.get_data(txt) # Fill the data object with text
+        @text.value = txt.text
+      end
+    end
+  end
+
+  # Paste an image to the clipboard
+  def on_copy_image
+    Wx::Clipboard.open do | clip |
+      clip.data = Wx::BitmapDataObject.new(@canvas.bitmap)
+    end
+  end
+
+  # Paste text to the clipboard
+  def on_copy_text
+    Wx::Clipboard.open do | clip |
+      clip.data = Wx::TextDataObject.new(@text.value)
+    end
+  end
+end
+
+class DataObjectFrame < Wx::Frame
+  def initialize(parent)
+    super
+    panel = Wx::Panel.new(self)
+    panel.sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    nb = Wx::Notebook.new(panel)
+    panel.sizer.add(nb, 1, Wx::ALL|Wx::GROW, 8)
+    fd = FileDropPane.new(nb)
+    nb.add_page(fd, 'Drag and Drop')
+    cv = PastePane.new(nb)
+    nb.add_page(cv, 'Clipboard')
+    # urldrop = URLDropList.new(self)
+  end
+end
+
+Wx::App.run do 
+  frame = DataObjectFrame.new(nil)
+  frame.show
+end

data/samples/drawing/bitmap.rb

@@ -0,0 +1,49 @@
+#!/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'
+
+
+# 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')
+
+    @offset = 10
+    size = 256+2*@offset
+    self.client_size = [size, size]
+
+    # Load a PNG bitmap from a file for drawing
+    img_file = File.join( File.dirname(__FILE__)+"/../../art",
+      'wxruby-256x256.png')
+    @bitmap = Wx::Bitmap.new(img_file)
+
+    # Set up the drawing to be done when the frame needs re-painting
+    evt_paint :on_paint
+  end
+
+  def on_paint
+    paint do | dc |
+      # Draw the bitmap at the specified offset with no transparency
+      dc.draw_bitmap(@bitmap, @offset, @offset, false)
+    end
+  end
+end
+
+Wx::App.run do
+  ImageFrame.new.show
+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/graphics_drawing.rb

@@ -0,0 +1,235 @@
+#!/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 GfxInfo
+  attr_accessor :font, :w, :h, :x, :y, :x_axis, :y_axis, :txt, :rotation
+  def initialize()
+    @font = nil
+    @w = 0
+    @h = 0
+    @x = 0
+    @y = 0
+    @x_axis = 0
+    @y_axis = 0
+    @txt = ""
+    @rotation = 0
+  end
+  
+  def move(max_x,max_y,max_sp)
+    @x += @x_axis
+    @y += @y_axis
+    if @x <= 0
+      @x_axis = rand(max_sp)
+      @x = 0
+    elsif (@x+@w) >= max_x
+      @x_axis = (rand(max_sp)*-1)
+      @x = max_x - @w
+    end
+    if @y <= 0
+      @y_axis = rand(max_sp)
+      @y = 0
+    elsif (@y+@h) >= max_y
+      @y_axis = (rand(max_sp)*-1)
+      @y = max_y - @h
+    end
+  end
+  
+  def rotate(run)
+    @rotation += run
+    if @rotation > 360
+      @rotation = 0
+    end
+  end
+  
+  def draw(gdc)
+    gdc.set_font(font)
+    gdc.draw_text(txt,x,y,rotation)
+  end
+  
+  def [](symbol)
+    self.__send__(symbol,*[])
+  end
+  
+  def []=(symbol,val)
+    self.__send__((symbol.to_s + "=").to_sym,*[val])
+  end
+end
+
+
+class GraphicsWindow < Wx::Window
+  # Create Needed Brushes and Pens
+  RED_BRUSH = Wx::Brush.new
+  GREEN_BRUSH = Wx::Brush.new
+  BLUE_BRUSH = Wx::Brush.new
+  RED_PEN = Wx::Pen.new
+  GREEN_PEN = Wx::Pen.new
+  BLUE_PEN = Wx::Pen.new
+  
+  # Instance Methods to keep track of toggle for corner, rect, and counter for frames per second
+  attr_accessor :corner, :rect, :fps
+  
+  def initialize(parent)
+    super(parent)
+    # Create the font we'll use to create our pre-defined fonts for the painting
+    @font = Wx::Font.new(18,Wx::FONTFAMILY_TELETYPE,
+                        Wx::FONTSTYLE_NORMAL,Wx::FONTWEIGHT_NORMAL)
+    # Setup the actual data to be stored in Brushes and Pens
+    RED_BRUSH.set_colour(Wx::RED)
+    RED_PEN.set_colour(Wx::RED)
+    GREEN_BRUSH.set_colour(Wx::GREEN)
+    GREEN_PEN.set_colour(Wx::GREEN)
+    BLUE_BRUSH.set_colour(Wx::BLUE)
+    BLUE_PEN.set_colour(Wx::BLUE)
+    # Create our Animation Timer
+    @timer = Wx::Timer.new(self,1000)
+    @fps = 0
+    # Set it to run every 25 milliseconds, you can set this value higher, to get
+    # higher frame rates, however, it may cause non-responsiveness of normal
+    # gui controls.
+    @timer.start(25)
+    # Setup the event Handler to do the drawing on this window.
+    evt_paint :on_paint
+    evt_timer 1000, :animate
+  end
+  
+  def create_resources(gdc)
+    # Create our Resource Class for holding the Text to be displayed
+    @rtxt = GfxInfo.new()
+    @gtxt = GfxInfo.new()
+    @btxt = GfxInfo.new()
+    # Store our fonts, and strings into the classes
+    @rtxt[:font] = gdc.create_font(@font,Wx::RED); @rtxt[:txt] = "This is a red string"
+    @gtxt[:font] = gdc.create_font(@font,Wx::GREEN); @gtxt[:txt] = "This is a green string"
+    @btxt[:font] = gdc.create_font(@font,Wx::BLUE); @btxt[:txt] = "This is a blue string"
+    # Create the GraphicsContext resources.  For some reason, unable to utilize
+    # GraphicsContext#create(wxWindow) to create these resources in initialize().
+    @rbrush = gdc.create_brush(RED_BRUSH)
+    @gbrush = gdc.create_brush(GREEN_BRUSH)
+    @bbrush = gdc.create_brush(BLUE_BRUSH)
+    @rpen = gdc.create_pen(RED_PEN)
+    @gpen = gdc.create_pen(GREEN_PEN)
+    @bpen = gdc.create_pen(BLUE_PEN)
+  end
+  
+  def get_extents(gdc)
+    # Since we need a GDC and the text to get the extents, we do this in a
+    # separate method, though we should be able to do it with create_resources()
+    width,height,*garbage = gdc.get_text_extent(@rtxt[:txt])
+    @rtxt[:w] = width.to_i; @rtxt[:h] = height.to_i
+    width,height,*garbage = gdc.get_text_extent(@gtxt[:txt])
+    @gtxt[:w] = width.to_i; @gtxt[:h] = height.to_i
+    width,height,*garbage = gdc.get_text_extent(@btxt[:txt])
+    @btxt[:w] = width.to_i; @btxt[:h] = height.to_i
+  end
+  
+  def setup_positions()
+    # Setup our initial positions for drawing.
+    @rtxt[:x] = @rtxt[:y] = 0
+    size = self.get_client_size()
+    pos_x = (size.width / 2) #- (@gtxt[:w] / 2)
+    pos_y = (size.height / 2) #- (@gtxt[:h] / 2)
+    @gtxt[:x] = pos_x
+    @gtxt[:y] = pos_y
+    @btxt[:x] = (size.width - @btxt[:w])
+    @btxt[:y] = (size.height - @btxt[:h])
+  end
+  
+  def animate()
+    # This routine manily animates the Text, which is also is handled by the
+    # GfxInfo class as well.  Mainly in #rotate and #move.
+    rect = self.get_client_size()
+    @rtxt.move(rect.width,rect.height,8) unless @rtxt.nil?
+    @gtxt.rotate(-0.01) unless @gtxt.nil?
+    @btxt.move(rect.width,rect.height,5) unless @btxt.nil?
+    # We're now ready to draw our stuff to the window
+    refresh()
+  end
+  
+  def on_paint
+    # We do our drawing now
+    rect = self.get_client_size
+    paint do |dc|
+      gdc = Wx::GraphicsContext.create(dc)
+      unless !@rtxt.nil?
+        create_resources(gdc)
+      end
+
+      unless !(@rtxt[:w] == 0)
+        gdc.set_font(@rtxt[:font])
+        get_extents(gdc)
+        setup_positions()
+      end
+      @rtxt.draw(gdc)
+      @gtxt.draw(gdc)
+      @btxt.draw(gdc)
+      # Draw our rectangles, if they are checked
+      15.times do
+        pen = gdc.create_pen(Wx::Pen.new(Wx::Colour.new(rand(256),rand(256),rand(256),rand(256))))
+        if @corner.is_checked
+          x = rand(rect.width)
+          y = rand(rect.height)
+          gdc.set_pen(pen)
+          gdc.draw_rectangle(x,y,x,1)
+          gdc.draw_rectangle(x,y,1,y)
+        end
+        if @rect.is_checked
+          x = rand(rect.width)
+          y = rand(rect.height)
+          w = rand(rect.width)
+          h = rand(rect.height)
+          w + x > rect.width ? (w -= x; w -= rand(150)) : 0
+          h + y > rect.height ? (h -= y; h -= rand(150)) : 0
+          gdc.set_pen(pen)
+          gdc.draw_rectangle(x,y,w,h)
+        end
+      end
+    end
+    @fps += 1
+  end
+end
+
+class GraphicsFrame < Wx::Frame
+  def initialize()
+    super(nil,:title=>"Graphics Context example",:size=>[500,400])
+    @win = GraphicsWindow.new(self)
+
+    create_status_bar(3)
+    status_bar.set_status_text("Frames per sec: 0", 0)
+    @win.rect = Wx::CheckBox.new(status_bar,:label=>"Draw Rectangles")
+    @win.corner = Wx::CheckBox.new(status_bar,:label=>"Draw Corners")
+    
+    Wx::Timer.every(1000) { fps_display }
+    evt_size :on_size
+  end
+
+
+  # Place the two control checkboxes within the StatusBar
+  def on_size
+    rect = status_bar.field_rect(1)
+    @win.rect.move [ rect.x + 2, rect.y + 2]
+    @win.rect.size = [ rect.width - 4, rect.height - 4 ]
+
+    rect = status_bar.field_rect(2)
+    @win.corner.move [ rect.x + 2, rect.y + 2]
+    @win.corner.size = [ rect.width - 4, rect.height - 4 ]
+  end
+
+  def fps_display()
+    get_status_bar.set_status_text("Frames per sec: #{@win.fps}", 0)
+    @win.fps = 0
+  end
+end
+
+class GraphicsApp < Wx::App
+  def on_init()
+    GraphicsFrame.new.show
+  end
+end
+
+GraphicsApp.new.main_loop()