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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3641fe86e3445b1cc2316d01fdf95f30685ec1cd7db34fa3d6f1a41866d2188
-  data.tar.gz: cafc7d51a9bc984d4d7e73181e3182be25ec45c4589f0af186d2ee1c95dfed6f
+  metadata.gz: cb68ca47dc52aa1c4ff478322597d44502782a0d58228d94a448d41963614ba6
+  data.tar.gz: 7799517b7e2018421436f41dce8e3f7a5faa9c0cd2b2c4df93b6e2558904a464
 SHA512:
-  metadata.gz: 333b2b88834008dccd8e07aa9264a8a17fa3d3591fc5e19e1bbcf729f2efd9e98f7ab309f7607f3e2157a8aadb5c4d96388a38db8f9c23b182e2bf19bbb84621
-  data.tar.gz: 5e77c8957774743fdeb71e216dfc71de9d5a626e8eca560c8e9f907e903d60af0368663354d841c066bac9041d98a38360aec63ade4e590e1eceee84643c6ee9
+  metadata.gz: 87cffdbf4f24e354a0b68337a01923c4f5c04084f5cebd02e5a8f7a065e7d92c8fa413852fd008bce63e841f2e031bd776d43009fdb997dd04cbaf1516b9024f
+  data.tar.gz: 434e080088dd9b85becebeb57c56f48c7465940553c56717a946cddf4e3eed31f81e4cccf22e9a715761007696e012f5a2f441edc8f21b307b405f41dfcf0d96

data/INSTALL.md

@@ -4,17 +4,20 @@
 
 # Installation of wxRuby3
 
+Below are installation instructions for Linux, Windows, and Mac (both AMD64 and ARM64).
+
 ## Minimal requirements for installing wxRuby3
 
 The minimal requirements for installing any source based setup (gem, source package or Github clone) of wxRuby3 are:
 
-| Sofware                                       | Notes                                                                                                                                                                                                                           |
-|-----------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Ruby                                          | A supported version of the Ruby interpreter needs to be installed.                                                                                                                                                              |
-| C++ compiler<br>(incl. dev tools like `make`) | On linux a recent version of the GNU C++ compiler (with c++-14 support) needs to be installed<br>On Windows the RubyInstaller MSYS2-Devkit needs to be installed<br>On MacOS XCode with commandline tools needs to be installed |
-| Git version control toolkit                   |                                                                                                                                                                                                                                 |
-| SWIG >= 3.0.12                                | On MacOS install [Homebrew](https://brew.sh/) and than `brew install swig`                                                                                                                                                      |
-| Doxygen (>= 1.9.1, <= 1.9.6)                  | Doxygen > 1.9.6 has changes that cause problems with the wxWidgets doxygen files.<br>On MacOS: `brew tap mcorino/wxruby3` and than `brew install doxygen@1.9.6` (default brew recipe installs 1.9.7)                            |
+| Sofware                                       | Notes                                                                                                                                                                                                                                                             |
+|-----------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Ruby                                          | A supported version of the Ruby interpreter needs to be installed.                                                                                                                                                                                                |
+| C++ compiler<br>(incl. dev tools like `make`) | On linux a recent version of the GNU C++ compiler (with c++-14 support) needs to be installed<br>On Windows the RubyInstaller MSYS2-Devkit needs to be installed<br>On MacOS XCode with commandline tools needs to be installed via `sudo xcode-select --install` |
+| Git version control toolkit                   |                                                                                                                                                                                                                                                                   |
+| SWIG >= 3.0.12                                | On MacOS install [Homebrew](https://brew.sh/) and than `brew install swig`                                                                                                                                                                                        |
+| Doxygen (>= 1.9.1, <= 1.9.6)                  | Doxygen > 1.9.6 has changes that cause problems with the wxWidgets doxygen files.<br>On MacOS: `brew tap mcorino/wxruby3` and than `brew install doxygen@1.9.6` (default brew recipe installs 1.9.7)                                                              |
+| wxWidgets (>= 3.2)                            | See [wxWidgets installation](#wxwidgets-installation)                                                                                                                                                                                                             |
 
 The wxRuby3 build process requires `git` to clone a copy of the wxWidgets Github repository to extract the interface 
 specifications from.<br>
@@ -44,6 +47,14 @@ gem install wxruby3 --platform=ruby
 
 When installing the source gem the minimal requirements listed above apply.
 
+On MacOS, if wxWidgets was not available, you can pull in the latest wxWidgets and build it by adding the `WITH_WXWIN=1` option:
+
+```shell
+gem install wxruby3 -- WITH_WXWIN=1
+```
+
+### wxWidgets installation
+
 Also a wxWidgets installation (version 3.2 or later) is required for which there are multiple options.
 
 1. System installed wxWidgets version (including development package)<br>
@@ -55,6 +66,17 @@ Also a wxWidgets installation (version 3.2 or later) is required for which there
    build procedure requires access to the wxWidgets interface specification sources which are not normally part of any of 
    the standard distribution packages.
    
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;On MacOS, you can install wxWidgets via [Homebrew](https://brew.sh/):
+
+```shell
+   brew install wxwidgets
+```
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Afterwards, you can install the Ruby gem and it will detect wxWidgets in the system automatically:
+
+```shell
+   gem install wxruby3
+```   
 
 2. User installed wxWidgets version<br>
    <br>
@@ -65,7 +87,7 @@ Also a wxWidgets installation (version 3.2 or later) is required for which there
 ```shell
    gem install wxruby3 -- WXWIN=/path/to/wx/install 
 ```
-   
+
 3. Automatic installed, embedded, wxWidgets version<br>
    <br>
    This is the easiest method when the system being installed on does not provide (a compatible) wxWidgets version (and 

data/README.md

@@ -100,7 +100,7 @@ Currently the following are fully supported:
 |----------------------------------------------------------------------------|-----------------| --- |
 | Windows 10 (tested)<br>(most likely also Windows 11)                       | Ruby >= 2.5<br>(RubyInstaller MSYS2-DevKit) | wxWidgets >= 3.2 |
 | Linux (tested; any AMD-64 distribution)<br>(most likely also i686 and ARM) | Ruby >= 2.5 | wxWidgets >= 3.2 |
-| MacOS >= 10.10 using Cocoa (tested on AMD-64)                              | Ruby >= 2.5 | wxWidgets >= 3.2 | 
+| MacOS >= 10.10 using Cocoa (tested on AMD-64 and ARM64 M2 Chip)            | Ruby >= 2.5 | wxWidgets >= 3.2 | 
 
 Support for other platforms is not being actively developed at present,
 but patches are welcome. It is likely to be much simpler to get wxRuby
@@ -158,7 +158,7 @@ some use a more modern coding style than others.
 
 Complete (more or less) wxRuby API documentation should be part of any
 complete wxRuby3 build. This tends to focus on providing a reference
-of all available modules, classes ad methods and how to use specific 
+of all available modules, classes and methods and how to use specific 
 classes and methods, rather than on how to construct an application 
 overall.
 This documentation (for the latest release) is also available online
@@ -190,7 +190,7 @@ If you know of a feature in wxWidgets that you would like to see
 supported in wxRuby3 you are free to ask but do not **EXPECT** unconditional 
 agreement or immediate response. 
 
-### How does wxRuby3 relate to the wxRuby 2.0 (and even older 0.6.0 release)?
+### How does wxRuby3 relate to the wxRuby 2.0 (and even older 0.6.0) release?
 
 wxRuby 0.6.0 was the last in a series of releases developed using a
 different approach in the early days of wxRuby. Work on this series

data/lib/wx/core/event_loop.rb

@@ -0,0 +1,7 @@
+
+module Wx
+
+  # simply an alias
+  EventLoop = GUIEventLoop
+
+end

data/lib/wx/core/image.rb

@@ -66,6 +66,39 @@ module Wx
     def convert_to_bitmap
       Wx::Bitmap.from_image(self)
     end
+
+    module Histogram
+
+      def make_key(r, g, b)
+        (r << 16) | (g << 8) | b
+      end
+
+      def find_first_unused_colour(r=1, g=0, b=0)
+        while self.has_key?(make_key(r,g,b))
+          if r >= 254
+            r = 0
+            if g >= 254
+              return nil if b >= 254
+              g = 0
+              b += 1
+            else
+              g += 1
+            end
+          else
+            r += 1
+          end
+        end
+        [r, g, b]
+      end
+
+    end
+
+    wx_compute_histogram = instance_method :compute_histogram
+    define_method :compute_histogram do
+      hist_hash = wx_compute_histogram.bind(self).call
+      hist_hash.extend Histogram
+      hist_hash
+    end
   end
 
   def self.Image(name, bmp_type = nil, *rest)

data/lib/wx/core/listctrl.rb

@@ -3,8 +3,23 @@ class Wx::ListCtrl
   # Make these ruby enumerables so find, find_all, map are available 
   include Enumerable
   # Passes each valid item index into the passed block
-  def each
-    0.upto(item_count - 1) { | i | yield i }
+  def each(&block)
+    if block_given?
+      0.upto(item_count - 1) { | i | block.call(i) }
+    else
+      ::Enumerator.new { |y| each { | i | y << i } }
+    end
+  end
+
+  def each_selected(&block)
+    if block_given?
+      item = -1
+      while (item = get_next_item(item, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED)) >= 0
+        block.call(item)
+      end
+    else
+      ::Enumerator.new { |y| each_selected { | i | y << i } }
+    end
   end
 
   # Returns an Array containing the indexes of the currently selected
@@ -19,15 +34,4 @@ class Wx::ListCtrl
     selections
   end
 
-  # # Stub version for LC_VIRTUAL controls that does nothing; may be
-  # # overridden in subclasses.
-  # def on_get_item_attr(i)
-  #   nil
-  # end
-  #
-  # # Stub version for LC_VIRTUAL|LC_REPORT controls that does nothing;
-  # # may be overridden in subclasses.
-  # def on_get_item_column_image(i, col)
-  #   -1
-  # end
 end

data/lib/wx/core/log.rb

@@ -14,7 +14,97 @@ module Wx
       alias :timestamp= :set_timestamp
       alias :verbose :get_verbose
       alias :verbose= :set_verbose
+
+      def set_component(comp)
+        @component = comp ? comp.to_s : comp
+      end
+      private :set_component
+
+      def component
+        @component
+      end
+
+      def for_component(comp, &block)
+        old_comp = component
+        set_component(comp)
+        begin
+          block.call if block_given?
+        ensure
+          set_component(old_comp)
+        end
+      end
+
+    end
+
+  end
+
+  class << self
+
+    def setup_log_info(fmt, args, filename, line, func, component)
+      # as wxRuby apps will ever only log from the main thread the only reason why
+      # log info data may be retained beyond the execution scope of the current
+      # log action is because of log repetition counting which will retain the
+      # first log info instance of a repeating message sequence
+
+      # format message
+      msg = fmt % args
+      log_info = {
+        filename: if filename
+                    filename.to_s
+                  else
+                    filename
+                  end,
+        line: line,
+        func: if func
+                func.to_s
+              else
+                func
+              end,
+        component: if component
+                     component.to_s
+                   else
+                     Log.component
+                   end
+      }
+      if Wx::Log.get_repetition_counting && @last_msg != msg
+        # refresh cache
+        @last_msg = msg
+        @last_info = log_info
+      end
+      [msg, log_info]
+    end
+    private :setup_log_info
+
+    wx_log_generic = self.instance_method :log_generic
+    define_method :log_generic do |lvl, fmt, *args, filename: nil, line: 0, func: nil, component: nil|
+      wx_log_generic.bind(self).call(lvl, *setup_log_info(fmt, args, filename, line, func, component))
     end
+
+    wx_log_info = self.instance_method :log_info
+    define_method :log_info do |fmt, *args, filename: nil, line: 0, func: nil, component: nil|
+      wx_log_info.bind(self).call(*setup_log_info(fmt, args, filename, line, func, component))
+    end
+
+    wx_log_verbose = self.instance_method :log_verbose
+    define_method :log_verbose do |fmt, *args, filename: nil, line: 0, func: nil, component: nil|
+      wx_log_verbose.bind(self).call(*setup_log_info(fmt, args, filename, line, func, component))
+    end
+
+    wx_log_message = self.instance_method :log_message
+    define_method :log_message do |fmt, *args, filename: nil, line: 0, func: nil, component: nil|
+      wx_log_message.bind(self).call(*setup_log_info(fmt, args, filename, line, func, component))
+    end
+
+    wx_log_warning = self.instance_method :log_warning
+    define_method :log_warning do |fmt, *args, filename: nil, line: 0, func: nil, component: nil|
+      wx_log_warning.bind(self).call(*setup_log_info(fmt, args, filename, line, func, component))
+    end
+
+    wx_log_error = self.instance_method :log_error
+    define_method :log_error do |fmt, *args, filename: nil, line: 0, func: nil, component: nil|
+      wx_log_error.bind(self).call(*setup_log_info(fmt, args, filename, line, func, component))
+    end
+
   end
 
 end

data/lib/wx/doc/bitmap.rb

@@ -8,20 +8,16 @@ module Wx
   # Default BitmapType for current platform. Actual value is platform dependent.
   CURSOR_DEFAULT_TYPE = Wx::BitmapType::BITMAP_TYPE_ANY
 
-  class Bitmap
-
-    # Searches for an art file with basename 'name' and creates a Bitmap 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)
-    # @return [Wx::Bitmap]
-    # @see Wx::ArtLocator::find_art
-    def self.Bitmap(name, bmp_type = nil); end
-
-  end
+  # Searches for an art file with basename 'name' and creates a Bitmap 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)
+  # @return [Wx::Bitmap]
+  # @see Wx::ArtLocator::find_art
+  def self.Bitmap(name, bmp_type = nil); end
 
 end

data/lib/wx/doc/event_loop.rb

@@ -0,0 +1,7 @@
+
+module Wx
+
+  # In wxRuby simply an alias for GUIEventLoop.
+  EventLoop = GUIEventLoop
+
+end

data/lib/wx/doc/extra/00_starting.md

@@ -18,9 +18,9 @@ is available for anyone to look at and use in any way they like. Also, anyone ca
 and enhancements to the project.
 
 Like wxWidgets wxRuby is a cross platform toolkit. This means that the same program will run on multiple platforms 
-without modification. Currently Supported platforms are Microsoft Windows and Linux or other 
-unix-like systems with GTK2 or GTK3 libraries. As wxWidgets also has stable releases for Mac OSX and Linux QT platforms
-it should not be to hard to support these. Contributions to achieve this are appreciated.
+without modification. Currently Supported platforms are Microsoft Windows, MacOSX and Linux or other 
+unix-like systems with GTK2 or GTK3 libraries. Contributions to achieve support for other wxWidgets supported platforms
+are appreciated.
 
 Since the programming language is Ruby, wxRuby programs are simple and easy to write and understand. To accomplish the
 full Ruby experience wxRuby has not ported the wxWidgets API 1 on 1 to Ruby but has made an effort to make the wxRuby
@@ -75,7 +75,7 @@ require 'wx'
 Wx::App.run { puts 'Hello world!' }
 ```
 
-As you can there is no obligation to create an instance of the Wx::App class in wxRuby for
+As you can see there is no obligation to create an instance of the Wx::App class in wxRuby for
 (admittedly extremely) simple applications. Calling the #run class method with a block will suffice.<br>
 The class method will create an instance of the generic Wx::App class under the hood and use the 
 provided block as the #on_init callback. As the code inside the block returns a false-type value (#puts 
@@ -127,8 +127,8 @@ When creating #on_init/#on_exit methods it is important to understand that those
 with wxWidgets itself). The base Wx::App class actually does not define these methods so it's also not needed (even not possible)
 to call `super` in the implementation. The wxRuby application class implementation will call the wxWidget OnInit base implementation
 itself and after successful completion check for the existence of an #on_init method (which could also be 'automagicallly'
-created from a block passed to #run) and call that if available or terminate the application if not. For the
-exit sequence to executions are similar but reversed (first a possible #on_exit method and than the wxWidgets base OnExit).
+created from a block passed to #run) and call that if available or terminate the application if not. The
+exit sequence of executions are similar but reversed (first a possible #on_exit method and than the wxWidgets base OnExit).
 
 What remains though is that for a derived application class it is still not necessary to explicitly create a class instance.
 Simply calling the #run class method will suffice.

data/lib/wx/doc/extra/02_lifecycles.md

@@ -76,7 +76,7 @@ As mentioned above the wxWidgets GUI framework resources will only be fully init
 starts. Likewise the framework resources will be de-initialized (deleted) after `#on_exit` method ends which means that 
 your application should not attempt to access any of these resources (windows, fonts, colours etc.) after that moment.
 
-Also, largely because of the way the wxWidgets framework is designed but also because of that way this meshes with Ruby 
+Also, largely because of the way the wxWidgets framework is designed but also because of the way this meshes with Ruby 
 GC, there is no safe way to re-initialize the framework after an application instance ends it run. This means you 
 **cannot** safely attempt to start another application instance after a previous (first) one has ended. 
 
@@ -120,7 +120,7 @@ therefor provides special support to ease handling the destruction of these. See
 One of the trickier things to handle correctly in the kind of native extensions like wxRuby is maintaining object 
 identities i.e. keeping native instances synced with their Ruby wrapper counter parts.
 
-Whenever a native extension is allowed to call back into Ruby space we encounter the problem the we need to map any 
+Whenever a native extension is allowed to call back into Ruby space we encounter the problem that we need to map any 
 native object data provided for the call to the right Ruby types and when necessary to the right Ruby instance (object
 identity).
 
@@ -131,8 +131,8 @@ passing them on to Ruby space.
 For a lot of other objects though it is essential to not only map to the right **most derived** class type but also to
 the exact Ruby instance which was originally instantiated as wrapper for the native object if any exists (in case no
 Ruby instance existed yet a new instance of the correct **most derived** class should be instantiated at that point). 
-The reason this is important is 1. because the Ruby instance may have been used to identify, link to or otherwise 
-reference other data and/or functionality related to that specific Ruby/native pair and 2. the Ruby instance could 
+The reason this is important is **1.** because the Ruby instance may have been used to identify, link to or otherwise 
+reference other data and/or functionality related to that specific Ruby/native pair and **2.** the Ruby instance could 
 contain data elements (instance variables) related to that specific Ruby/native pair.<br>
 In the case of wxRuby Window instance for example it is common to derive custom Window classes with custom behaviour and
 corresponding instance variables that drive that behaviour. When an event handler or an overloaded native method is passed
@@ -155,11 +155,12 @@ There are however quite a lot of wrapped native objects in wxRuby for which *obj
 object tracking has been disabled for their classes. This means these kind of classes/object should **not** be derived from
 (if even possible and/or useful) to add functionality/information or their identity used as key to link other information.<br>
 These classes include:
-- classes considered POD types like Wx::Size, Wx::Point, Wx::RealPoint, Wx::Rect, Wx::GBSpan, Wx::GBPosition, Wx::BusyInfoFlags,
+* classes considered POD types like Wx::Size, Wx::Point, Wx::RealPoint, Wx::Rect, Wx::GBSpan, Wx::GBPosition, Wx::BusyInfoFlags,
 Wx::AboutDialogInfo
-- final non-instantiatable classes like the Wx::DC (Device Context) class family, Wx::GraphicsContext, Wx::WindowsDisabler,
+* final non-instantiatable classes like the Wx::DC (Device Context) class family, Wx::GraphicsContext, Wx::WindowsDisabler,
 Wx::EventBlocker, Wx::BusyInfo
-- classes with native singleton objects like Wx::Clipboard
-- the reference counted GDI objects like Wx::Pen, Wx::Brush, Wx::Colour, Wx::Cursor, Wx::Bitmap, Wx::Icon
+* classes with native singleton objects like Wx::Clipboard
+* the reference counted GDI objects like Wx::Pen, Wx::Brush, Wx::Colour, Wx::Cursor, Wx::Bitmap, Wx::Icon and similar 
+reference counted objects like Wx::Font
 
 The reference documentation will note untracked object classes.

data/lib/wx/doc/extra/09_exceptions.md

@@ -15,7 +15,7 @@ your own Ruby application code.
 
 Any exceptions raised from wxRuby wrapper code signal coding errors that need to be rectified.
 
-As far as handling application code exceptions is concerned the same advice applies as for wxWidgets itself; do **not**
+As far as handling application code exceptions is concerned the same advice applies as for wxWidgets itself; do **NOT**
 let exceptions escape your event handlers meaning that if you can reasonably expect application code to raise exceptions
 you should make sure to catch any such exceptions within the context of the event handler like:
 

data/lib/wx/doc/extra/11_drawing_and_dc.md

@@ -12,9 +12,9 @@ device context object is destroyed.
 For this reason the common practice in wxWidgets C++ code would be to create temporary DC objects on the
 stack and draw on them while they are in scope (for several classes it is even strongly advised to never create
 them any other way and to never keep objects alive out of scope). When leaving the scope these object would than be 
-automatically destroyed and the any buffered output flushed to the final target.
+automatically destroyed and any buffered output flushed to the final target.
 
-In Ruby this approach is impossible as Ruby is a purely dynamic language and does not **this kind** of scope bound
+In Ruby this approach is impossible as Ruby is a purely dynamic language and does not support **this kind** of scope bound
 life cycles. Any DC object created would have to be dynamically created and due to the properties of the GC driven
 life cycles could well be kept alive beyond the scope of it's creation. This will not always cause problems but could
 and does not really have an upside.
@@ -24,7 +24,7 @@ cannot be instantiated using `new`. Rather all `Wx::DC` derived classes provide
 temporary dc objects that will be passed on to blocks given and will only exist for the duration of the execution of
 the block. This will guarantee proper DC cleanup when leaving it's usage scope.
 
-> Note that it is a **BAD** idea to think about storing the dc reference provide to the block for later access!
+> Note that it is a **BAD** idea to think about storing the dc reference provided to the block for later access!
 
 A typical usage of a `::draw_on` method would be:
 
@@ -48,7 +48,7 @@ The `Wx::PaintDC` and `Wx::AutoBufferedPaintDC` classes provide `::draw_on` meth
 this is mostly to be consistent.
 
 In this case it is recommended to instead use the `Wx::Window#paint` or `Wx::Window#paint_buffered` methods as these
-provide some optimizations with regard to automatically detecting is the methods are called inside `Wx::EVT_PAINT` 
+provide some optimizations with regard to automatically detecting if the methods are called inside `Wx::EVT_PAINT` 
 handlers (which should normally be the case) or not.
 
 So the typical way to do buffered painting inside a windows `Wx::EVT_PAINT` handler would be something like:

data/lib/wx/doc/font.rb

@@ -1,5 +1,5 @@
 
-class Wx
+module Wx
   class Font
 
     # @overload find_or_create_font(point_size, family, style, weight, underline=false, facename='', encoding=Wx::FontEncoding::FONTENCODING_DEFAULT)

data/lib/wx/doc/functions.rb

@@ -11,32 +11,73 @@ module Wx
   # @param lvl  [Integer] logging level (like {Wx::LOG_Message})
   # @param fmt  [String]  message (formatting) string
   # @param args [Array<Object>] optional message arguments
-  # @return [nil]
-  def self.log_generic(lvl, fmt, *args) end
+  # @param filename [String] optional file name for log info
+  # @param line [Integer] optional line number for log info
+  # @param func [String] optional function name for log info
+  # @param component [String] optional component name for log info
+  # @return [void]
+  def self.log_generic(lvl, fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
 
   # Log a Wx low priority informational message to the current Wx log output
   # @param fmt  [String]  message (formatting) string
   # @param args [Array<Object>] optional message arguments
-  # @return [nil]
-  def self.log_info(fmt, *args) end
+  # @param filename [String] optional file name for log info
+  # @param line [Integer] optional line number for log info
+  # @param func [String] optional function name for log info
+  # @param component [String] optional component name for log info
+  # @return [void]
+  def self.log_info(fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
 
   # Log a Wx Informational message to the current Wx log output
   # @param fmt  [String]  message (formatting) string
   # @param args [Array<Object>] optional message arguments
-  # @return [nil]
-  def self.log_message(fmt, *args) end
+  # @param filename [String] optional file name for log info
+  # @param line [Integer] optional line number for log info
+  # @param func [String] optional function name for log info
+  # @param component [String] optional component name for log info
+  # @return [void]
+  def self.log_message(fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
 
   # Log a Wx Error message to the current Wx log output
   # @param fmt  [String]  message (formatting) string
   # @param args [Array<Object>] optional message arguments
-  # @return [nil]
-  def self.log_error(fmt, *args) end
+  # @param filename [String] optional file name for log info
+  # @param line [Integer] optional line number for log info
+  # @param func [String] optional function name for log info
+  # @param component [String] optional component name for log info
+  # @return [void]
+  def self.log_error(fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
 
   # Log a Wx Warning message to the current Wx log output
   # @param fmt  [String]  message (formatting) string
   # @param args [Array<Object>] optional message arguments
-  # @return [nil]
-  def self.log_warning(fmt, *args) end
+  # @param filename [String] optional file name for log info
+  # @param line [Integer] optional line number for log info
+  # @param func [String] optional function name for log info
+  # @param component [String] optional component name for log info
+  # @return [void]
+  def self.log_warning(fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
+
+  # Log a Wx verbose informational message to the current Wx log output
+  # (needs explicit activation to be shown)
+  # @param fmt  [String]  message (formatting) string
+  # @param args [Array<Object>] optional message arguments
+  # @param filename [String] optional file name for log info
+  # @param line [Integer] optional line number for log info
+  # @param func [String] optional function name for log info
+  # @param component [String] optional component name for log info
+  # @return [void]
+  def self.log_verbose(fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
+
+  # Log a Wx debug message to the current Wx log output
+  # @param fmt  [String]  message (formatting) string
+  # @param args [Array<Object>] optional message arguments
+  # @param filename [String] optional file name for log info
+  # @param line [Integer] optional line number for log info
+  # @param func [String] optional function name for log info
+  # @param component [String] optional component name for log info
+  # @return [void]
+  def self.log_debug(fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
 
   # Log a Wx Status message - this is directed to the status bar of the
   # specified Frame window, or the application main window if not specified.
@@ -51,19 +92,6 @@ module Wx
   # @return [nil]
   def self.log_status(fmt, *args) end
 
-  # Log a Wx verbose informational message to the current Wx log output
-  # (needs explicit activation to be shown)
-  # @param fmt  [String]  message (formatting) string
-  # @param args [Array<Object>] optional message arguments
-  # @return [nil]
-  def self.log_verbose(fmt, *args) end
-
-  # Log a Wx debug message to the current Wx log output
-  # @param fmt  [String]  message (formatting) string
-  # @param args [Array<Object>] optional message arguments
-  # @return [nil]
-  def self.log_debug(fmt, *args) end
-
   # @!endgroup
 
   # @!group Other class methods

data/lib/wx/doc/gc_dc.rb

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

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

@@ -66,7 +66,7 @@ module Wx
   class AboutDialogInfo < ::Object
   
     # Default constructor leaves all fields are initially uninitialized, in general you should call at least {Wx::AboutDialogInfo#set_version}, {Wx::AboutDialogInfo#set_copyright} and {Wx::AboutDialogInfo#set_description}.
-    # @return [AboutDialogInfo]
+    # @return [Wx::AboutDialogInfo]
     def initialize; end
     
     # Adds an artist name to be shown in the program credits.