wxruby3 0.9.0.pre.beta.1-x64-mingw-ucrt-3.2

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

@@ -0,0 +1,35 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A {Wx::WindowDC} must be constructed if an application wishes to paint on the whole area of a window (client and decorations).
+  # This should normally be constructed as a temporary stack object; don't store a {Wx::WindowDC} object.
+  # To draw on a window from inside an EVT_PAINT() handler, construct a {Wx::PaintDC} object instead.
+  # To draw on the client area of a window from outside an EVT_PAINT() handler, construct a {Wx::ClientDC} object.
+  # A {Wx::WindowDC} object is initialized to use the same font and colours as the window it is associated with.
+  # === 
+  # 
+  # Category:  Device Contexts
+  # @see Wx::DC
+  # @see  Wx::MemoryDC
+  # @see  Wx::PaintDC
+  # @see  Wx::ClientDC
+  # @see  Wx::ScreenDC 
+  # 
+  # 
+  class WindowDC < DC
+  
+    # Constructor.
+    # Pass a pointer to the window on which you wish to paint.
+    # @param window [Wx::Window] 
+    # @return [WindowDC]
+    def initialize(window) end
+    
+  end # WindowDC
+  
+
+end

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

@@ -0,0 +1,24 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # This class disables all top level windows of the application (maybe with the exception of one of them) in its constructor and enables them back in its destructor.
+  # This is useful when you want to indicate to the user that the application is currently busy and cannot respond to user input.
+  # When instantiated, this affects only windows shown on the screen and not already disabled.
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Miscellaneous}
+  # @see Wx::BusyCursor 
+  # 
+  # 
+  class WindowDisabler < ::Object
+  
+  end # WindowDisabler
+  
+
+end

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

@@ -0,0 +1,73 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A mixin class to be used with other classes that use a {Wx::ImageList}.
+  # This class is used by classes such as {Wx::Notebook} and {Wx::TreeCtrl}, that use image indices to specify the icons used for their items (page icons for the former or the items inside the control for the latter).
+  # The icon index can either be a special value NO_IMAGE to indicate that an item doesn't use an image at all or a small positive integer to specify the index of the icon in the list of images maintained by this class. Note that for many controls, either none of the items should have an icon or all of them should have one, i.e. mixing the items with and without an icon doesn't always work well and may result in less than ideal appearance.
+  # To initialize the list of icons used, call {Wx::WithImages#set_images} method passing it a vector of {Wx::BitmapBundle} objects which can, in the simplest case, be just {Wx::Bitmap} or {Wx::Icon} objects  however, as always with {Wx::BitmapBundle}, either more than one bitmap or icon needs to be specified or the bitmap bundle needs to be created from SVG to obtain better appearance in high DPI.
+  # Alternative, traditional API which was the only one available until wxWidgets 3.1.6, is based on the use of {Wx::ImageList} class. To use it, you need to create an object of this class and then call either {Wx::WithImages#assign_image_list} to set this image list and give the control its ownership or {Wx::WithImages#set_image_list} to retain the ownership of the image list, which can be useful if the same image list is shared by multiple controls, but requires deleting the image list later.
+  # {Wx::ImageList}-based API is not formally deprecated, but its use is discouraged because it is more complicated than simply providing a vector of bitmaps and it doesn't allow specifying multiple images or using SVG, which is required for good high DPI support. Please don't use {Wx::WithImages#assign_image_list} and {Wx::WithImages#set_image_list} in the new code and use {Wx::WithImages#set_images} instead.
+  # 
+  # 
+  # @note  In wxRuby this is a mixin module instead of a (base) class.
+  module WithImages
+  
+    # @return [WithImages]
+    def initialize; end
+    
+    # Return the number of images in this control.
+    # The returned value may be 0 if there are no images associated with the control.
+    # @see Wx::WithImages#has_images
+    # @return [Integer]
+    def get_image_count; end
+    alias_method :image_count, :get_image_count
+    
+    # Return true if the control has any images associated with it.
+    # 
+    # @see Wx::WithImages#get_image_count
+    # @return [true,false]
+    def has_images; end
+    alias_method :has_images?, :has_images
+    
+    # Set the images to use for the items in the control.
+    # This function allows to specify the images to use in multiple different resolutions, letting the control to select the appropriate one for its DPI scaling. For this reason, it should be preferred to using the functions taking {Wx::ImageList}, which has a fixed size, in the new code.
+    # @param images [Array<Wx::Image>]  Non empty vector of bitmap bundles. Valid image indexes for the items in this control are determined by the size of this vector.
+    # @return [void]
+    def set_images(images) end
+    alias_method :images=, :set_images
+    
+    # Sets the image list for the page control and takes ownership of the list.
+    # This function exists for compatibility only, please use {Wx::WithImages#set_images} in the new code.
+    # @see Wx::ImageList
+    # @see  Wx::WithImages#set_image_list 
+    # @param imageList [Wx::ImageList] 
+    # @return [void]
+    def set_image_list(imageList) end
+    alias_method :image_list=, :set_image_list
+    
+    # Returns the associated image list, may be NULL.
+    # Note that the new code should use {Wx::WithImages#get_updated_image_list_for} instead.
+    # @see Wx::ImageList
+    # @see  Wx::WithImages#set_image_list 
+    # @return [Wx::ImageList]
+    def get_image_list; end
+    alias_method :image_list, :get_image_list
+    
+    # Returns the image list updated to reflect the DPI scaling used for the given window if possible.
+    # If {Wx::WithImages#set_images} has been called, this function creates the image list containing the images using the DPI scaling in effect for the provided win, which must be valid.
+    # Otherwise it behaves as {Wx::WithImages#get_image_list}, i.e. returns the image list previously set using {Wx::WithImages#set_image_list} or {Wx::WithImages#assign_image_list}, and just returns NULL if none of them had been called.
+    # Possibly null pointer owned by this object, i.e. which must not be deleted by the caller.
+    # @param win [Wx::Window] 
+    # @return [Wx::ImageList]
+    def get_updated_image_list_for(win) end
+    alias_method :updated_image_list_for, :get_updated_image_list_for
+    
+  end # WithImages
+  
+
+end

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

@@ -0,0 +1,197 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {Wx::Wizard} is the central class for implementing 'wizard-like' dialogs.
+  # These dialogs are mostly familiar to Windows users and are nothing other than a sequence of 'pages', each displayed inside a dialog which has the buttons to navigate to the next (and previous) pages.
+  # The wizards are typically used to decompose a complex dialog into several simple steps and are mainly useful to the novice users, hence it is important to keep them as simple as possible.
+  # To show a wizard dialog, you must first create an instance of the {Wx::Wizard} class using either the non-default constructor or a default one followed by call to the {Wx::Wizard#create} function. Then you should add all pages you want the wizard to show and call {Wx::Wizard#run_wizard}. Finally, don't forget to call <code>"wizard->Destroy()"</code>, otherwise your application will hang on exit due to an undestroyed window.
+  # You can supply a bitmap to display on the left of the wizard, either for all pages or for individual pages. If you need to have the bitmap resize to the height of the wizard, call {Wx::Wizard#set_bitmap_placement} and if necessary, {Wx::Wizard#set_bitmap_background_colour} and {Wx::Wizard#set_minimum_bitmap_width}.
+  # To make wizard pages scroll when the display is too small to fit the whole dialog, you can switch layout adaptation on globally with {Wx::Dialog.enable_layout_adaptation} or per dialog with {Wx::Dialog#set_layout_adaptation_mode}. For more about layout adaptation, see Automatic Scrolled Dialogs.
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::WizardEvent} events.
+  # Event handler methods for events emitted by this class:
+  # - {Wx::EvtHandler#evt_wizard_page_changed}(id, meth = nil, &block): The page has just been 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. 
+  # 
+  # == Extended styles
+  # 
+  # Use the {Wx::Window#set_extra_style} function to set the following style. You will need to use two-step construction (use the default constructor, call {Wx::Wizard#set_extra_style}, then call Create).
+  # 
+  # === Extra Styles
+  # 
+  # This class supports the following extra styles:
+  #  
+  # - {Wx::WIZARD_EX_HELPBUTTON}: Shows a Help button using {Wx::StandardID::ID_HELP}. 
+  # 
+  # See also {Wx::Dialog} for other extended styles.
+  # === 
+  # 
+  # Category:  Common Dialogs
+  # @see Wx::WizardEvent
+  # @see  Wx::WizardPage
+  # @see  Wizard Sample 
+  # 
+  # 
+  class Wizard < Dialog
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   Use this if you wish to derive from {Wx::Wizard} and then call {Wx::Wizard#create}, for example if you wish to set an extra style with {Wx::Window#set_extra_style} between the two calls.
+    #   @return [Wizard]
+    # @overload initialize(parent, id=Wx::ID_ANY, title=Wx::EMPTY_STRING, bitmap=(Wx::BitmapBundle.new()), pos=Wx::DEFAULT_POSITION, style=Wx::DEFAULT_DIALOG_STYLE)
+    #   Constructor which really creates the wizard  if you use this constructor, you shouldn't call {Wx::Wizard#create}.
+    #   Notice that unlike almost all other wxWidgets classes, there is no size parameter in the {Wx::Wizard} constructor because the wizard will have a predefined default size by default. If you want to change this, you should use the {Wx::Wizard#get_page_area_sizer} function.
+    #   @param parent [Wx::Window]  The parent window, may be NULL.
+    #   @param id [Integer]  The id of the dialog, will usually be just {Wx::StandardID::ID_ANY}.
+    #   @param title [String]  The title of the dialog.
+    #   @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  The default bitmap used in the left side of the wizard. See also {Wx::Wizard#get_bitmap}.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  The position of the dialog, it will be centered on the screen by default.
+    #   @param style [Integer]  Window style is passed to {Wx::Dialog}.
+    #   @return [Wizard]
+    def initialize(*args) end
+    
+    # Creates the wizard dialog.
+    # Must be called if the default constructor had been used to create the object.
+    # Notice that unlike almost all other wxWidgets classes, there is no size parameter in the {Wx::Wizard} constructor because the wizard will have a predefined default size by default. If you want to change this, you should use the {Wx::Wizard#get_page_area_sizer} function.
+    # @param parent [Wx::Window]  The parent window, may be NULL.
+    # @param id [Integer]  The id of the dialog, will usually be just -1.
+    # @param title [String]  The title of the dialog.
+    # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  The default bitmap used in the left side of the wizard. See also {Wx::Wizard#get_bitmap}.
+    # @param pos [Array(Integer, Integer), Wx::Point]  The position of the dialog, it will be centered on the screen by default.
+    # @param style [Integer]  Window style is passed to {Wx::Dialog}.
+    # @return [true,false]
+    def create(parent, id=Wx::ID_ANY, title=Wx::EMPTY_STRING, bitmap=(Wx::BitmapBundle.new()), pos=Wx::DEFAULT_POSITION, style=Wx::DEFAULT_DIALOG_STYLE) end
+    
+    # This method is obsolete, use {Wx::Wizard#get_page_area_sizer} instead.
+    # Sets the page size to be big enough for all the pages accessible via the given firstPage, i.e. this page, its next page and so on.
+    # This method may be called more than once and it will only change the page size if the size required by the new page is bigger than the previously set one. This is useful if the decision about which pages to show is taken during run-time, as in this case, the wizard won't be able to get to all pages starting from a single one and you should call Fit separately for the others.
+    # @param firstPage [Wx::WizardPage] 
+    # @return [void]
+    def fit_to_page(firstPage) end
+    
+    # Returns the colour that should be used to fill the area not taken up by the wizard or page bitmap, if a non-zero bitmap placement flag has been set.
+    # See also {Wx::Wizard#set_bitmap_placement}.
+    # @return [Wx::Colour,String,Symbol]
+    def get_bitmap_background_colour; end
+    alias_method :bitmap_background_colour, :get_bitmap_background_colour
+    
+    # Returns the flags indicating how the wizard or page bitmap should be expanded and positioned to fit the page height.
+    # By default, placement is 0 (no expansion is done).
+    # See also {Wx::Wizard#set_bitmap_placement} for the possible values.
+    # @return [Integer]
+    def get_bitmap_placement; end
+    alias_method :bitmap_placement, :get_bitmap_placement
+    
+    # Get the current page while the wizard is running.
+    # NULL is returned if {Wx::Wizard#run_wizard} is not being executed now.
+    # @return [Wx::WizardPage]
+    def get_current_page; end
+    alias_method :current_page, :get_current_page
+    
+    # Returns the minimum width for the bitmap that will be constructed to contain the actual wizard or page bitmap if a non-zero bitmap placement flag has been set.
+    # See also {Wx::Wizard#set_bitmap_placement}.
+    # @return [Integer]
+    def get_minimum_bitmap_width; end
+    alias_method :minimum_bitmap_width, :get_minimum_bitmap_width
+    
+    # Returns pointer to page area sizer.
+    # The wizard is laid out using sizers and the page area sizer is the place-holder for the pages. All pages are resized before being shown to match the wizard page area.
+    # Page area sizer has a minimal size that is the maximum of several values. First, all pages (or other objects) added to the sizer. Second, all pages reachable by repeatedly applying {Wx::WizardPage#get_next} to any page inserted into the sizer.
+    # Third, the minimal size specified using {Wx::Wizard#set_page_size} and {Wx::Wizard#fit_to_page}. Fourth, the total wizard height may be increased to accommodate the bitmap height. Fifth and finally, wizards are never smaller than some built-in minimal size to avoid wizards that are too small.
+    # The caller can use {Wx::Sizer#set_min_size} to enlarge it beyond the minimal size. If {Wx::RESIZE_BORDER} was passed to constructor, user can resize wizard and consequently the page area (but not make it smaller than the minimal size).
+    # It is recommended to add the first page to the page area sizer. For simple wizards, this will enlarge the wizard to fit the biggest page.
+    # For non-linear wizards, the first page of every separate chain should be added. Caller-specified size can be accomplished using {Wx::Sizer#set_min_size}. Adding pages to the page area sizer affects the default border width around page area that can be altered with {Wx::Wizard#set_border}.
+    # @return [Wx::Sizer]
+    def get_page_area_sizer; end
+    alias_method :page_area_sizer, :get_page_area_sizer
+    
+    # Returns the size available for the pages.
+    # @return [Wx::Size]
+    def get_page_size; end
+    alias_method :page_size, :get_page_size
+    
+    # Return true if this page is not the last one in the wizard.
+    # The base class version implements this by calling {Wx::page->GetNext} but this could be undesirable if, for example, the pages are created on demand only.
+    # @see Wx::Wizard#has_prev_page 
+    # @param page [Wx::WizardPage] 
+    # @return [true,false]
+    def has_next_page(page) end
+    alias_method :has_next_page?, :has_next_page
+    
+    # Returns true if this page is not the first one in the wizard.
+    # The base class version implements this by calling {Wx::page->GetPrev} but this could be undesirable if, for example, the pages are created on demand only.
+    # @see Wx::Wizard#has_next_page 
+    # @param page [Wx::WizardPage] 
+    # @return [true,false]
+    def has_prev_page(page) end
+    alias_method :has_prev_page?, :has_prev_page
+    
+    # Executes the wizard starting from the given page, returning true if it was successfully finished or false if user cancelled it.
+    # The firstPage cannot be NULL.
+    # @param firstPage [Wx::WizardPage] 
+    # @return [true,false]
+    def run_wizard(firstPage) end
+    
+    # Sets the bitmap used for the wizard.
+    # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    # @return [void]
+    def set_bitmap(bitmap) end
+    alias_method :bitmap=, :set_bitmap
+    
+    # Sets the colour that should be used to fill the area not taken up by the wizard or page bitmap, if a non-zero bitmap placement flag has been set.
+    # See also {Wx::Wizard#set_bitmap_placement}.
+    # @param colour [Wx::Colour,String,Symbol] 
+    # @return [void]
+    def set_bitmap_background_colour(colour) end
+    alias_method :bitmap_background_colour=, :set_bitmap_background_colour
+    
+    # Sets the flags indicating how the wizard or page bitmap should be expanded and positioned to fit the page height.
+    # By default, placement is 0 (no expansion is done). placement is a bitlist with the following possible values:
+    # 
+    # - <b>{Wx::WIZARD_VALIGN_TOP}:</b> Aligns the bitmap at the top.- <b>{Wx::WIZARD_VALIGN_CENTRE}:</b> Centres the bitmap vertically.- <b>{Wx::WIZARD_VALIGN_BOTTOM}:</b> Aligns the bitmap at the bottom.- <b>{Wx::WIZARD_HALIGN_LEFT}:</b> Left-aligns the bitmap.- <b>{Wx::WIZARD_HALIGN_CENTRE}:</b> Centres the bitmap horizontally.- <b>{Wx::WIZARD_HALIGN_RIGHT}:</b> Right-aligns the bitmap.- <b>{Wx::WIZARD_TILE}:</b> The bitmap will be tiled to fit available space.
+    # 
+    # See also {Wx::Wizard#set_minimum_bitmap_width}.
+    # @param placement [Integer] 
+    # @return [void]
+    def set_bitmap_placement(placement) end
+    alias_method :bitmap_placement=, :set_bitmap_placement
+    
+    # Sets width of border around page area.
+    # Default is zero. For backward compatibility, if there are no pages in {Wx::Wizard#get_page_area_sizer}, the default is 5 pixels.
+    # If there is a five point border around all controls in a page and the border around page area is left as zero, a five point white space along all dialog borders will be added to the control border in order to space page controls ten points from the dialog border and non-page controls.
+    # @param border [Integer] 
+    # @return [void]
+    def set_border(border) end
+    alias_method :border=, :set_border
+    
+    # Sets the minimum width for the bitmap that will be constructed to contain the actual wizard or page bitmap if a non-zero bitmap placement flag has been set.
+    # If this is not set when using bitmap placement, the initial layout may be incorrect.
+    # See also {Wx::Wizard#set_bitmap_placement}.
+    # @param width [Integer] 
+    # @return [void]
+    def set_minimum_bitmap_width(width) end
+    alias_method :minimum_bitmap_width=, :set_minimum_bitmap_width
+    
+    # Sets the minimal size to be made available for the wizard pages.
+    # The wizard will take into account the size of the bitmap (if any) itself. Also, the wizard will never be smaller than the default size.
+    # The recommended way to use this function is to lay out all wizard pages using the sizers (even though the wizard is not resizable) and then use {Wx::Sizer#calc_min} in a loop to calculate the maximum of minimal sizes of the pages and pass it to {Wx::Wizard#set_page_size}.
+    # @param sizePage [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def set_page_size(sizePage) end
+    alias_method :page_size=, :set_page_size
+    
+  end # Wizard
+  
+
+end

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

@@ -0,0 +1,105 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  WIZARD_EX_HELPBUTTON = 16
+  
+  # 
+  WIZARD_VALIGN_TOP = 1
+  
+  # 
+  WIZARD_VALIGN_CENTRE = 2
+  
+  # 
+  WIZARD_VALIGN_BOTTOM = 4
+  
+  # 
+  WIZARD_HALIGN_LEFT = 8
+  
+  # 
+  WIZARD_HALIGN_CENTRE = 16
+  
+  # 
+  WIZARD_HALIGN_RIGHT = 32
+  
+  # 
+  WIZARD_TILE = 64
+  
+  # 
+  # 
+  EVT_WIZARD_PAGE_CHANGED = 10013
+  
+  # 
+  # 
+  EVT_WIZARD_PAGE_CHANGING = 10014
+  
+  # 
+  # 
+  EVT_WIZARD_CANCEL = 10016
+  
+  # 
+  # 
+  EVT_WIZARD_HELP = 10018
+  
+  # 
+  # 
+  EVT_WIZARD_FINISHED = 10017
+  
+  # 
+  # 
+  EVT_WIZARD_PAGE_SHOWN = 10019
+  
+  # 
+  # 
+  EVT_WIZARD_BEFORE_PAGE_CHANGED = 10015
+  
+  # {Wx::WizardEvent} class represents an event generated by the {Wx::Wizard}: this event is first sent to the page itself and, if not processed there, goes up the window hierarchy as usual.
+  # === Events using this class
+  # 
+  # 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. 
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Events}
+  # @see Wx::Wizard
+  # @see  Wizard Sample 
+  # 
+  # 
+  class WizardEvent < NotifyEvent
+  
+    # 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 id [Integer] 
+    # @param direction [true,false] 
+    # @param page [Wx::WizardPage] 
+    # @return [WizardEvent]
+    def initialize(type=Wx::EVT_NULL, id=Wx::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.
+    # @return [true,false]
+    def get_direction; end
+    alias_method :direction, :get_direction
+    
+    # Returns the {Wx::WizardPage} which was active when this event was generated.
+    # @return [Wx::WizardPage]
+    def get_page; end
+    alias_method :page, :get_page
+    
+  end # WizardEvent
+  
+
+end

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

@@ -0,0 +1,61 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {Wx::WizardPage} is one of the screens in {Wx::Wizard}: it must know what are the following and preceding pages (which may be NULL for the first/last page).
+  # Except for this extra knowledge, {Wx::WizardPage} is just a panel, so the controls may be placed directly on it in the usual way.
+  # This class allows the programmer to decide the order of pages in the wizard dynamically (during run-time) and so provides maximal flexibility. Usually, however, the order of pages is known in advance in which case {Wx::WizardPageSimple} class is enough and it is simpler to use.
+  # 
+  # == Virtual functions to override
+  # 
+  # To use this class, you must override {Wx::WizardPage#get_prev} and {Wx::WizardPage#get_next} pure virtual functions (or you may use {Wx::WizardPageSimple} instead). {Wx::WizardPage#get_bitmap} can also be overridden, but this should be very rarely needed.
+  # === 
+  # 
+  # Category:  Miscellaneous Windows
+  # @see Wx::Wizard
+  # @see  Wizard Sample 
+  # 
+  # 
+  class WizardPage < Panel
+  
+    # Default constructor.
+    # @return [WizardPage]
+    def initialize; end
+    
+    # Creates the wizard page.
+    # Must be called if the default constructor had been used to create the object.
+    # @param parent [Wx::Wizard]  The parent wizard
+    # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  The page-specific bitmap if different from the global one
+    # @return [true,false]
+    def create(parent, bitmap=(Wx::BitmapBundle.new())) end
+    
+    # This method is called by {Wx::Wizard} to get the bitmap to display alongside the page.
+    # By default, m_bitmap member variable which was set in the {Wx::WizardPage#wizard_page} constructor.
+    # If the bitmap was not explicitly set (i.e. if {Wx::NULL_BITMAP} is returned), the default bitmap for the wizard should be used.
+    # The only cases when you would want to override this function is if the page bitmap depends dynamically on the user choices, i.e. almost never.
+    # @return [Wx::Bitmap]
+    def get_bitmap; end
+    alias_method :bitmap, :get_bitmap
+    
+    # Get the page which should be shown when the user chooses the <code>"Next"</code> button: if NULL is returned, this button will be disabled.
+    # The last page of the wizard will usually return NULL from here, but the others will not.
+    # @see Wx::WizardPage#get_prev 
+    # @return [Wx::WizardPage]
+    def get_next; end
+    alias_method :next_, :get_next
+    
+    # Get the page which should be shown when the user chooses the <code>"Back"</code> button: if NULL is returned, this button will be disabled.
+    # The first page of the wizard will usually return NULL from here, but the others will not.
+    # @see Wx::WizardPage#get_next 
+    # @return [Wx::WizardPage]
+    def get_prev; end
+    alias_method :prev, :get_prev
+    
+  end # WizardPage
+  
+
+end

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

@@ -0,0 +1,72 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {Wx::WizardPageSimple} is the simplest possible {Wx::WizardPage} implementation: it just returns the pointers given to its constructor from {Wx::WizardPage#get_next} and {Wx::WizardPage#get_prev} functions.
+  # This makes it very easy to use the objects of this class in the wizards where the pages order is known statically - on the other hand, if this is not the case you must derive your own class from {Wx::WizardPage} instead.
+  # === 
+  # 
+  # Category:  Miscellaneous Windows
+  # @see Wx::Wizard
+  # @see  Wizard Sample 
+  # 
+  # 
+  class WizardPageSimple < WizardPage
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [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}.
+    #   @param parent [Wx::Wizard] 
+    #   @param prev [Wx::WizardPage] 
+    #   @param next_ [Wx::WizardPage] 
+    #   @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    #   @return [WizardPageSimple]
+    def initialize(*args) end
+    
+    # Creates the wizard page.
+    # Must be called if the default constructor had been used to create the object.
+    # @param parent [Wx::Wizard] 
+    # @param prev [Wx::WizardPage] 
+    # @param next_ [Wx::WizardPage] 
+    # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    # @return [true,false]
+    def create(parent=nil, prev=nil, next_=nil, bitmap=(Wx::BitmapBundle.new())) end
+    
+    # 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);
+    # 
+    # 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.
+    # 
+    # Reference to next on which {Wx::WizardPageSimple#chain} can be called again.
+    # @param next_ [Wx::WizardPageSimple] 
+    # @return [Wx::WizardPageSimple]
+    def chain(next_) end
+    
+    # Sets the next page.
+    # @param next_ [Wx::WizardPage] 
+    # @return [void]
+    def set_next(next_) end
+    alias_method :next_=, :set_next
+    
+    # Sets the previous page.
+    # @param prev [Wx::WizardPage] 
+    # @return [void]
+    def set_prev(prev) end
+    alias_method :prev=, :set_prev
+    
+  end # WizardPageSimple
+  
+
+end