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

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

@@ -0,0 +1,159 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Base class for customization hooks used with {Wx::FileDialog}.
+  # {Wx::FileDialogCustomizeHook} is an abstract base class, i.e. in order to use a concrete class inheriting from it and implementing its pure virtual {Wx::FileDialogCustomizeHook#add_custom_controls} function must be defined. Then an object of this class should be passed to {Wx::FileDialog#set_customize_hook}, which will result in its {Wx::FileDialogCustomizeHook#add_custom_controls} being called before the dialog is shown, {Wx::FileDialogCustomizeHook#update_custom_controls} being called whenever something changes in the dialog while it is shown and, finally, {Wx::FileDialogCustomizeHook#transfer_data_from_custom_controls} being called when the user accepts their choice in the dialog.
+  # Putting all this together, here is an example of customizing the file dialog using this class: 
+  # ```
+  #   class EncryptHook : public wxFileDialogCustomizeHook
+  #   {
+  #   public:
+  #       // Override to add custom controls using the provided customizer object.
+  #       void AddCustomControls(wxFileDialogCustomize& customizer) override
+  #       {
+  #           // Suppose we can encrypt files when saving them.
+  #           m_checkbox = customizer.AddCheckBox("Encrypt");
+  #   
+  #           // While m_checkbox is not a wxCheckBox, it looks almost like one
+  #           // and, in particular, we can bind to custom control events as usual.
+  #           m_checkbox->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent& event) {
+  #               // We can also call wxWindow-like functions on them.
+  #               m_button->Enable(event.IsChecked());
+  #           });
+  #   
+  #           // The encryption parameters can be edited in a dedicated dialog.
+  #           m_button = customizer.AddButton("Parameters...");
+  #           m_button->Bind(wxEVT_BUTTON, [](wxCommandEvent&) {
+  #               ... show the encryption parameters dialog here ...
+  #           });
+  #       }
+  #   
+  #       // Override to save the values of the custom controls.
+  #       void TransferDataFromCustomControls() override
+  #       {
+  #           // Save the checkbox value, as we won't be able to use it any more
+  #           // once this function returns.
+  #           m_encrypt = m_checkbox->GetValue();
+  #       }
+  #   
+  #       // Just a simple accessor to get the results.
+  #       bool Encrypt() const { return m_encrypt; }
+  #   
+  #   private:
+  #       wxFileDialogButton* m_button;
+  #       wxFileDialogCheckBox* m_checkbox;
+  #   
+  #       bool m_encrypt = false;
+  #   };
+  #   
+  #   void SomeFunc()
+  #   {
+  #       wxFileDialog dialog(NULL, "Save document", wxString(), "file.my",
+  #                           "My files (*.my)|*.my",
+  #                           wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
+  #   
+  #       // This object may be destroyed before the dialog, but must remain
+  #       // alive until ShowModal() returns.
+  #       EncryptHook customizeHook;
+  #       dialog.SetCustomizeHook(customHook);
+  #   
+  #       if ( dialog.ShowModal() == wxID_OK )
+  #       {
+  #           if ( customizeHook.Encrypt() )
+  #               ... save with encryption ...
+  #           else
+  #               ... save without encryption ...
+  #       }
+  #   }
+  # ```
+  # 
+  # === 
+  # 
+  # Category:  Common Dialogs
+  # @see Wx::FileDialog
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class FileDialogCustomizeHook < ::Object
+  
+    # Must be overridden to add custom controls to the dialog using the provided customizer object.
+    # Call {Wx::FileDialogCustomize} functions to add controls and possibly bind to their events.
+    # Note that there is no possibility to define the custom controls layout, they will appear more or less consecutively, but the exact layout is determined by the current platform.
+    # @param customizer [Wx::FileDialogCustomize] 
+    # @return [void]
+    def add_custom_controls(customizer) end
+    
+    # May be overridden to update the custom controls whenever something changes in the dialog.
+    # This function is called when the user selects a file, changes the directory or changes the current filter in the dialog, for example. It can be used to update the custom controls state depending on the currently selected file, for example.
+    # Note that it is not necessarily called when the value of a custom control changes.
+    # Base class version does nothing.
+    # @return [void]
+    def update_custom_controls; end
+    
+    # Should typically be overridden to save the values of the custom controls when the dialog is accepted.
+    # Custom controls are destroyed and cannot be used any longer once {Wx::FileDialog#show_modal} returns, so their values must be retrieved in this function, which is called just before this happens.
+    # This function is not called if the user cancels the dialog.
+    # Base class version does nothing.
+    # @return [void]
+    def transfer_data_from_custom_controls; end
+    
+  end # FileDialogCustomizeHook
+  
+  # Used with {Wx::FileDialogCustomizeHook} to add custom controls to {Wx::FileDialog}.
+  # An object of this class is passed to {Wx::FileDialogCustomizeHook#add_custom_controls} to allow it to actually add controls to the dialog.
+  # The pointers returned by the functions of this class belong to wxWidgets and should not be deleted by the application, just as {Wx::Window}-derived objects (even if these controls do not inherit from {Wx::Window}). These pointers become invalid when {Wx::FileDialog#show_modal} returns, and the dialog containing them is destroyed, and the latest point at which they can be still used is when {Wx::FileDialogCustomizeHook#transfer_data_from_custom_controls} is called.
+  # === 
+  # 
+  # Category:  Common Dialogs
+  # @see Wx::FileDialog
+  # 
+  # 
+  class FileDialogCustomize < ::Object
+  
+    # Add a button with the specified label.
+    # @param label [String] 
+    # @return [Wx::FileDialogButton]
+    def add_button(label) end
+    
+    # Add a checkbox with the specified label.
+    # @param label [String] 
+    # @return [Wx::FileDialogCheckBox]
+    def add_check_box(label) end
+    
+    # Add a radio button with the specified label.
+    # The first radio button added will be initially checked. All the radio buttons added immediately after it will become part of the same radio group and will not be checked, but checking any one of them later will uncheck the first button and all the other ones.
+    # If two consecutive but distinct radio groups are required, {Wx::FileDialogCustomize#add_static_text} with an empty label can be used to separate them.
+    # @param label [String] 
+    # @return [Wx::FileDialogRadioButton]
+    def add_radio_button(label) end
+    
+    # Add a read-only combobox with the specified contents.
+    # The combobox doesn't have any initial selection, i.e. {Wx::FileDialogChoice#get_selection} returns {Wx::NOT_FOUND}, if some item must be selected, use {Wx::FileDialogChoice#set_selection} explicitly to do it.
+    # @param n [Integer]  The number of strings, must be positive, as there is no way to add more strings later and creating an empty combobox is not very useful.
+    # @param strings [String]  A non-NULL pointer to an array of n strings.
+    # @return [Wx::FileDialogChoice]
+    def add_choice(n, strings) end
+    
+    # Add a text control with an optional label preceding it.
+    # Unlike all the other functions for adding controls, the label parameter here doesn't specify the contents of the text control itself, but rather the label appearing before it. Unlike static controls added by {Wx::FileDialogCustomize#add_static_text}, this label is guaranteed to be immediately adjacent to it.
+    # If label is empty, no label is created.
+    # @param label [String] 
+    # @return [Wx::FileDialogTextCtrl]
+    def add_text_ctrl(label=(())) end
+    
+    # Add a static text with the given contents.
+    # The contents of the static text can be updated later, i.e. it doesn't need to be actually static.
+    # @param label [String] 
+    # @return [Wx::FileDialogStaticText]
+    def add_static_text(label) end
+    
+  end # FileDialogCustomize
+  
+
+end

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

@@ -76,7 +76,7 @@ module Wx
     #   @return [Wx::FileDirPickerEvent]
     # @overload initialize(type, generator, id, path)
     #   The constructor is not normally used by the user code.
-    #   @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
+    #   @param type [Wx::CommandLinkButton::EventType] 
     #   @param generator [Wx::Object] 
     #   @param id [Integer] 
     #   @param path [String] 

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

@@ -49,7 +49,7 @@ module Wx
   
     # @overload initialize()
     #   @return [Wx::FilePickerCtrl]
-    # @overload initialize(parent, id, path=(''), message=Wx::FileSelectorPromptStr, wildcard=Wx::FILE_SELECTOR_DEFAULT_WILDCARD_STR, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::FLP_DEFAULT_STYLE, validator=Wx::DEFAULT_VALIDATOR, name=Wx::FilePickerCtrlNameStr)
+    # @overload initialize(parent, id, path=(''), message=Wx::FILE_SELECTOR_PROMPT_STR, wildcard=Wx::FILE_SELECTOR_DEFAULT_WILDCARD_STR, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::FLP_DEFAULT_STYLE, validator=Wx::DEFAULT_VALIDATOR, name=Wx::FILE_PICKER_CTRL_NAME_STR)
     #   Initializes the object and calls {Wx::FilePickerCtrl#create} with all the parameters.
     #   @param parent [Wx::Window] 
     #   @param id [Integer] 
@@ -76,11 +76,11 @@ module Wx
     # @param style [Integer]  The window style, see {Wx::FLP_}* flags.
     # @param validator [Wx::Validator]  Validator which can be used for additional data checks.
     # @param name [String]  Control name.
-    # @return [true,false]
-    def create(parent, id, path=(''), message=Wx::FileSelectorPromptStr, wildcard=Wx::FILE_SELECTOR_DEFAULT_WILDCARD_STR, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::FLP_DEFAULT_STYLE, validator=Wx::DEFAULT_VALIDATOR, name=Wx::FilePickerCtrlNameStr) end
+    # @return [Boolean]
+    def create(parent, id, path=(''), message=Wx::FILE_SELECTOR_PROMPT_STR, wildcard=Wx::FILE_SELECTOR_DEFAULT_WILDCARD_STR, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::FLP_DEFAULT_STYLE, validator=Wx::DEFAULT_VALIDATOR, name=Wx::FILE_PICKER_CTRL_NAME_STR) end
     
     # Similar to {Wx::FilePickerCtrl#get_path} but returns the path of the currently selected file as a {Wx::FileName} object.
-    # @return [Wx::FileName]
+    # @return [String]
     def get_file_name; end
     alias_method :file_name, :get_file_name
     
@@ -90,7 +90,7 @@ module Wx
     alias_method :path, :get_path
     
     # This method does the same thing as {Wx::FilePickerCtrl#set_path} but takes a {Wx::FileName} object instead of a string.
-    # @param filename [Wx::FileName] 
+    # @param filename [String] 
     # @return [void]
     def set_file_name(filename) end
     alias_method :file_name=, :set_file_name

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

@@ -0,0 +1,250 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # This class provides an interface for opening files on different file systems.
+  # It can handle absolute and/or local filenames.
+  # It uses a system of handlers (see {Wx::FileSystemHandler}) to provide access to user-defined virtual file systems.
+  # === 
+  # 
+  # Category:  Virtual File System
+  # @see Wx::FileSystemHandler
+  # @see  Wx::FSFile
+  # @see  wxFileSystem Overview 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class FileSystem < Object
+  
+    # Constructor.
+    # The initial current path of this object will be empty (i.e. {Wx::FileSystem#get_path} == {Wx::EmptyString}) which means that e.g. {Wx::FileSystem#open_file} or {Wx::FileSystem#find_first} functions will use current working directory as current path (see also {Wx::GetCwd}).
+    # @return [Wx::FileSystem]
+    def initialize; end
+    
+    # Remove a filesystem handler from the list of handlers.
+    # @param handler [Wx::FileSystemHandler] 
+    # @return [Wx::FileSystemHandler]
+    def self.remove_handler(handler) end
+    
+    # Converts a {Wx::FileName} into an URL.
+    # 
+    # @see Wx::FileSystem.url_to_file_name
+    # @see  Wx::FileName 
+    # @param filename [String] 
+    # @return [String]
+    def self.file_name_to_url(filename) end
+    
+    # This static function returns true if there is a registered handler which can open the given location.
+    # @param location [String] 
+    # @return [Boolean]
+    def self.has_handler_for_path(location) end
+    
+    # Converts URL into a well-formed filename.
+    # The URL must use the file protocol.
+    # @param url [String] 
+    # @return [String]
+    def self.url_to_file_name(url) end
+    
+  end # FileSystem
+  
+  # Classes derived from {Wx::FileSystemHandler} are used to access virtual file systems.
+  # Its public interface consists of two methods: {Wx::FileSystemHandler#can_open} and {Wx::FileSystemHandler#open_file}.
+  # It provides additional protected methods to simplify the process of opening the file: {Wx::FileSystemHandler.get_protocol}, {Wx::FileSystemHandler.get_left_location}, {Wx::FileSystemHandler.get_right_location}, {Wx::FileSystemHandler.get_anchor}, {Wx::FileSystemHandler.get_mime_type_from_ext}.
+  # Please have a look at overview (see {Wx::FileSystem}) if you don't know how locations are constructed.
+  # Also consult the list of available handlers.
+  # Note that the handlers are shared by all instances of {Wx::FileSystem}.
+  # {Wx::HTML} library provides handlers for local files and HTTP or FTP protocol.
+  # 
+  # The location parameter passed to {Wx::FileSystemHandler#open_file} or {Wx::FileSystemHandler#can_open} methods is always an absolute path. You don't need to check the FS's current path.
+  # 
+  # === 
+  # 
+  # Category:  Virtual File System
+  # @see Wx::FileSystem
+  # @see  Wx::FSFile
+  # @see  wxFileSystem Overview 
+  # 
+  # 
+  class FileSystemHandler < Object
+  
+    # Constructor.
+    # @return [Wx::FileSystemHandler]
+    def initialize; end
+    
+    # Returns true if the handler is able to open this file.
+    # This function doesn't check whether the file exists or not, it only checks if it knows the protocol. Example:
+    # 
+    # ```
+    #   bool MyHand::CanOpen(const wxString& location)
+    #   {
+    #       return (GetProtocol(location) == "http");
+    #   }
+    # ```
+    # 
+    # Must be overridden in derived handlers.
+    # @param location [String] 
+    # @return [Boolean]
+    def can_open(location) end
+    alias_method :can_open?, :can_open
+    
+    # Works like {find_first_file}.
+    # Returns the name of the first filename (within filesystem's current path) that matches wildcard. flags may be one of {Wx::FILE} (only files), {Wx::DIR} (only directories) or 0 (both).
+    # This method is only called if {Wx::FileSystemHandler#can_open} returns true.
+    # @param wildcard [String] 
+    # @param flags [Integer] 
+    # @return [String]
+    def find_first(wildcard, flags=0) end
+    
+    # Returns next filename that matches parameters passed to {Wx::FileSystem#find_first}.
+    # This method is only called if {Wx::FileSystemHandler#can_open} returns true and {Wx::FileSystemHandler#find_first} returned a non-empty string.
+    # @return [String]
+    def find_next; end
+    
+    # Opens the file and returns {Wx::FSFile} pointer or NULL if failed.
+    # Must be overridden in derived handlers.
+    # @param fs [Wx::FileSystem]  Parent FS (the FS from that OpenFile was called). See the ZIP handler for details of how to use it.
+    # @param location [String]  The absolute location of file.
+    # @return [Wx::FSFile]
+    def open_file(fs, location) end
+    
+    # Returns the MIME type based on <b>extension</b> of location.
+    # (While {Wx::FSFile#get_mime_type} returns real MIME type - either extension-based or queried from HTTP.)
+    # Example: 
+    # ```
+    #   GetMimeTypeFromExt("index.htm") == "text/html"
+    # ```
+    # @param location [String] 
+    # @return [String]
+    def self.get_mime_type_from_ext(location) end
+    
+  end # FileSystemHandler
+  
+  # A file system handler for accessing files inside of archives.
+  # 
+  # 
+  class ArchiveFSHandler < FileSystemHandler
+  
+    # @return [Wx::ArchiveFSHandler]
+    def initialize; end
+    
+    # @return [void]
+    def cleanup; end
+    
+  end # ArchiveFSHandler
+  
+  # This {Wx::FileSystem} handler can store arbitrary data in memory stream and make them accessible via an URL.
+  # It is particularly suitable for storing bitmaps from resources or included XPM files so that they can be used with {Wx::HTML} or {Wx::WebView}.
+  # Filenames are prefixed with <code>"memory:"</code>, e.g. <code>"memory:myfile.html"</code>.
+  # Example:
+  # 
+  # ```
+  #   #ifndef __WXMSW__
+  #   #include "logo.xpm"
+  #   #endif
+  #   
+  #   void MyFrame::OnAbout(wxCommandEvent&)
+  #   {
+  #       wxFileSystem::AddHandler(new wxMemoryFSHandler);
+  #       wxMemoryFSHandler::AddFile("logo.png", wxBITMAP(logo), wxBITMAP_TYPE_PNG);
+  #       wxMemoryFSHandler::AddFile("about.htm",
+  #                               "<html><body>About: "
+  #                               "<img src=\"memory:logo.png\"></body></html>");
+  #   
+  #       wxDialog dlg(this, -1, wxString(_("About")));
+  #       wxBoxSizer *topsizer;
+  #       topsizer = new wxBoxSizer(wxVERTICAL);
+  #   #ifdef USE_WEBVIEW
+  #       wxWebView* browser = wxWebView::New(&dlg, wxID_ANY, wxWebViewDefaultURLStr,
+  #                                wxDefaultPosition, wxSize(380, 160));
+  #       browser->RegisterHandler(wxSharedPtr<wxWebViewHandler>(new wxWebViewFSHandler("memory")));
+  #       browser->LoadURL("memory:about.htm");
+  #   #else // Use wxHtml
+  #       wxHtmlWindow *browser;
+  #       browser = new wxHtmlWindow(&dlg, -1, wxDefaultPosition,
+  #                                  wxSize(380, 160), wxHW_SCROLLBAR_NEVER);
+  #       browser->SetBorders(0);
+  #       browser->LoadPage("memory:about.htm");
+  #       browser->SetSize(browser->GetInternalRepresentation()->GetWidth(),
+  #                   browser->GetInternalRepresentation()->GetHeight());
+  #   #endif
+  #       topsizer->Add(browser, 1, wxALL, 10);
+  #       topsizer->Add(new wxStaticLine(&dlg, -1), 0, wxEXPAND | wxLEFT | wxRIGHT, 10);
+  #       topsizer->Add(new wxButton(&dlg, wxID_OK, "Ok"),
+  #                   0, wxALL | wxALIGN_RIGHT, 15);
+  #       dlg.SetAutoLayout(true);
+  #       dlg.SetSizer(topsizer);
+  #       topsizer->Fit(&dlg);
+  #       dlg.Centre();
+  #       dlg.ShowModal();
+  #   
+  #       wxMemoryFSHandler::RemoveFile("logo.png");
+  #       wxMemoryFSHandler::RemoveFile("about.htm");
+  #   }
+  # ```
+  # 
+  # === 
+  # 
+  # Category:  Virtual File System
+  # @see Wx::MemoryFSHandler.add_file_with_mime_type 
+  # 
+  # 
+  class MemoryFSHandler < FileSystemHandler
+  
+    # @overload self.add_file(filename, image, type)
+    #   Adds a file to the list of the files stored in memory.
+    #   Stored data (bitmap, text or raw data) will be copied into private memory stream and available under name <code>"memory:"</code> + filename.
+    #   When using the overload taking {Wx::String} data, if the string contains only Latin-1 characters (which includes strings created using Wx::String#from8bit_data), its data is used as is. Otherwise, the UTF-8 representation of the string is stored as the data associated with the given filename.
+    #   you must use a type value (aka image format) that wxWidgets can save (e.g. JPG, PNG, see {Wx::Image} documentation)!
+    #   @see Wx::MemoryFSHandler.add_file_with_mime_type 
+    #   @param filename [String] 
+    #   @param image [Wx::Image] 
+    #   @param type [Wx::BitmapType] 
+    #   @return [void]
+    # @overload self.add_file(filename, bitmap, type)
+    #   Adds a file to the list of the files stored in memory.
+    #   Stored data (bitmap, text or raw data) will be copied into private memory stream and available under name <code>"memory:"</code> + filename.
+    #   When using the overload taking {Wx::String} data, if the string contains only Latin-1 characters (which includes strings created using Wx::String#from8bit_data), its data is used as is. Otherwise, the UTF-8 representation of the string is stored as the data associated with the given filename.
+    #   you must use a type value (aka image format) that wxWidgets can save (e.g. JPG, PNG, see {Wx::Image} documentation)!
+    #   @see Wx::MemoryFSHandler.add_file_with_mime_type 
+    #   @param filename [String] 
+    #   @param bitmap [Wx::Bitmap] 
+    #   @param type [Wx::BitmapType] 
+    #   @return [void]
+    # @overload self.add_file(filename, textdata)
+    #   Adds a file to the list of the files stored in memory.
+    #   Stored data (bitmap, text or raw data) will be copied into private memory stream and available under name <code>"memory:"</code> + filename.
+    #   When using the overload taking {Wx::String} data, if the string contains only Latin-1 characters (which includes strings created using Wx::String#from8bit_data), its data is used as is. Otherwise, the UTF-8 representation of the string is stored as the data associated with the given filename.
+    #   you must use a type value (aka image format) that wxWidgets can save (e.g. JPG, PNG, see {Wx::Image} documentation)!
+    #   @see Wx::MemoryFSHandler.add_file_with_mime_type 
+    #   @param filename [String] 
+    #   @param textdata [String] 
+    #   @return [void]
+    def self.add_file(*args) end
+    
+    # Like {Wx::MemoryFSHandler.add_file}, but lets you explicitly specify added file's MIME type.
+    # This version should be used whenever you know the MIME type, because it makes accessing the files faster.
+    # @see Wx::MemoryFSHandler.add_file 
+    # @param filename [String] 
+    # @param textdata [String] 
+    # @param mimetype [String] 
+    # @return [void]
+    def self.add_file_with_mime_type(filename, textdata, mimetype) end
+    
+    # Constructor.
+    # @return [Wx::MemoryFSHandler]
+    def initialize; end
+    
+    # Removes a file from memory FS and frees the occupied memory.
+    # @param filename [String] 
+    # @return [void]
+    def self.remove_file(filename) end
+    
+  end # MemoryFSHandler
+  
+
+end

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

@@ -93,7 +93,7 @@ module Wx
   class FindDialogEvent < CommandEvent
   
     # Constructor used by wxWidgets only.
-    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param commandType [Wx::CommandLinkButton::EventType] 
     # @param id [Integer] 
     # @return [Wx::FindDialogEvent]
     def initialize(commandType=Wx::EVT_NULL, id=0) end

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

@@ -30,7 +30,7 @@ module Wx
     # @param data [Wx::FindReplaceData] 
     # @param title [String] 
     # @param style [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def create(parent, data, title, style=0) end
     
     # Get the {Wx::FindReplaceData} object used by this dialog.

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

@@ -82,19 +82,19 @@ module Wx
     # - {Wx::FlexSizerGrowMode::FLEX_GROWMODE_ALL}: Sizer equally stretches all columns or rows in the non-flexible direction, independently of the proportions applied in the flexible direction.
     # @see Wx::FlexGridSizer#set_flexible_direction
     # @see  Wx::FlexGridSizer#set_non_flexible_grow_mode 
-    # @return [FlexSizerGrowMode]
+    # @return [Wx::FlexSizerGrowMode]
     def get_non_flexible_grow_mode; end
     alias_method :non_flexible_grow_mode, :get_non_flexible_grow_mode
     
     # Returns true if column idx is growable.
     # @param idx [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_col_growable(idx) end
     alias_method :col_growable?, :is_col_growable
     
     # Returns true if row idx is growable.
     # @param idx [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_row_growable(idx) end
     alias_method :row_growable?, :is_row_growable
     
@@ -118,7 +118,7 @@ module Wx
     
     # Specifies how the sizer should grow in the non-flexible direction if there is one (so {Wx::FlexGridSizer#set_flexible_direction} must have been called previously).
     # Argument mode can be one of those documented in {Wx::FlexGridSizer#get_non_flexible_grow_mode}, please see there for their explanation. Note that this method does not trigger relayout.
-    # @param mode [FlexSizerGrowMode] 
+    # @param mode [Wx::FlexSizerGrowMode] 
     # @return [void]
     def set_non_flexible_grow_mode(mode) end
     alias_method :non_flexible_grow_mode=, :set_non_flexible_grow_mode