wxruby3 0.9.0.pre.rc.2-x64-mingw-ucrt → 0.9.0.pre.rc.3-x64-mingw-ucrt

data/lib/wx/doc/gen/wizard_event.rb

@@ -63,12 +63,19 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::WizardEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_wizard_page_changed}(id, meth = nil, &block): The page has been just changed (this event cannot be vetoed). 
+  # 
   # - {Wx::EvtHandler#evt_wizard_page_changing}(id, meth = nil, &block): The page is being changed (this event can be vetoed). 
+  # 
   # - {Wx::EvtHandler#evt_wizard_before_page_changed}(id, meth = nil, &block): Called after Next is clicked but before GetNext is called. Unlike EVT_WIZARD_CHANGING, the handler for this function can change state that might affect the return value of GetNext. This event can be vetoed. 
+  # 
   # - {Wx::EvtHandler#evt_wizard_page_shown}(id, meth = nil, &block): The page was shown and laid out (this event cannot be vetoed). 
+  # 
   # - {Wx::EvtHandler#evt_wizard_cancel}(id, meth = nil, &block): The user attempted to cancel the wizard (this event may also be vetoed). 
+  # 
   # - {Wx::EvtHandler#evt_wizard_help}(id, meth = nil, &block): The wizard help button was pressed. 
+  # 
   # - {Wx::EvtHandler#evt_wizard_finished}(id, meth = nil, &block): The wizard finished button was pressed. 
   # 
   # === 
@@ -82,11 +89,11 @@ module Wx
   
     # Constructor.
     # It is not normally used by the user code as the objects of this type are constructed by {Wx::Wizard}.
-    # @param type [Integer] 
+    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
     # @param direction [true,false] 
     # @param page [Wx::WizardPage] 
-    # @return [WizardEvent]
+    # @return [Wx::WizardEvent]
     def initialize(type=Wx::EVT_NULL, id=Wx::StandardID::ID_ANY, direction=true, page=0) end
     
     # Return the direction in which the page is changing: for EVT_WIZARD_PAGE_CHANGING, return true if we're going forward or false otherwise and for EVT_WIZARD_PAGE_CHANGED return true if we came from the previous page and false if we returned from the next one.

data/lib/wx/doc/gen/wizard_page.rb

@@ -23,7 +23,7 @@ module Wx
   class WizardPage < Panel
   
     # Default constructor.
-    # @return [WizardPage]
+    # @return [Wx::WizardPage]
     def initialize; end
     
     # Creates the wizard page.

data/lib/wx/doc/gen/wizard_page_simple.rb

@@ -19,7 +19,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
-    #   @return [WizardPageSimple]
+    #   @return [Wx::WizardPageSimple]
     # @overload initialize(parent, prev=nil, next_=nil, bitmap=(Wx::BitmapBundle.new()))
     #   Constructor takes the previous and next pages.
     #   They may be modified later by {Wx::WizardPageSimple#set_prev} or {Wx::WizardPageSimple#set_next}.
@@ -27,7 +27,7 @@ module Wx
     #   @param prev [Wx::WizardPage] 
     #   @param next_ [Wx::WizardPage] 
     #   @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
-    #   @return [WizardPageSimple]
+    #   @return [Wx::WizardPageSimple]
     def initialize(*args) end
     
     # Creates the wizard page.
@@ -42,11 +42,11 @@ module Wx
     # A helper chaining this page with the next one.
     # Notice that this method returns a reference to the next page, so the calls to it can, in turn, be chained:
     # 
-    # ```
-    #   wxWizardPageSimple* firstPage = new FirstPage;
-    #   (*firstPage).Chain(new SecondPage)
-    #               .Chain(new ThirdPage)
-    #               .Chain(new LastPage);
+    # ```ruby
+    #   firstPage = FirstPage.new # derived from Wx::WizardPageSimple
+    #   firstPage.chain(SecondPage.new)
+    #              .chain(ThirdPage.new)
+    #              .chain(LastPage.new)
     # ```
     # 
     # This makes this method the simplest way to define the order of changes in fully static wizards, i.e. in those where the order doesn't depend on the choices made by the user in the wizard pages during run-time.

data/lib/wx/doc/gen/xml_node.rb

@@ -114,12 +114,12 @@ module Wx
     #   @param name [String]  The name of the node. This is the string which appears between angular brackets.
     #   @param content [String]  The content of the node. Only meaningful when type is {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}.
     #   @param lineNo [Integer]  Number of line this node was present at in input file or -1.
-    #   @return [XmlNode]
+    #   @return [Wx::XmlNode]
     # @overload initialize(node)
     #   Copy constructor.
     #   Note that this does NOT copy siblings and parent pointer, i.e. {Wx::XmlNode#get_parent} and {Wx::XmlNode#get_next} will return NULL after using copy ctor and are never unmodified by {Wx::operator=()}. On the other hand, it DOES copy children and attributes.
     #   @param node [Wx::XmlNode] 
-    #   @return [XmlNode]
+    #   @return [Wx::XmlNode]
     def initialize(*args) end
     
     # Appends an attribute with given name and value to the list of attributes for this node.
@@ -193,7 +193,7 @@ module Wx
     alias_method :next_, :get_next
     
     # Returns the content of the first child node of type {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}.
-    # This function is very useful since the XML snippet <code>"tagnametagcontent/tagname"</code> is represented by expat with the following tag tree:
+    # This function is very useful since the XML snippet <code>"<tagname>tagcontent</tagname>"</code> is represented by expat with the following tag tree:
     # 
     # ```
     #   wxXML_ELEMENT_NODE name="tagname", content=""

data/lib/wx/doc/gen/xml_resource.rb

@@ -48,12 +48,12 @@ module Wx
     #   @param filemask [String]  The XRC file, archive file, or wildcard specification that will be used to load all resource files inside a zip archive.
     #   @param flags [Integer]  One or more value of the {Wx::XmlResourceFlags} enumeration.
     #   @param domain [String]  The name of the gettext catalog to search for translatable strings. By default all loaded catalogs will be searched. This provides a way to allow the strings to only come from a specific catalog.
-    #   @return [XmlResource]
+    #   @return [Wx::XmlResource]
     # @overload initialize(flags=Wx::XmlResourceFlags::XRC_USE_LOCALE, domain=(''))
     #   Constructor.
     #   @param flags [Integer]  One or more value of the {Wx::XmlResourceFlags} enumeration.
     #   @param domain [String]  The name of the gettext catalog to search for translatable strings. By default all loaded catalogs will be searched. This provides a way to allow the strings to only come from a specific catalog.
-    #   @return [XmlResource]
+    #   @return [Wx::XmlResource]
     def initialize(*args) end
     
     # Attaches an unknown control to the given panel/window/dialog.
@@ -104,9 +104,10 @@ module Wx
     
     # Loads resources from XML files that match given filemask.
     # Example: 
-    # ```
-    #   if (!wxXmlResource::Get()->Load("rc/*.xrc"))
-    #       wxLogError("Couldn't load resources!");
+    # ```ruby
+    #   if !Wx::XmlResource.get.load('rc/*.xrc')
+    #     Wx.log_error("Couldn't load resources!")
+    #   end
     # ```
     # 
     # If {Wx::USE_FILESYS} is enabled, this method understands {Wx::FileSystem} URLs (see Wx::FileSystem#find_first).
@@ -151,10 +152,12 @@ module Wx
     # parent points to parent window (if any).
     # This form is used to finish creation of an already existing instance (the main reason for this is that you may want to use derived class with a new event table). Example:
     # 
-    # ```
-    #   MyDialog dlg;
-    #   wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
-    #   dlg.ShowModal();
+    # ```ruby
+    #   dlg = MyDialog.new
+    #   Wx::XmlResource.get.load_dialog_subclass(dlg, main_frame, 'my_dialog')
+    #   dlg.show_modal
+    # 
+    #   dlg.destroy
     # ```
     # @param dlg [Wx::Dialog] 
     # @param parent [Wx::Window] 

data/lib/wx/doc/image.rb

@@ -11,23 +11,53 @@ module Wx
     # @return [Array<String>]
     def self.extensions; end
 
+    # Returns an array with the supported mime types of the available image handlers.
+    # @return [Array<String>]
+    def self.mime_types; end
+
     # returns a Hash with all supported extensions per available BitmapType
     # @return [Hash]
     def self.handler_extensions; end
 
-    # Searches for an art file with basename 'name' and creates an Image if found.
-    # Raises an ArgumentError if not found.
-    # Wx::ArtLocator::find_art is used to look up the art file using ::Kernel#caller_locations to
-    # determine the values for the 'art_path' and 'art_owner' arguments ('art_path' is set to the
-    # absolute path to the folder holding the caller's code and 'art_owner' to the basename of the
-    # caller's source file). The 'art_type' argument is set to <code>:icon</code>.
-    # @param [String,Symbol] name base name of art file
-    # @param [Wx::BitmapType,nil] bmp_type bitmap type for art file (nil means any supported type)
-    # @param [Integer] index  Index of the image to load in the case that the image file contains multiple images. This is only used by GIF, ICO and TIFF handlers. The default value (-1) means "choose the default image" and is interpreted as the first image (index=0) by the GIF and TIFF handler and as the largest and most colourful one by the ICO handler.
-    # @return [Wx::Image]
-    # @see Wx::ArtLocator::find_art
-    def self.Image(name, bmp_type = nil, index=-1); end
+    module Histogram
+
+      # Calculate an image histogram key from given RGB values.
+      # @param [Integer] r Red value
+      # @param [Integer] g Green value
+      # @param [Integer] b Blue value
+      # @return [Integer] key value
+      def make_key(r,g,b) end
+
+      # Find first colour that is not used in the image and has higher RGB values than RGB(r, g, b)
+      # @param [Integer] r Red value
+      # @param [Integer] g Green value
+      # @param [Integer] b Blue value
+      # @return [Array(Integer,Integer,Integer),nil] RGB values of first unused colour or nil if none found
+      def find_first_unused_colour(r=1, g=0, b=0) end
+
+    end
+
+    # Computes the histogram of the image and fills a hash table, indexed
+    # with integer keys built as 0xRRGGBB, containing pairs (Array) of integer values.
+    # For each pair the first value is the index of the first pixel in the colour in the image
+    # and the second value the number of pixels having the colour in the image.
+    # The returned Hash object is extended with the {Wx::Image::Histogram} mixin.
+    # @return [Hash] hash object extended with {Wx::Image::Histogram}
+    def compute_histogram; end
 
   end
 
+  # Searches for an art file with basename 'name' and creates an Image if found.
+  # Raises an ArgumentError if not found.
+  # Wx::ArtLocator::find_art is used to look up the art file using ::Kernel#caller_locations to
+  # determine the values for the 'art_path' and 'art_owner' arguments ('art_path' is set to the
+  # absolute path to the folder holding the caller's code and 'art_owner' to the basename of the
+  # caller's source file). The 'art_type' argument is set to <code>:icon</code>.
+  # @param [String,Symbol] name base name of art file
+  # @param [Wx::BitmapType,nil] bmp_type bitmap type for art file (nil means any supported type)
+  # @param [Integer] index  Index of the image to load in the case that the image file contains multiple images. This is only used by GIF, ICO and TIFF handlers. The default value (-1) means "choose the default image" and is interpreted as the first image (index=0) by the GIF and TIFF handler and as the largest and most colourful one by the ICO handler.
+  # @return [Wx::Image]
+  # @see Wx::ArtLocator::find_art
+  def self.Image(name, bmp_type = nil, index=-1); end
+
 end

data/lib/wx/doc/list_ctrl.rb

@@ -0,0 +1,32 @@
+
+class Wx::ListCtrl
+
+  include Enumerable
+
+  # Iterates all items in the list control passing each item (id) to the given block.
+  # @yieldparam [Integer] item
+  # @return [Object] result of last block iteration
+  def each(&block) end
+
+  # Iterates all selected items in the list control (like #get_next_item(item, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED))
+  # passing each item (id) to the given block.
+  # @yieldparam [Integer] item
+  # @return [Object] result of last block iteration
+  def each_selected(&block) end
+
+  # Returns array of selected items.
+  # @return [Array<Integer>] selected items
+  def get_selections; end
+
+  # Call this function to sort the items in the list control.
+  # The sorting method will call the given block repeatedly to compare two items from the list
+  # passing the <b>item data</b> for each item as well as the `data` argument given to the #sort_items method.
+  # The block should return 0 if the items are equal, negative value if the first item is less than the second
+  # one and positive value if the first one is greater than the second one.
+  # @param [Object] data user data to pass on to the sorting block
+  # @yieldparam [Object] item_data1 data for first item
+  # @yieldparam [Object] item_data2 data for second item
+  # @yieldparam [Object] data propagated data argument
+  def sort_items(data = nil, &block) end
+
+end

data/lib/wx/doc/log.rb

@@ -0,0 +1,28 @@
+
+module Wx
+
+  class Log
+
+    # Sets the current component for log info to the given value before executing the
+    # given block and restores the previous component value after the block returns.
+    # @param [String] comp component value for log info
+    def self.for_component(comp, &block) end
+
+  end
+
+  class LogStderr
+
+    # Creates a new LogStderr for the given file handle.
+    # Possible values are 2 for `stderr` and 1 for `stdout`.
+    # @param [Integer] fh file stream handle
+    def initialize(fh = 2) end
+  end
+
+  class LogNull
+
+    # Suspends logging before executing the given block and restarts logging when the block returns.
+    def self.no_log(&block) end
+
+  end
+
+end

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

@@ -8,7 +8,7 @@ module Wx::PRT
     # @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
+    def self.draw_on(print_data) end
 
   end
 
@@ -19,7 +19,7 @@ module Wx::PRT
     # @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
+    def self.draw_on(print_data) end
 
   end
 

data/lib/wx/doc/scaled_dc.rb

@@ -1,5 +1,5 @@
 
-class Wx
+module Wx
 
   class ScaledDC < Wx::DC
 

data/lib/wx/doc/text_validator.rb

@@ -0,0 +1,12 @@
+
+class Wx::TextValidator
+
+  # @overload initialize(validator)
+  #   Copy constructor.
+  #   @param [Wx::TextValidator] validator validator to copy
+  # @overload initialize(style=Wx::FILTER_NONE)
+  #   Constructor taking a style.
+  #   @param [Integer] style One or more of the {Wx::TextValidatorStyle} styles. See #set_style.
+  def initialize(*args) end
+
+end

data/lib/wx/version.rb

@@ -1,3 +1,3 @@
 module Wx
-  WXRUBY_VERSION    = '0.9.0-rc.2'
+  WXRUBY_VERSION    = '0.9.0-rc.3'
 end

data/tests/test_art.rb

@@ -76,6 +76,15 @@ class TestArt < Test::Unit::TestCase
     end
   end
 
+  def test_image_histogram
+    img = Wx.Image(:wxruby, Wx::BitmapType::BITMAP_TYPE_JPEG)
+    img_hist = img.compute_histogram
+    assert(img_hist.is_a?(::Hash))
+    assert(img_hist.is_a?(Wx::Image::Histogram))
+    assert(img_hist.size > 0)
+    assert(img_hist.values.all? { |index, value| index>=0 && value>=1 })
+  end
+
   def test_art
     art = nil
     assert_nothing_raised do

data/tests/test_box_sizer.rb

@@ -0,0 +1,161 @@
+
+require_relative './lib/wxframe_runner'
+
+class BoxSizerTests < WxRuby::Test::GUITests
+
+  def setup
+    super
+    @win = Wx::Window.new(test_frame, Wx::ID_ANY)
+    @sizer = Wx::HBoxSizer.new
+    @win.set_client_size(127, 35)
+    @win.sizer = @sizer
+  end
+
+  def cleanup
+    test_frame.destroy_children
+    @win = nil
+    @sizer = nil
+    super
+  end
+
+  attr_reader :win, :sizer
+
+  def test_size
+    sizeTotal = win.get_client_size
+    sizeChild = sizeTotal / 2
+
+    child = Wx::Window.new(win, Wx::ID_ANY, Wx::DEFAULT_POSITION, sizeChild)
+    sizer.add(child)
+    win.layout
+    assert(child.size == sizeChild)
+
+    sizer.clear
+    sizer.add(child, Wx::SizerFlags.new(1))
+    win.layout
+    assert(child.size == [sizeTotal.x, sizeChild.y])
+
+    sizer.clear
+    sizer.add(child, Wx::SizerFlags.new(1).expand)
+    win.layout
+    assert(child.size == sizeTotal)
+
+    sizer.clear
+    sizer.add(child, Wx::SizerFlags.new)
+    sizer.set_item_min_size(child, sizeTotal*2)
+    win.layout
+    assert(child.size == sizeTotal)
+
+    sizer.clear
+    sizer.add(child, Wx::SizerFlags.new.expand)
+    sizer.set_item_min_size(child, sizeTotal*2)
+    win.layout
+    assert(child.size == sizeTotal)
+  end
+
+  class << self
+
+    def _ltd(*args)
+      @ltd_klass ||= Struct.new(:prop, :minsize, :x, :sizes, :dont_permute) do
+        def add_to_sizer(sizer, win, n)
+          sizer.add(win, Wx::SizerFlags.new(prop[n]))
+          sizer.set_item_min_size(win, Wx::Size.new(minsize[n], -1))
+        end
+      end
+      @ltd_klass.new(*args)
+    end
+
+  end
+
+  LayoutTestData = [
+    # some really simple cases (no need to permute those, they're
+    # symmetrical anyhow)
+    _ltd( [ 1, 1, 1, ], [  50,  50,  50, ], 150, [  50,  50,  50, ], true ),
+    _ltd( [ 2, 2, 2, ], [  50,  50,  50, ], 600, [ 200, 200, 200, ], true ),
+
+    # items with different proportions and min sizes when there is enough
+    # space to lay them out
+    _ltd( [ 1, 2, 3, ], [   0,   0,   0, ], 600, [ 100, 200, 300, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ], 600, [ 100, 200, 300, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100,  50,  50, ], 600, [ 100, 200, 300, ] ),
+    _ltd( [ 0, 1, 1, ], [ 200, 100, 100, ], 600, [ 200, 200, 200, ] ),
+    _ltd( [ 0, 1, 2, ], [ 300, 100, 100, ], 600, [ 300, 100, 200, ] ),
+    _ltd( [ 0, 1, 1, ], [ 100,  50,  50, ], 300, [ 100, 100, 100, ] ),
+    _ltd( [ 0, 1, 2, ], [ 100,  50,  50, ], 400, [ 100, 100, 200, ] ),
+
+    # cases when there is not enough space to lay out the items correctly
+    # while still respecting their min sizes
+    _ltd( [ 0, 1, 1, ], [ 100, 150,  50, ], 300, [ 100, 150,  50, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ], 300, [ 100, 100, 100, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100,  50,  50, ], 300, [ 100,  80, 120, ] ),
+    _ltd( [ 1, 2, 3, ], [ 100,  10,  10, ], 150, [ 100,  20,  30, ] ),
+
+    # cases when there is not enough space even for the min sizes (don't
+    # permute in these cases as the layout does depend on the item order
+    # because the first ones have priority)
+    _ltd( [ 1, 2, 3, ], [ 100,  50,  50, ], 150, [ 100,  50,   0, ], true ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ], 200, [ 100, 100,   0, ], true ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ], 150, [ 100,  50,   0, ], true ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ],  50, [  50,   0,   0, ], true ),
+    _ltd( [ 1, 2, 3, ], [ 100, 100, 100, ],   0, [   0,   0,   0, ], true ),
+  ]
+
+  def test_size_3
+    child = [Wx::Window.new(win, Wx::ID_ANY),
+             Wx::Window.new(win, Wx::ID_ANY),
+             Wx::Window.new(win, Wx::ID_ANY)]
+
+    LayoutTestData.each_with_index do |ltd, i|
+      # the results shouldn't depend on the order of items except in the
+      # case when there is not enough space for even the fixed width items
+      # (in which case the first ones might get enough of it but not the
+      # last ones) so test a couple of permutations of test data unless
+      # specifically disabled for this test case
+      3.times do |p|
+        case p
+        when 0
+          # nothing, use original data
+        when 1
+          # exchange first and last elements
+          ltd.prop[0], ltd.prop[2] = ltd.prop[2], ltd.prop[0]
+          ltd.minsize[0], ltd.minsize[2] = ltd.minsize[2], ltd.minsize[0]
+          ltd.sizes[0], ltd.sizes[2] = ltd.sizes[2], ltd.sizes[0]
+        when 2
+          # exchange the original third and second elements
+          ltd.prop[0], ltd.prop[1] = ltd.prop[1], ltd.prop[0]
+          ltd.minsize[0], ltd.minsize[1] = ltd.minsize[1], ltd.minsize[0]
+          ltd.sizes[0], ltd.sizes[1] = ltd.sizes[1], ltd.sizes[0]
+        end
+
+        sizer.clear
+
+        child.each_with_index { |c, j| ltd.add_to_sizer(sizer, c, j) }
+
+        win.set_client_size(ltd.x, -1)
+        win.layout
+
+        child.each_with_index do |c, j|
+          assert_equal(ltd.sizes[j], c.size.x,
+                       "test #{i}, permutation #{p}: wrong size for child #{j} for total size #{ltd.x}")
+        end
+
+        # don't try other permutations if explicitly disabled
+        break if ltd.dont_permute
+      end
+    end
+  end
+
+  def test_min_size
+    child = Wx::Window.new(win, Wx::ID_ANY)
+    child.set_initial_size([10, -1])
+    sizer.add(child)
+
+    # Setting minimal size explicitly must make get_min_size() return at least
+    # this size even if it needs a much smaller one.
+    sizer.set_min_size(100, 0)
+    assert(sizer.get_min_size.x == 100)
+
+    sizer.layout
+    assert(sizer.min_size.x == 100)
+  end
+
+end