wxruby3 0.9.4-x64-mingw-ucrt → 0.9.5-x64-mingw-ucrt

data/lib/wx/doc/gen/aui/aui_manager.rb

@@ -28,7 +28,6 @@ module Wx::AUI
   # ```
   # 
   # ## Layers, Rows and Directions, Positions
-  # 
   # Inside {Wx::AUI}, the docking layout is figured out by checking several pane parameters. Four of these are important for determining where a pane will end up:
   # 
   # - Direction: Each docked pane has a direction, Top, Bottom, Left, Right, or Center. This is fairly self-explanatory. The pane will be placed in the location specified by this variable. 

data/lib/wx/doc/gen/aui/aui_mdi_client_window.rb

@@ -26,12 +26,13 @@ module Wx::AUI
     # @return [Boolean]
     def create_client(parent, style=(Wx::VSCROLL|Wx::HSCROLL)) end
     
-    # Sets the page selection.
+    # Sets the selection to the given page, returning the previous selection.
     # 
-    # Calling this method will generate a page change event.
-    # @param new_page [Integer] 
+    # Notice that the call to this function generates the page changing events, use the {Wx::AUI::AuiMDIClientWindow#change_selection} function if you don't want these events to be generated.
+    # @see Wx::AUI::AuiMDIClientWindow#get_selection 
+    # @param page [Integer] 
     # @return [Integer]
-    def set_selection(new_page) end
+    def set_selection(page) end
     alias_method :selection=, :set_selection
     
     # @return [Wx::AUI::AuiMDIChildFrame]

data/lib/wx/doc/gen/aui/aui_tool_bar_event.rb

@@ -6,6 +6,26 @@
 
 module Wx::AUI
 
+  # 
+  # 
+  EVT_AUITOOLBAR_TOOL_DROPDOWN = 10406
+  
+  # 
+  # 
+  EVT_AUITOOLBAR_OVERFLOW_CLICK = 10407
+  
+  # 
+  # 
+  EVT_AUITOOLBAR_RIGHT_CLICK = 10408
+  
+  # 
+  # 
+  EVT_AUITOOLBAR_MIDDLE_CLICK = 10409
+  
+  # 
+  # 
+  EVT_AUITOOLBAR_BEGIN_DRAG = 10410
+  
   # {Wx::AUI::AuiToolBarStyle} is part of the {Wx::AUI} class framework, used to define the appearance of a {Wx::AUI::AuiToolBar}.
   # 
   # See also wxAUI Overview.
@@ -111,26 +131,6 @@ module Wx::AUI
     
   end # AuiToolBarToolTextOrientation
   
-  # 
-  # 
-  EVT_AUITOOLBAR_TOOL_DROPDOWN = 10406
-  
-  # 
-  # 
-  EVT_AUITOOLBAR_OVERFLOW_CLICK = 10407
-  
-  # 
-  # 
-  EVT_AUITOOLBAR_RIGHT_CLICK = 10408
-  
-  # 
-  # 
-  EVT_AUITOOLBAR_MIDDLE_CLICK = 10409
-  
-  # 
-  # 
-  EVT_AUITOOLBAR_BEGIN_DRAG = 10410
-  
   # {Wx::AUI::AuiToolBarEvent} is used for the events generated by {Wx::AUI::AuiToolBar}.
   # 
   # Category:  Window Docking (wxAUI), {Wx::Events}

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

@@ -55,7 +55,6 @@ module Wx
   # You can retrieve the current system colour settings with {Wx::SystemSettings}.
   # 
   # ## Channel Accessor Functions
-  # 
   # Note that this class provides pairs of functions for each of the colour channels, i.e. red, green, blue and alpha values. The one word functions {Wx::Colour#red}, {Wx::Colour#green}, {Wx::Colour#blue} and {Wx::Colour#alpha} return the values of type unsigned char, while {Wx::Colour#get_red}, {Wx::Colour#get_green}, {Wx::Colour#get_blue} and {Wx::Colour#get_alpha} returns the same value as unsigned int. According to the C++ integer promotion rules, the result of any arithmetic expression involving the former will be (signed) int, while that of the latter will be unsigned, which is what would be commonly expected, so the latter family of functions should be typically preferred (but they are only available since wxWidgets 3.1.6).
   # 
   # Category:  Graphics Device Interface (GDI)

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

@@ -68,7 +68,7 @@ module Wx
     # @return [Wx::ColourDialog]
     def initialize(parent, data=nil) end
     
-    # Same as {colour_dialog}.
+    # Same as {Wx::ColourDialog#initialize}.
     # @param parent [Wx::Window] 
     # @param data [Wx::ColourData] 
     # @return [Boolean]

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

@@ -228,9 +228,10 @@ module Wx
     def get_string(n) end
     alias_method :string, :get_string
     
-    # Gets the text currently selected in the control.
+    # Returns the label of the selected item or an empty string if no item is selected.
     # 
-    # If there is no selection, the returned string is empty.
+    # 
+    # @see Wx::ComboBox#get_selection 
     # @return [String]
     def get_string_selection; end
     alias_method :string_selection, :get_string_selection

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

@@ -19,93 +19,96 @@ module Wx
   # In addition it has other customization features. For instance, position and size of the dropdown button can be changed.
   # 
   # ## Setting Custom Popup for wxComboCtrl
-  # 
   # {Wx::ComboCtrl} needs to be told somehow which control to use and this is done by {Wx::ComboCtrl#set_popup_control}. However, we need something more than just a {Wx::Control} in this method as, for example, we need to call SetStringValue("initial text value") and {Wx::Control} doesn't have such method. So we also need a {Wx::ComboPopup} which is an interface which must be implemented by a control to be usable as a popup.
   # We couldn't derive {Wx::ComboPopup} from {Wx::Control} as this would make it impossible to have a class deriving from a wxWidgets control and from it, so instead it is just a mix-in.
   # Here's a minimal sample of {Wx::ListView} popup:
   # 
-  # ```
-  #   \#include <wx/combo.h>
-  #   \#include <wx/listctrl.h>
-  #   
-  #   class wxListViewComboPopup : public wxListView, public wxComboPopup
-  #   {
-  #   public:
-  #       // Initialize member variables
-  #       virtual void Init()
-  #       {
-  #           m_value = -1;
-  #       }
-  #   
-  #       // Create popup control
-  #       virtual bool Create(wxWindow* parent)
-  #       {
-  #           return wxListView::Create(parent,1,wxPoint(0,0),wxDefaultSize);
-  #       }
-  #   
-  #       // Return pointer to the created control
-  #       virtual wxWindow *GetControl() { return this; }
-  #   
-  #       // Translate string into a list selection
-  #       virtual void SetStringValue(const wxString& s)
-  #       {
-  #           int n = wxListView::FindItem(-1,s);
-  #           if ( n >= 0 && n < wxListView::GetItemCount() )
-  #               wxListView::Select(n);
-  #       }
+  # ```ruby
+  # class ListViewComboPopup < Wx::ListView
+  # 
+  #   include Wx::ComboPopup
   #   
-  #       // Get list selection as a string
-  #       virtual wxString GetStringValue() const
-  #       {
-  #           if ( m_value >= 0 )
-  #           return wxListView::GetItemText(m_value);
-  #           return wxEmptyString;
-  #       }
+  #   # Allow only default ctor
+  #   def initialize
+  #     # call default control ctor; need to call Wx::ListView#create later
+  #     super
+  #   end
   #   
-  #       // Do mouse hot-tracking (which is typical in list popups)
-  #       void OnMouseMove(wxMouseEvent& event)
-  #       {
-  #           // TODO: Move selection to cursor
-  #       }
+  #   # Initialize member variables
+  #   def init
+  #     @value = -1
+  #   end
   #   
-  #       // On mouse left up, set the value and close the popup
-  #       void OnMouseClick(wxMouseEvent& WXUNUSED(event))
-  #       {
-  #           m_value = wxListView::GetFirstSelected();
+  #   # Create popup control
+  #   def create(parent)
+  #     # need to finish creating the list view here
+  #     # as calling super here would just call Wx::ComboPopup#create and not Wx::ListView#create
+  #     # we need to use Ruby magic
+  #     wx_lv_create = (Wx::ListView.instance_method :create).bind(self)
+  #     wx_lv_create.call(parent, 1, [0,0], Wx::DEFAULT_SIZE)
+  #     evt_motion :on_mouse_move
+  #     evt_left_up :on_mouse_click
+  #     end
   #   
-  #           // TODO: Send event as well
+  #   # Return pointer to the created control
+  #   def get_control
+  #     self
+  #   end
   #   
-  #           Dismiss();
-  #       }
+  #   def lv_find_item(*args)
+  #     unless @wx_lv_find_item
+  #     @wx_lv_find_item = (Wx::ListView.instance_method :find_item).bind(self)
+  #     end
+  #     @wx_lv_find_item.call(*args)
+  #   end
+  #   protected :lv_find_item
   #   
-  #   protected:
+  #   # Translate string into a list selection
+  #   def set_string_value(s)
+  #     n = lv_find_item(-1, s)
+  #     if n >= 0 && n < get_item_count
+  #       select(n)
+  #       @value = n
+  #     end
+  #   end
   #   
-  #       int m_value; // current item index
+  #   # Get list selection as a string
+  #   def get_string_value
+  #     return get_item_text(@value) if @value >= 0
+  #     ''
+  #   end
   #   
-  #   private:
-  #       wxDECLARE_EVENT_TABLE();
-  #   };
+  #   # Do mouse hot-tracking (which is typical in list popups)
+  #   def on_mouse_move(event)
+  #     # Move selection to cursor ...
+  #   end
   #   
-  #   wxBEGIN_EVENT_TABLE(wxListViewComboPopup, wxListView)
-  #       EVT_MOTION(wxListViewComboPopup::OnMouseMove)
-  #       EVT_LEFT_UP(wxListViewComboPopup::OnMouseClick)
-  #   wxEND_EVENT_TABLE()
+  #   # On mouse left up, set the value and close the popup
+  #   def on_mouse_click(_event)
+  #     @value = get_first_selected
+  #     
+  #     # Send event as well ...
+  #     
+  #     dismiss
+  #   end
+  # 
+  # end
   # ```
   # 
   # Here's how you would create and populate it in a dialog constructor:
   # 
-  # ```
-  #   wxComboCtrl* comboCtrl = new wxComboCtrl(this, wxID_ANY, wxEmptyString);
+  # ```ruby
+  #   comboCtrl = Wx::ComboCtrl.new(self, Wx::ID_ANY, '')
   #   
-  #   wxListViewComboPopup* popupCtrl = new wxListViewComboPopup();
+  #   popupCtrl = ListViewComboPopup.new
   #   
-  #   // It is important to call SetPopupControl() as soon as possible
-  #   comboCtrl->SetPopupControl(popupCtrl);
+  #   # It is important to call #set_popup_control as soon as possible
+  #   comboCtrl.set_popup_control(popupCtrl)
   #   
-  #   // Populate using wxListView methods
-  #   popupCtrl->InsertItem(popupCtrl->GetItemCount(), "First Item");
-  #   popupCtrl->InsertItem(popupCtrl->GetItemCount(), "Second Item");
-  #   popupCtrl->InsertItem(popupCtrl->GetItemCount(), "Third Item");
+  #   # Populate using Wx::ListView methods
+  #   popupCtrl.insert_item((popupCtrl.item_count, 'First Item')
+  #   popupCtrl.insert_item((popupCtrl.item_count, 'Second Item')
+  #   popupCtrl.insert_item((popupCtrl.item_count, 'Third Item')
   # ```
   # 
   # ### Styles
@@ -231,7 +234,7 @@ module Wx
     # Prepare background of combo control or an item in a dropdown list in a way typical on platform.
     # 
     # This includes painting the focus/disabled background and setting the clipping region.
-    # Unless you plan to paint your own focus indicator, you should always call this in your {Wx::ComboPopup#paint_combo_control} implementation. In addition, it sets pen and text colour to what looks good and proper against the background.
+    # Unless you plan to paint your own focus indicator, you should always call this in your {Wx::ComboPopup::PaintComboControl} implementation. In addition, it sets pen and text colour to what looks good and proper against the background.
     # flags: {Wx::RendererNative} flags: {Wx::CONTROL_ISSUBMENU}: is drawing a list item instead of combo control {Wx::CONTROL_SELECTED}: list item is selected {Wx::CONTROL_DISABLED}: control/item is disabled
     # @param dc [Wx::DC] 
     # @param rect [Wx::Rect] 
@@ -456,23 +459,23 @@ module Wx
     # By default, combo controls without {Wx::CB_READONLY} style create a {Wx::TextCtrl} which shows the current value and allows to edit it. This method allows to use some other window instead of this {Wx::TextCtrl}.
     # This method can be called after creating the combo fully, however in this case a {Wx::TextCtrl} is unnecessarily created just to be immediately destroyed when it's replaced by a custom window. If you wish to avoid this, you can use the following approach, also shown in the combo sample:
     # 
-    # ```
-    #   // Create the combo control using its default ctor.
-    #   wxComboCtrl* combo = new wxComboCtrl();
+    # ```ruby
+    #   # Create the combo control using its default ctor.
+    #   combo = Wx::ComboCtrl.new
     #   
-    #   // Create the custom main control using its default ctor too.
-    #   SomeWindow* main = new SomeWindow();
+    #   # Create the custom main control using its default ctor too.
+    #   main = SomeWindow.new
     #   
-    #   // Set the custom main control before creating the combo.
-    #   combo->SetMainControl(main);
+    #   # Set the custom main control before creating the combo.
+    #   combo.set_main_control(main)
     #   
-    #   // And only create it now: wxTextCtrl won't be unnecessarily
-    #   // created because the combo already has a main window.
-    #   combo->Create(panel, wxID_ANY, wxEmptyString);
+    #   # And only create it now: Wx::TextCtrl won't be unnecessarily
+    #   # created because the combo already has a main window.
+    #   combo.create(panel, Wx::ID_ANY, '')
     #   
-    #   // Finally create the main window itself, now that its parent was
-    #   // created.
-    #   main->Create(combo, ...);
+    #   # Finally create the main window itself, now that its parent was
+    #   # created.
+    #   main.create(combo, ...)
     # ```
     # 
     # Note that when a custom main window is used, none of the methods of this class inherited from {Wx::TextEntry}, such as {Wx::ComboCtrl#set_value}, {Wx::ComboCtrl#replace}, {Wx::ComboCtrl#set_insertion_point} etc do anything and simply return.
@@ -492,10 +495,9 @@ module Wx
     # Set popup interface class derived from {Wx::ComboPopup}.
     # 
     # This method should be called as soon as possible after the control has been created, unless {Wx::ComboCtrl#on_button_click} has been overridden.
-    # @param popup [Wx::ComboPopup] 
+    # @param popup [Wx::ComboPopup,nil] 
     # @return [void]
     def set_popup_control(popup) end
-    alias_method :popup_control=, :set_popup_control
     
     # Extends popup size horizontally, relative to the edges of the combo control.
     # 
@@ -553,13 +555,13 @@ module Wx
     # 
     # Usually you will need to use this during two-step creation, just before {Wx::ComboCtrl#create}. For example:
     # 
-    # ```
-    #   wxComboCtrl* comboCtrl = new wxComboCtrl();
+    # ```ruby
+    #   comboCtrl = Wx::ComboCtrl.new
     #   
-    #   // Let's make the text right-aligned
-    #   comboCtrl->SetTextCtrlStyle(wxTE_RIGHT);
+    #   # Let's make the text right-aligned
+    #   comboCtrl.set_text_ctrl_style(Wx::TE_RIGHT)
     #   
-    #   comboCtrl->Create(parent, wxID_ANY, wxEmptyString);
+    #   comboCtrl.create(parent, Wx::ID_ANY, '')
     # ```
     # @param style [Integer] 
     # @return [void]
@@ -626,7 +628,7 @@ module Wx
     # <p>If you have implemented {Wx::ComboCtrl#on_button_click} to do something else than show the popup, then {Wx::ComboCtrl#do_set_popup_control} must always set popup to NULL. 
     # </p>
     # </div>
-    # @param popup [Wx::ComboPopup] 
+    # @param popup [Wx::ComboPopup,nil] 
     # @return [void]
     def do_set_popup_control(popup) end
     
@@ -640,143 +642,5 @@ module Wx
     
   end # ComboCtrl
   
-  # In order to use a custom popup with {Wx::ComboCtrl}, an interface class must be derived from {Wx::ComboPopup}.
-  # 
-  # For more information on how to use it, see Setting Custom Popup for wxComboCtrl.
-  # 
-  # Category:  {Wx::Controls}
-  # @see Wx::ComboCtrl 
-  # 
-  # 
-  # 
-  # @note  In wxRuby this is a mixin module instead of a (base) class.
-  # @wxrb_require USE_COMBOCTRL
-  module ComboPopup
-  
-    # Default constructor.
-    # 
-    # It is recommended that internal variables are prepared in {Wx::ComboPopup#init} instead (because m_combo is not valid in constructor).
-    # @return [Wx::ComboPopup]
-    def initialize; end
-    
-    # The derived class must implement this to create the popup control.
-    # 
-    # true if the call succeeded, false otherwise.
-    # @param parent [Wx::Window] 
-    # @return [Boolean]
-    def create(parent) end
-    
-    # You only need to implement this member function if you create your popup class in non-standard way.
-    # 
-    # The default implementation can handle both multiple-inherited popup control (as seen in {Wx::ComboCtrl} samples) and one allocated separately in heap.
-    # If you do completely re-implement this function, make sure it calls Destroy() for the popup control and also deletes this object (usually as the last thing).
-    # @return [void]
-    def destroy_popup; end
-    
-    # Utility function that hides the popup.
-    # @return [void]
-    def dismiss; end
-    
-    # Implement to customize matching of value string to an item container entry.
-    # 
-    # <div class="wxrb-remark">
-    # <b>Remark:</b>
-    # <p>Default implementation always return true and does not alter trueItem. 
-    # </p>
-    # </div>
-    # @param item [String]  String entered, usually by user or from SetValue() call.
-    # @param trueItem [String]  When item matches an entry, but the entry's string representation is not exactly the same (case mismatch, for example), then the true item string should be written back to here, if it is not a NULL pointer.
-    # @return [Boolean]
-    def find_item(item, trueItem=nil) end
-    
-    # The derived class may implement this to return adjusted size for the popup control, according to the variables given.
-    # 
-    # <div class="wxrb-remark">
-    # <b>Remark:</b>
-    # <p>This function is called each time popup is about to be shown. 
-    # </p>
-    # </div>
-    # @param minWidth [Integer]  Preferred minimum width.
-    # @param prefHeight [Integer]  Preferred height. May be -1 to indicate no preference.
-    # @param maxHeight [Integer]  Max height for window, as limited by screen size.
-    # @return [Wx::Size]
-    def get_adjusted_size(minWidth, prefHeight, maxHeight) end
-    alias_method :adjusted_size, :get_adjusted_size
-    
-    # Returns pointer to the associated parent {Wx::ComboCtrl}.
-    # @return [Wx::ComboCtrl]
-    def get_combo_ctrl; end
-    alias_method :combo_ctrl, :get_combo_ctrl
-    
-    # The derived class must implement this to return pointer to the associated control created in {Wx::ComboPopup#create}.
-    # @return [Wx::Window]
-    def get_control; end
-    alias_method :control, :get_control
-    
-    # The derived class must implement this to return string representation of the value.
-    # @return [String]
-    def get_string_value; end
-    alias_method :string_value, :get_string_value
-    
-    # The derived class must implement this to initialize its internal variables.
-    # 
-    # This method is called immediately after construction finishes. m_combo member variable has been initialized before the call.
-    # @return [void]
-    def init; end
-    
-    # Utility method that returns true if Create has been called.
-    # 
-    # Useful in conjunction with {Wx::ComboPopup#lazy_create}.
-    # @return [Boolean]
-    def is_created; end
-    alias_method :created?, :is_created
-    
-    # The derived class may implement this to return true if it wants to delay call to {Wx::ComboPopup#create} until the popup is shown for the first time.
-    # 
-    # It is more efficient, but on the other hand it is often more convenient to have the control created immediately.
-    # 
-    # <div class="wxrb-remark">
-    # <b>Remark:</b>
-    # <p>Base implementation returns false. 
-    # </p>
-    # </div>
-    # @return [Boolean]
-    def lazy_create; end
-    
-    # The derived class may implement this to do something when the parent {Wx::ComboCtrl} gets double-clicked.
-    # @return [void]
-    def on_combo_double_click; end
-    
-    # The derived class may implement this to receive key events from the parent {Wx::ComboCtrl}.
-    # 
-    # Events not handled should be skipped, as usual.
-    # @param event [Wx::KeyEvent] 
-    # @return [void]
-    def on_combo_key_event(event) end
-    
-    # The derived class may implement this to do special processing when popup is hidden.
-    # @return [void]
-    def on_dismiss; end
-    
-    # The derived class may implement this to do special processing when popup is shown.
-    # @return [void]
-    def on_popup; end
-    
-    # The derived class may implement this to paint the parent {Wx::ComboCtrl}.
-    # 
-    # Default implementation draws value as string.
-    # @param dc [Wx::DC] 
-    # @param rect [Wx::Rect] 
-    # @return [void]
-    def paint_combo_control(dc, rect) end
-    
-    # The derived class must implement this to receive string value changes from {Wx::ComboCtrl}.
-    # @param value [String] 
-    # @return [void]
-    def set_string_value(value) end
-    alias_method :string_value=, :set_string_value
-    
-  end # ComboPopup
-  
 
 end

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

@@ -7,7 +7,7 @@
 module Wx
 
   # wxRuby version string
-  Wx::WXRUBY_VERSION = '0.9.4'
+  Wx::WXRUBY_VERSION = '0.9.5'
 
   # wxRuby version release type (alpha, beta, rc)
   Wx::WXRUBY_RELEASE_TYPE = ''
@@ -16,7 +16,7 @@ module Wx
   # wxRuby minor version number
   Wx::WXRUBY_MINOR = 9
   # wxRuby release number
-  Wx::WXRUBY_RELEASE = 4
+  Wx::WXRUBY_RELEASE = 5
 
   # Convenience string for WxWidgets version info
   WXWIDGETS_VERSION = '3.2.4'

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

@@ -139,18 +139,15 @@ module Wx
   # Beginning with wxWidgets 2.9.0 the entire {Wx::DC} code has been reorganized. All platform dependent code (actually all drawing code) has been moved into backend classes which derive from a common {Wx::DCImpl} class. The user-visible classes such as {Wx::ClientDC} and {Wx::PaintDC} merely forward all calls to the backend implementation.
   # 
   # ## Device and logical units
-  # 
   # In the {Wx::DC} context there is a distinction between logical units and device units.
   # <b>Device</b> units are the units native to the particular device; e.g. for a screen, a device unit is a pixel. For a printer, the device unit is defined by the resolution of the printer (usually given in DPI: dot-per-inch).
   # All {Wx::DC} functions use instead <b>logical</b> units, unless where explicitly stated. Logical units are arbitrary units mapped to device units using the current mapping mode (see {Wx::DC#set_map_mode}).
   # This mechanism allows reusing the same code which prints on e.g. a window on the screen to print on e.g. a paper.
   # 
   # ## Support for Transparency / Alpha Channel
-  # 
   # In general {Wx::DC} methods don't support alpha transparency and the alpha component of {Wx::Colour} is simply ignored and you need to use {Wx::GraphicsContext} for full transparency support. There are, however, a few exceptions: first, under macOS and GTK+ 3 colours with alpha channel are supported in all the normal {Wx::DC}-derived classes as they use {Wx::GraphicsContext} internally. Second, under all platforms {Wx::SVGFileDC} also fully supports alpha channel. In both of these cases the instances of {Wx::Pen} or {Wx::Brush} that are built from {Wx::Colour} use the colour's alpha values when stroking or filling.
   # 
   # ## Support for Transformation Matrix
-  # 
   # On some platforms (currently under MSW, GTK+ 3, macOS) {Wx::DC} has support for applying an arbitrary affine transformation matrix to its coordinate system (since 3.1.1 this feature is also supported by {Wx::GCDC} in all ports). Call {Wx::DC#can_use_transform_matrix} to check if this support is available and then call {Wx::DC#set_transform_matrix} if it is. If the transformation matrix is not supported, {Wx::DC#set_transform_matrix} always simply returns false and doesn't do anything.
   # This feature is only available when {Wx::Setup::USE_DC_TRANSFORM_MATRIX} build option is enabled.
   # 

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

@@ -52,7 +52,6 @@ module Wx
   # Also notice that the {Wx::Dialog#create_button_sizer} should be used to create the buttons appropriate for the current platform and positioned correctly (including their order which is platform-dependent).
   # 
   # ## Modal and Modeless
-  # 
   # There are two kinds of dialog, modal and modeless. A modal dialog blocks program flow and user input on other windows until it is dismissed, whereas a modeless dialog behaves more like a frame in that program flow continues, and input in other windows is still possible. To show a modal dialog you should use the {Wx::Dialog#show_modal} method while to show a dialog modelessly you simply use {Wx::Dialog#show}, just as with frames.
   # Note that dialogs need to be explicitly destroyed when closed and not used anymore. The traditional code for this would be like:
   # 

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

@@ -22,7 +22,6 @@ module Wx
   # Category:  {Wx::Events}
   # 
   # ## Delayed Action Mechanism
-  # 
   # {Wx::IdleEvent} can be used to perform some action "at slightly later time". This can be necessary in several circumstances when, for whatever reason, something can't be done in the current event handler. For example, if a mouse event handler is called with the mouse button pressed, the mouse can be currently captured and some operations with it  notably capturing it again  might be impossible or lead to undesirable results. If you still want to capture it, you can do it from {Wx::EVT_IDLE} handler when it is called the next time instead of doing it immediately.
   # This can be achieved in two different ways: when using static event tables, you will need a flag indicating to the (always connected) idle event handler whether the desired action should be performed. The originally called handler would then set it to indicate that it should indeed be done and the idle handler itself would reset it to prevent it from doing the same action again.
   # Using dynamically connected event handlers things are even simpler as the original event handler can simply {Wx::EvtHandler#connect} or {Wx::EvtHandler#bind} the idle event handler which would only be executed then and could {Wx::EvtHandler#disconnect} or {Wx::EvtHandler#unbind} itself.
@@ -107,7 +106,6 @@ module Wx
   # Note that scrolled windows send the {Wx::ScrollWinEvent} which does not derive from {Wx::CommandEvent}, but from {Wx::Event} directly - don't confuse these two kinds of events and use the event table macros mentioned below only for the scrollbar-like controls.
   # 
   # ## The difference between EVT_SCROLL_THUMBRELEASE and EVT_SCROLL_CHANGED
-  # 
   # The EVT_SCROLL_THUMBRELEASE event is only emitted when actually dragging the thumb using the mouse and releasing it (This EVT_SCROLL_THUMBRELEASE event is also followed by an EVT_SCROLL_CHANGED event).
   # The EVT_SCROLL_CHANGED event also occurs when using the keyboard to change the thumb position, and when clicking next to the thumb (In all these cases the EVT_SCROLL_THUMBRELEASE event does not happen).
   # In short, the EVT_SCROLL_CHANGED event is triggered when scrolling/ moving has finished independently of the way it had started. Please see the Widgets Sample ("Slider" page) to see the difference between EVT_SCROLL_THUMBRELEASE and EVT_SCROLL_CHANGED in action.
@@ -1612,14 +1610,6 @@ module Wx
     # 
     class Reason < Wx::Enum
     
-      # Window activated by mouse click.
-      # 
-      Reason_Mouse = Wx::ActivateEvent::Reason.new(0)
-      
-      # Window was activated with some other method than mouse click.
-      # 
-      Reason_Unknown = Wx::ActivateEvent::Reason.new(1)
-      
     end # Reason
     
     # Constructor.
@@ -1628,7 +1618,7 @@ module Wx
     # @param id [Integer] 
     # @param activationReason [Wx::ActivateEvent::Reason] 
     # @return [Wx::ActivateEvent]
-    def initialize(eventType=Wx::EVT_NULL, active=true, id=0, activationReason=Wx::ActivateEvent::Reason::Reason_Unknown) end
+    def initialize(eventType=Wx::EVT_NULL, active=true, id=0, activationReason=REASON_UNKNOWN) end
     
     # Returns true if the application or window is being activated, false otherwise.
     # @return [Boolean]
@@ -2672,18 +2662,6 @@ module Wx
     # 
     class Origin < Wx::Enum
     
-      # unrecognized event source.
-      # 
-      Origin_Unknown = Wx::HelpEvent::Origin.new(0)
-      
-      # event generated from F1 key press.
-      # 
-      Origin_Keyboard = Wx::HelpEvent::Origin.new(1)
-      
-      # event generated by {Wx::ContextHelp} or from the [?] button on the title bar (Windows).
-      # 
-      Origin_HelpButton = Wx::HelpEvent::Origin.new(2)
-      
     end # Origin
     
     # Constructor.
@@ -2692,7 +2670,7 @@ module Wx
     # @param pt [Array(Integer, Integer), Wx::Point] 
     # @param origin [Wx::HelpEvent::Origin] 
     # @return [Wx::HelpEvent]
-    def initialize(type=Wx::EVT_NULL, winid=0, pt=Wx::DEFAULT_POSITION, origin=Wx::HelpEvent::Origin::Origin_Unknown) end
+    def initialize(type=Wx::EVT_NULL, winid=0, pt=Wx::DEFAULT_POSITION, origin=ORIGIN_UNKNOWN) end
     
     # Returns the origin of the help event which is one of the {Wx::HelpEvent::Origin} values.
     # 

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

@@ -108,7 +108,6 @@ module Wx
   # ```
   # 
   # ## Wildcard Filters
-  # 
   # All implementations of the {Wx::FileDialog} provide a wildcard filter. Typing a filename containing wildcards (*, ?) in the filename text item, and clicking on Ok, will result in only those files matching the pattern being displayed. The wildcard may be a specification for multiple types of file with a description for each, such as: 
   # ```
   #   "BMP and GIF files (*.bmp;*.gif)|*.bmp;*.gif|PNG files (*.png)|*.png"
@@ -121,7 +120,6 @@ module Wx
   #  But in contrast to Windows and Unix, where the file type choice filters only the selected files, on Mac macOS even in this case the dialog shows all files matching all file types. The files which does not match the currently selected file type are greyed out and are not selectable.
   # 
   # ## Dialog Customization
-  # 
   # Uniquely among the other standard dialogs, {Wx::FileDialog} can be customized by adding extra controls to it. Moreover, there are two ways to do it: the first one is to define a callback function and use {Wx::FileDialog#set_extra_control_creator} to tell the dialog to call it, while the second one requires defining a class inheriting from {Wx::FileDialogCustomizeHook} and implementing its virtual functions, notably {Wx::FileDialogCustomizeHook#add_custom_controls} where the extra controls have to be created, and finally calling {Wx::FileDialog#set_customize_hook} with this custom hook object.
   # The first approach is somewhat simpler and more flexible, as it allows to create any kind of custom controls, but is not supported by the "new style" (where "new" means used since Windows Vista, i.e. circa 2007) file dialogs under MSW. Because of this, calling {Wx::FileDialog#set_extra_control_creator} in WXMSW forces the use of old style (Windows XP) dialogs, that may look out of place. The second approach is implemented by the MSW dialogs natively and doesn't suffer from this limitation, so its use is recommended, especially if the few simple control types supported by it (see {Wx::FileDialogCustomize} for more information about the supported controls) are sufficient for your needs.
   # Both of the approaches to the dialog customization are demonstrated in the Dialogs Sample, please check it for more details.