wxruby3 0.9.0.pre.beta.14 → 0.9.0.pre.rc.2

data/lib/wx/doc/memory_dc.rb

@@ -0,0 +1,75 @@
+
+module Wx
+
+  class MemoryDC < Wx::DC
+
+    # Creates a Memory DC and passes that to the given block to draw on.
+    # Automatically unselects any source object of the MemoryDC after the block finishes.
+    # @overload self.draw_on()
+    #   @yieldparam [Wx::MemoryDC] dc
+    # @overload self.draw_on(bitmap)
+    #   @param [Wx::Bitmap]
+    #   @yieldparam [Wx::MemoryDC] dc
+    # @overload self.draw_on(dc)
+    #   @param [Wx::DC]
+    #   @yieldparam [Wx::MemoryDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class BufferedDC < Wx::MemoryDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # @overload self.draw_on()
+    #   Creates a buffer for the provided dc.
+    #   @yieldparam [Wx::BufferedDC] dc
+    # @overload self.draw_on(tgt, area, style=Wx::BUFFER_CLIENT_AREA)
+    #   Creates a buffer for the provided dc. #init must not be called when using this constructor.
+    #   @param [Wx::DC] tgt The underlying DC: everything drawn to this object will be flushed to this DC when this object is destroyed. You may pass nil in order to just initialize the buffer, and not flush it.
+    #   @param [Wx::Size] area The size of the bitmap to be used for buffering (this bitmap is created internally when it is not given explicitly).
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedDC] dc
+    # @overload self.draw_on(tgt, buffer=Wx::NULL_BITMAP, style=Wx::BUFFER_CLIENT_AREA)
+    #   Creates a buffer for the provided dc. #init must not be called when using this constructor.
+    #   @param [Wx::DC] tgt The underlying DC: everything drawn to this object will be flushed to this DC when this object is destroyed. You may pass nil in order to just initialize the buffer, and not flush it.
+    #   @param [Wx::Bitmap] buffer Explicitly provided bitmap to be used for buffering: this is the most efficient solution as the bitmap doesn't have to be recreated each time but it also requires more memory as the bitmap is never freed. The bitmap should have appropriate size, anything drawn outside of its bounds is clipped.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class BufferedPaintDC < Wx::BufferedDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # As with Wx::BufferedDC, you may either provide the bitmap to be used for buffering or let this object create one internally (in the latter case, the size of the client part of the window is used).
+    #
+    # Pass W::xBUFFER_CLIENT_AREA for the style parameter to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    # @overload self.draw_on(win, style=Wx::BUFFER_CLIENT_AREA)
+    #   @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedPaintDC] dc
+    # @overload self.draw_on(win, buffer=Wx::NULL_BITMAP, style=Wx::BUFFER_CLIENT_AREA)
+    #   @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    #   @param [Wx::Bitmap] buffer Explicitly provided bitmap to be used for buffering: this is the most efficient solution as the bitmap doesn't have to be recreated each time but it also requires more memory as the bitmap is never freed. The bitmap should have appropriate size, anything drawn outside of its bounds is clipped.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedPaintDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class AutoBufferedPaintDC < Wx::BufferedPaintDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # Pass a pointer to the window on which you wish to paint.
+    # @note In wxRuby this method mostly exists to be consistent with the other DC classes. It is however recommended to use Wx::Window#paint_buffered instead.
+    # @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    # @yieldparam [Wx::AutoBufferedPaintDC] dc
+    def self.draw_on(win, &block) end
+
+  end
+
+end

data/lib/wx/doc/mirror_dc.rb

@@ -0,0 +1,16 @@
+
+module Wx
+
+  class MirrorDC < Wx::DC
+
+    # Executes the given block providing a temporary (mirror) dc as
+    # it's single argument.
+    # @param [Wx::DC] dc DC to duplicate the (mirrored) drawing on
+    # @param [Boolean] mirror whether to mirror or not
+    # @yieldparam [Wx::MirrorDC] dc the MirrorDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(dc, mirror) end
+
+  end
+
+end

data/lib/wx/doc/pen.rb

@@ -0,0 +1,17 @@
+
+module Wx
+
+  class Pen
+
+    # Finds a pen with the specified attributes in the global list and returns it, else creates a new pen, adds it to the global pen list, and returns it.
+    # @param [Wx::Colour, String, Symbol] colour Colour of the pen.
+    # @param [Integer] width Width of the pen.
+    # @param [Wx::PenStyle] style Pen style. See {Wx::PenStyle} for a list of styles.
+    # @return [Wx::Pen]
+    def self.find_or_create_pen(colour, width=1, style=Wx::PenStyle::PENSTYLE_SOLID) end
+
+  end
+
+  ThePenList = Wx::Pen
+
+end

data/lib/wx/doc/prt/printer_dc.rb

@@ -0,0 +1,26 @@
+
+module Wx::PRT
+
+  class PrinterDC < Wx::DC
+
+    # Executes the given block providing a temporary (printer) dc as
+    # it's single argument.
+    # @param [Wx::PRT::PrintData] print_data print_data defining the print settings
+    # @yieldparam [Wx::PrinterDC] dc the PrinterDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(win) end
+
+  end
+
+  class PostScriptDC < Wx::DC
+
+    # Executes the given block providing a temporary (postscript) dc as
+    # it's single argument.
+    # @param [Wx::PRT::PrintData] print_data print_data defining the print settings
+    # @yieldparam [Wx::PostScriptDC] dc the PostScriptDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(win) end
+
+  end
+
+end

data/lib/wx/doc/radio_box.rb

@@ -0,0 +1,20 @@
+
+class Wx::RadioBox
+
+  # Enables od disables individual buttons.
+  # true if the item has been enabled or disabled or false if nothing was done because it already was in the requested state.
+  # @see Wx::Window#enable
+  # @param item [Integer]  The zero-based position of the button to enable or disable.
+  # @param enable [true,false]  true to enable, false to disable.
+  # @return [true,false]
+  def enable_item(item, enable=true) end
+
+  # Shows or hides individual buttons.
+  # true if the item has been shown or hidden or false if nothing was done because it already was in the requested state.
+  # @see Wx::Window#show
+  # @param item [Integer]  The zero-based position of the button to show or hide.
+  # @param show [true,false]  true to show, false to hide.
+  # @return [true,false]
+  def show_item(item, show=true) end
+
+end

data/lib/wx/doc/screen_dc.rb

@@ -1,10 +1,14 @@
 
-class Wx::ScreenDC
+module Wx
 
-  # Executes the given block providing a temporary (screen) dc as
-  # it's single argument.
-  # @yieldparam [Wx::ScreenDC] dc the ScreenDC instance to paint on
-  # @return [Object] result of the block
-  def self.paint; end
+  class ScreenDC < Wx::DC
+
+    # Executes the given block providing a temporary (screen) dc as
+    # it's single argument.
+    # @yieldparam [Wx::ScreenDC] dc the ScreenDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on; end
+
+  end
 
 end

data/lib/wx/doc/svg_file_dc.rb

@@ -0,0 +1,20 @@
+
+module Wx
+
+  class SVGFileDC < Wx::DC
+
+    # Executes the given block providing a temporary dc as it's single argument.
+    # Initializes a wxSVGFileDC with the given filename, width and height at dpi resolution, and an optional title.
+    # The title provides a readable name for the SVG document.
+    # @param [String] filename name of file to create
+    # @param [Integer] width width for SVG image
+    # @param [Integer] height height for SVG image
+    # @param [Float] dpi resolution for SVG image
+    # @param [String] title readable name for the SVG document
+    # @yieldparam [Wx::SVGFileDC] dc the SVGFileDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(filename, width=320, height=240, dpi=72, title='') end
+
+  end
+
+end

data/lib/wx/doc/v_list_box.rb

@@ -0,0 +1,9 @@
+
+class Wx::VListBox
+
+  # Iterate selected items. Returns Enumerator if no block given.
+  # @yieldparam [Integer] sel selected item index
+  # @return [Enumerator,Object] if block given returns last return value of block, Enumerator otherwise
+  def each_selected; end
+
+end

data/lib/wx/doc/window.rb

@@ -15,4 +15,31 @@ class Wx::Window
   # @return [Object] result from block
   def paint_buffered; end
 
+  # Locks the window from updates while executing the given block.
+  # @param [Proc] block
+  def locked(&block); end
+
+  # Find the first child window with the given id recursively in the window hierarchy of this window.
+  #
+  # Window with the given id or nil if not found.
+  # @see Wx::Window.find_window_by_id
+  # @param id [Integer]
+  # @return [Wx::Window]
+  def find_window_by_id(id) end
+
+  # Find the first child window with the given label recursively in the window hierarchy of this window.
+  #
+  # Window with the given label or nil if not found.
+  # @see Wx::Window.find_window_by_label
+  # @param label [String]
+  # @return [Wx::Window]
+  def find_window_by_label(label) end
+
+  # Find the first child window with the given name (as given in a window constructor or {Wx::Window#create} function call) recursively in the window hierarchy of this window.
+  #
+  # Window with the given name or nil if not found.
+  # @param name [String]
+  # @return [Wx::Window]
+  def find_window_by_name(name) end
+
 end

data/lib/wx/doc/window_disabler.rb

@@ -0,0 +1,10 @@
+
+class Wx::WindowDisabler
+
+  # Disables all top level windows of the application (maybe with the exception of one of them) in
+  # and enables them back after the given block has returned.
+  # @param [Wx::Window,nil] to_skip window to exclude from disabling
+  # @return [void]
+  def self.disable(to_skip = nil) end
+
+end

data/lib/wx/html/keyword_defs.rb

@@ -10,13 +10,12 @@ Wx::define_keyword_ctors(Wx::HTML::HtmlWindow) do
 end
 
 # wxHtmlListBox 	A listbox showing HTML content
-# wxListBox 	A list of strings for single or multiple selection
-Wx::define_keyword_ctors('ListBox') do
-  wx_ctor_params :id, :pos, :size, :choices => []
-  wx_ctor_params :style
-  wx_ctor_params :validator, :name => 'listBox'
+Wx::define_keyword_ctors(Wx::HTML::HtmlListBox) do
+  wx_ctor_params :id, :pos, :size, :style, :name => 'HtmlListBox'
 end
 
-Wx::define_keyword_ctors('HtmlListBox') do
-  wx_ctor_params :id, :pos, :size, :style, :name => 'HtmlListBoxNameStr'
+Wx::define_keyword_ctors(Wx::HTML::SimpleHtmlListBox) do
+  wx_ctor_params :id, :pos, :size
+  wx_ctor_params :choices => []
+  wx_ctor_params :style, :validator, :name => 'SimpleHtmlListBox'
 end

data/lib/wx/html/require.rb

@@ -6,5 +6,6 @@ require_relative './events/evt_list'
 require_relative './keyword_defs'
 require_relative './htmlwindow'
 require_relative './htmlhelpcontroller'
+require_relative './simple_html_listbox'
 
 Wx::Dialog.setup_dialog_functors(Wx::HTML)

data/lib/wx/html/simple_html_listbox.rb

@@ -0,0 +1,105 @@
+
+class Wx::HTML::SimpleHtmlListBox
+
+  # Make this a Ruby enumerable so find, find_all, map etc are available
+  include Enumerable
+
+  # Passes each valid item index into the passed block
+  def each
+    get_count.times { | i | yield i }
+  end
+
+  # We need to cache client data in Ruby variables as we cannot access items
+  # during the GC mark phase as for some platforms (WXMSW at least) that would
+  # involve calling methods that would break in that phase.
+
+  def client_data_store
+    @client_data ||= []
+  end
+  private :client_data_store
+
+  wx_set_client_data = instance_method :set_client_data
+  define_method :set_client_data do |item, data|
+    item = item.to_i
+    wx_set_client_data.bind(self).call(item, data)
+    client_data_store[item] = data
+  end
+
+  def get_client_data(item)
+    client_data_store[item.to_i]
+  end
+
+  wx_append = instance_method :append
+  define_method :append do |item, data=nil|
+    if data
+      if ::Array === item
+        if !(::Array === data)
+          ::Kernel.raise ::TypeError.new("Expected Array for argument 3")
+        elsif data.size != item.size
+          ::Kernel.raise ::ArgumentError.new("item and data array must be equal size")
+        end
+        offs = get_count
+        wx_append.bind(self).call(item)
+        item.size.times { |ix| set_client_data(offs+ix, data[ix]) }
+      else
+        wx_append.bind(self).call(item, data)
+        client_data_store[get_count-1] = data
+      end
+    else
+      wx_append.bind(self).call(item)
+      # no changes to data store
+    end
+  end
+
+  wx_insert = instance_method :insert
+  define_method :insert do |item, pos, data=nil|
+    if data
+      if ::Array === item
+        if !(::Array === data)
+          ::Kernel.raise ::TypeError.new("Expected Array for argument 3")
+        elsif data.size != item.size
+          ::Kernel.raise ::ArgumentError.new("item and data array must be equal size")
+        end
+        wx_insert.bind(self).call(item, pos)
+        client_data_store.insert(pos, *::Array.new(item.size))
+        item.size.times { |ix| set_client_data(pos+ix, data[ix]) }
+      else
+        wx_insert.bind(self).call(item, pos, data)
+        client_data_store.insert(pos, data)
+      end
+    else
+      wx_insert.bind(self).call(item, pos)
+      if ::Array === item
+        client_data_store.insert(pos, *::Array.new(item.size))
+      else
+        client_data_store.insert(pos, nil)
+      end
+    end
+  end
+
+  wx_set = instance_method :set
+  define_method :set do |items, data=nil|
+    if data
+      if !(::Array === data)
+        ::Kernel.raise ::TypeError.new("Expected Array for argument 2")
+      elsif data.size != items.size
+        ::Kernel.raise ::ArgumentError.new("items and data array must be equal size")
+      end
+    end
+    wx_set.bind(self).call(items)
+    client_data_store.clear
+    items.each_with_index { |item, ix| set_client_data(item, data[ix]) }
+  end
+
+  wx_clear = instance_method :clear
+  define_method :clear do
+    wx_clear.bind(self).call
+    client_data_store.clear
+  end
+
+  wx_delete = instance_method :delete
+  define_method :delete do |item|
+    wx_delete.bind(self).call(item.to_i)
+    client_data_store.slice!(item.to_i)
+  end
+end