wxruby3 0.9.0.pre.beta.8-x64-mingw-ucrt

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

@@ -0,0 +1,224 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A class that can handle events from the windowing system.
+  # {Wx::Window} is (and therefore all window classes are) derived from this class.
+  # When events are received, {Wx::EvtHandler} invokes the method listed in the event table using itself as the object. When using multiple inheritance <b>it is imperative that the {Wx::EvtHandler}(-derived) class is the first class inherited</b> such that the this pointer for the overall object will be identical to the this pointer of the {Wx::EvtHandler} portion.
+  # === 
+  # 
+  # Category:  {Wx::Events}
+  # @see How Events are Processed
+  # @see  Wx::EventBlocker
+  # @see  Wx::EventLoopBase 
+  # 
+  # 
+  class EvtHandler < Object
+  
+    # Queue event for a later processing.
+    # This method is similar to {Wx::EvtHandler#process_event} but while the latter is synchronous, i.e. the event is processed immediately, before the function returns, this one is asynchronous and returns immediately while the event will be processed at some later time (usually during the next event loop iteration).
+    # Another important difference is that this method takes ownership of the event parameter, i.e. it will delete it itself. This implies that the event should be allocated on the heap and that the pointer can't be used any more after the function returns (as it can be deleted at any moment).
+    # {Wx::EvtHandler#queue_event} can be used for inter-thread communication from the worker threads to the main thread, it is safe in the sense that it uses locking internally and avoids the problem mentioned in {Wx::EvtHandler#add_pending_event} documentation by ensuring that the event object is not used by the calling thread any more. Care should still be taken to avoid that some fields of this object are used by it, notably any {Wx::String} members of the event object must not be shallow copies of another {Wx::String} object as this would result in them still using the same string buffer behind the scenes. For example: 
+    # 
+    #   void FunctionInAWorkerThread(const wxString& str)
+    #   {
+    #       wxCommandEvent* evt = new wxCommandEvent;
+    #   
+    #       // NOT evt->SetString(str) as this would be a shallow copy
+    #       evt->SetString(str.c_str()); // make a deep copy
+    #   
+    #       wxTheApp->QueueEvent( evt );
+    #   }
+    # 
+    # Note that you can use {Wx::ThreadEvent} instead of {Wx::CommandEvent} to avoid this problem: 
+    # 
+    #   void FunctionInAWorkerThread(const wxString& str)
+    #   {
+    #       wxThreadEvent evt;
+    #       evt.SetString(str);
+    #   
+    #       // wxThreadEvent::Clone() makes sure that the internal wxString
+    #       // member is not shared by other wxString instances:
+    #       wxTheApp->QueueEvent( evt.Clone() );
+    #   }
+    # 
+    # Finally notice that this method automatically wakes up the event loop if it is currently idle by calling {wake_up_idle} so there is no need to do it manually when using it.
+    # @param event [Wx::Event]  A heap-allocated event to be queued, {Wx::EvtHandler#queue_event} takes ownership of it. This parameter shouldn't be NULL.
+    # @return [void]
+    def queue_event(event) end
+    
+    # Post an event to be processed later.
+    # This function is similar to {Wx::EvtHandler#queue_event} but can't be used to post events from worker threads for the event objects with {Wx::String} fields (i.e. in practice most of them) because of an unsafe use of the same {Wx::String} object which happens because the {Wx::String} field in the original event object and its copy made internally by this function share the same string buffer internally. Use {Wx::EvtHandler#queue_event} to avoid this.
+    # A copy of event is made by the function, so the original can be deleted as soon as function returns (it is common that the original is created on the stack). This requires that the {Wx::Event#clone} method be implemented by event so that it can be duplicated and stored until it gets processed.
+    # @param event [Wx::Event]  Event to add to the pending events queue.
+    # @return [void]
+    def add_pending_event(event) end
+    
+    # Try to process the event in this handler and all those chained to it.
+    # As explained in {Wx::EvtHandler#process_event} documentation, the event handlers may be chained in a doubly-linked list. This function tries to process the event in this handler (including performing any pre-processing done in {Wx::EvtHandler#try_before}, e.g. applying validators) and all those following it in the chain until the event is processed or the chain is exhausted.
+    # This function is called from {Wx::EvtHandler#process_event} and, in turn, calls {Wx::EvtHandler#try_before} and {Wx::EvtHandler#try_after}. It is not virtual and so cannot be overridden but can, and should, be called to forward an event to another handler instead of {Wx::EvtHandler#process_event} which would result in a duplicate call to {Wx::EvtHandler#try_after}, e.g. resulting in all unprocessed events being sent to the application object multiple times.
+    # 
+    # true if this handler of one of those chained to it processed the event.
+    # @param event [Wx::Event]  Event to process.
+    # @return [true,false]
+    def process_event_locally(event) end
+    
+    # Processes an event by calling {Wx::EvtHandler#process_event} and handles any exceptions that occur in the process.
+    # If an exception is thrown in event handler, {Wx::App::OnExceptionInMainLoop} is called.
+    # 
+    # true if the event was processed, false if no handler was found or an exception was thrown.
+    # @see Wx::Window#handle_window_event 
+    # @param event [Wx::Event]  Event to process.
+    # @return [true,false]
+    def safely_process_event(event) end
+    
+    # Processes the pending events previously queued using {Wx::EvtHandler#queue_event} or {Wx::EvtHandler#add_pending_event}; you must call this function only if you are sure there are pending events for this handler, otherwise a {Wx::CHECK} will fail.
+    # The real processing still happens in {Wx::EvtHandler#process_event} which is called by this function.
+    # Note that this function needs a valid application object (see Wx::AppConsole#get_instance) because {Wx::App} holds the list of the event handlers with pending events and this function manipulates that list.
+    # @return [void]
+    def process_pending_events; end
+    
+    # Deletes all events queued on this event handler using {Wx::EvtHandler#queue_event} or {Wx::EvtHandler#add_pending_event}.
+    # Use with care because the events which are deleted are (obviously) not processed and this may have unwanted consequences (e.g. user actions events will be lost).
+    # @return [void]
+    def delete_pending_events; end
+    
+    # Returns true if the event handler is enabled, false otherwise.
+    # 
+    # @see Wx::EvtHandler#set_evt_handler_enabled 
+    # @return [true,false]
+    def get_evt_handler_enabled; end
+    alias_method :evt_handler_enabled, :get_evt_handler_enabled
+    
+    # Returns the pointer to the next handler in the chain.
+    # 
+    # @see Wx::EvtHandler#set_next_handler
+    # @see  Wx::EvtHandler#get_previous_handler
+    # @see  Wx::EvtHandler#set_previous_handler
+    # @see  Wx::Window#push_event_handler
+    # @see  Wx::Window#pop_event_handler 
+    # @return [Wx::EvtHandler]
+    def get_next_handler; end
+    alias_method :next_handler, :get_next_handler
+    
+    # Returns the pointer to the previous handler in the chain.
+    # 
+    # @see Wx::EvtHandler#set_previous_handler
+    # @see  Wx::EvtHandler#get_next_handler
+    # @see  Wx::EvtHandler#set_next_handler
+    # @see  Wx::Window#push_event_handler
+    # @see  Wx::Window#pop_event_handler 
+    # @return [Wx::EvtHandler]
+    def get_previous_handler; end
+    alias_method :previous_handler, :get_previous_handler
+    
+    # Enables or disables the event handler.
+    # You can use this function to avoid having to remove the event handler from the chain, for example when implementing a dialog editor and changing from edit to test mode.
+    # @see Wx::EvtHandler#get_evt_handler_enabled 
+    # @param enabled [true,false]  true if the event handler is to be enabled, false if it is to be disabled.
+    # @return [void]
+    def set_evt_handler_enabled(enabled) end
+    alias_method :evt_handler_enabled=, :set_evt_handler_enabled
+    
+    # Sets the pointer to the next handler.
+    # See {Wx::EvtHandler#process_event} for more info about how the chains of event handlers are internally used. Also remember that {Wx::EvtHandler} uses double-linked lists and thus if you use this function, you should also call {Wx::EvtHandler#set_previous_handler} on the argument passed to this function: 
+    # 
+    #   handlerA->SetNextHandler(handlerB);
+    #   handlerB->SetPreviousHandler(handlerA);
+    # @see How Events are Processed 
+    # @param handler [Wx::EvtHandler]  The event handler to be set as the next handler. Cannot be NULL.
+    # @return [void]
+    def set_next_handler(handler) end
+    alias_method :next_handler=, :set_next_handler
+    
+    # Sets the pointer to the previous handler.
+    # All remarks about {Wx::EvtHandler#set_next_handler} apply to this function as well.
+    # @see How Events are Processed 
+    # @param handler [Wx::EvtHandler]  The event handler to be set as the previous handler. Cannot be NULL.
+    # @return [void]
+    def set_previous_handler(handler) end
+    alias_method :previous_handler=, :set_previous_handler
+    
+    # Unlinks this event handler from the chain it's part of (if any); then links the "previous" event handler to the "next" one (so that the chain won't be interrupted).
+    # E.g. if before calling {Wx::EvtHandler#unlink} you have the following chain: 
+    #  then after calling <code>B->Wx::EvtHandler#unlink</code> you'll have:
+    # @return [void]
+    def unlink; end
+    
+    # Returns true if the next and the previous handler pointers of this event handler instance are NULL.
+    # 
+    # @see Wx::EvtHandler#set_previous_handler
+    # @see  Wx::EvtHandler#set_next_handler 
+    # @return [true,false]
+    def is_unlinked; end
+    alias_method :unlinked?, :is_unlinked
+    
+    # Add an event filter whose FilterEvent() method will be called for each and every event processed by wxWidgets.
+    # The filters are called in LIFO order and {Wx::App} is registered as an event filter by default. The pointer must remain valid until it's removed with {Wx::EvtHandler.remove_filter} and is not deleted by {Wx::EvtHandler}.
+    # @param filter [Wx::EventFilter] 
+    # @return [void]
+    def self.add_filter(filter) end
+    
+    # Remove a filter previously installed with {Wx::EvtHandler.add_filter}.
+    # It's an error to remove a filter that hadn't been previously added or was already removed.
+    # @param filter [Wx::EventFilter] 
+    # @return [void]
+    def self.remove_filter(filter) end
+    
+    # Constructor.
+    # @return [EvtHandler]
+    def initialize; end
+    
+    
+    protected
+    
+    # Method called by {Wx::EvtHandler#process_event} before examining this object event tables.
+    # This method can be overridden to hook into the event processing logic as early as possible. You should usually call the base class version when overriding this method, even if {Wx::EvtHandler} itself does nothing here, some derived classes do use this method, e.g. {Wx::Window} implements support for {Wx::Validator} in it.
+    # Example: 
+    # 
+    #   class MyClass : public BaseClass // inheriting from wxEvtHandler
+    #   {
+    #   ...
+    #   protected:
+    #       virtual bool TryBefore(wxEvent& event)
+    #       {
+    #           if ( MyPreProcess(event) )
+    #               return true;
+    #   
+    #           return BaseClass::TryBefore(event);
+    #       }
+    #   };
+    # @see Wx::EvtHandler#process_event 
+    # @param event [Wx::Event] 
+    # @return [true,false]
+    def try_before(event) end
+    
+    # Method called by {Wx::EvtHandler#process_event} as last resort.
+    # This method can be overridden to implement post-processing for the events which were not processed anywhere else.
+    # The base class version handles forwarding the unprocessed events to {Wx::App} at {Wx::EvtHandler} level and propagating them upwards the window child-parent chain at {Wx::Window} level and so should usually be called when overriding this method: 
+    # 
+    #   class MyClass : public BaseClass // inheriting from wxEvtHandler
+    #   {
+    #   ...
+    #   protected:
+    #       virtual bool TryAfter(wxEvent& event)
+    #       {
+    #           if ( BaseClass::TryAfter(event) )
+    #               return true;
+    #   
+    #           return MyPostProcess(event);
+    #       }
+    #   };
+    # @see Wx::EvtHandler#process_event 
+    # @param event [Wx::Event] 
+    # @return [true,false]
+    def try_after(event) end
+    
+  end # EvtHandler
+  
+
+end

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

@@ -0,0 +1,100 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # This class implements help via an external browser.
+  # It requires the name of a directory containing the documentation and a file mapping numerical Section numbers to relative URLS.
+  # The map file contains two or three fields per line: numeric_id relative_URL [; comment/documentation]
+  # The numeric_id is the id used to look up the entry in {Wx::ExtHelpController#display_section}/DisplayBlock(). The relative_URL is a filename of an html file, relative to the help directory. The optional comment/documentation field (after a ';') is used for keyword searches, so some meaningful text here does not hurt. If the documentation itself contains a ';', only the part before that will be displayed in the listbox, but all of it used for search.
+  # Lines starting with ';' will be ignored.
+  # === 
+  # 
+  # Category:  {Wx::HELP}
+  # @see Wx::HelpController 
+  # 
+  # 
+  class ExtHelpController < Object
+  
+    # @param parentWindow [Wx::Window] 
+    # @return [ExtHelpController]
+    def initialize(parentWindow=nil) end
+    
+    # Tell it which browser to use.
+    # The Netscape support will check whether Netscape is already running (by looking at the .netscape/lock file in the user's home directory) and tell it to load the page into the existing window.
+    # @param viewer [String]  The command to call a browser/html viewer.
+    # @param flags [Integer]  Set this to {Wx::HELP_NETSCAPE} if the browser is some variant of Netscape.
+    # @return [void]
+    def set_viewer(viewer=Wx::EMPTY_STRING, flags=Wx::HELP_NETSCAPE) end
+    alias_method :viewer=, :set_viewer
+    
+    # This must be called to tell the controller where to find the documentation.
+    # If a locale is set, look in file/localename, i.e. If passed "/usr/local/myapp/help" and the current {Wx::Locale} is set to be "de", then look in "/usr/local/myapp/help/de/" first and fall back to "/usr/local/myapp/help" if that doesn't exist.
+    # 
+    # true on success
+    # @param dir [String]  directory name where to fine the help files
+    # @return [true,false]
+    def init(dir) end
+    
+    # Display list of all help entries.
+    # true on success
+    # @return [true,false]
+    def display_contents; end
+    
+    # Search comment/documentation fields in map file and present a list to chose from.
+    # true on success
+    # @param k [String]  string to search for, empty string will list all entries
+    # @param mode [HelpSearchMode]  optional parameter allows the search the index ({Wx::HelpSearchMode::HELP_SEARCH_INDEX}) but this currently only supported by the {Wx::HTML::HtmlHelpController}.
+    # @return [true,false]
+    def keyword_search(k, mode=Wx::HELP_SEARCH_ALL) end
+    
+    # Does nothing.
+    # @return [void]
+    def on_quit; end
+    
+    # Call the browser using a relative URL.
+    # @param relativeURL [String] 
+    # @return [true,false]
+    def display_help(relativeURL) end
+    
+    # Allows one to override the default settings for the help frame.
+    # @param titleFormat [String] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param newFrameEachTime [true,false] 
+    # @return [void]
+    def set_frame_parameters(titleFormat, size, pos=Wx::DEFAULT_POSITION, newFrameEachTime=false) end
+    
+    # Displays the section as a popup window using a context id.
+    # Returns false if unsuccessful or not implemented.
+    # @param contextId [Integer] 
+    # @return [true,false]
+    def display_context_popup(contextId) end
+    
+    # Displays the text in a popup window, if possible.
+    # Returns false if unsuccessful or not implemented.
+    # @param text [String] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @return [true,false]
+    def display_text_popup(text, pos) end
+    
+    # Returns the window to be used as the parent for the help window.
+    # This window is used by {Wx::CHMHelpController}, {Wx::WinHelpController} and {Wx::HTML::HtmlHelpController}.
+    # @return [Wx::Window]
+    def get_parent_window; end
+    alias_method :parent_window, :get_parent_window
+    
+    # Sets the window to be used as the parent for the help window.
+    # This is used by {Wx::CHMHelpController}, {Wx::WinHelpController} and {Wx::HTML::HtmlHelpController}.
+    # @param parentWindow [Wx::Window] 
+    # @return [void]
+    def set_parent_window(parentWindow) end
+    alias_method :parent_window=, :set_parent_window
+    
+  end # ExtHelpController
+  
+
+end

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

@@ -0,0 +1,294 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  FD_DEFAULT_STYLE = 1
+  
+  # 
+  # 
+  FD_OPEN = 1
+  
+  # 
+  # 
+  FD_SAVE = 2
+  
+  # 
+  # 
+  FD_OVERWRITE_PROMPT = 4
+  
+  # 
+  # 
+  FD_NO_FOLLOW = 8
+  
+  # 
+  # 
+  FD_FILE_MUST_EXIST = 16
+  
+  # 
+  # 
+  FD_CHANGE_DIR = 128
+  
+  # 
+  # 
+  FD_PREVIEW = 256
+  
+  # 
+  # 
+  FD_MULTIPLE = 512
+  
+  # 
+  # 
+  FD_SHOW_HIDDEN = 1024
+  
+  # Default wildcard string used in {Wx::FileDialog} corresponding to all files.
+  # 
+  FILE_SELECTOR_DEFAULT_WILDCARD_STR = "*.*"
+  
+  # This class represents the file chooser dialog.
+  # The path and filename are distinct elements of a full file pathname. If path is {Wx::EmptyString}, the current directory will be used. If filename is {Wx::EmptyString}, no default filename will be supplied. The wildcard determines what files are displayed in the file selector, and file extension supplies a type extension for the required filename.
+  # The typical usage for the open file dialog is: 
+  # 
+  #   void MyFrame::OnOpen(wxCommandEvent& WXUNUSED(event))
+  #   {
+  #       if (...current content has not been saved...)
+  #       {
+  #           if (wxMessageBox(_("Current content has not been saved! Proceed?"), _("Please confirm"),
+  #                            wxICON_QUESTION | wxYES_NO, this) == wxNO )
+  #               return;
+  #           //else: proceed asking to the user the new file to open
+  #       }
+  #   
+  #       wxFileDialog
+  #           openFileDialog(this, _("Open XYZ file"), "", "",
+  #                          "XYZ files (*.xyz)|*.xyz", wxFD_OPEN|wxFD_FILE_MUST_EXIST);
+  #   
+  #       if (openFileDialog.ShowModal() == wxID_CANCEL)
+  #           return;     // the user changed idea...
+  #   
+  #       // proceed loading the file chosen by the user;
+  #       // this can be done with e.g. wxWidgets input streams:
+  #       wxFileInputStream input_stream(openFileDialog.GetPath());
+  #       if (!input_stream.IsOk())
+  #       {
+  #           wxLogError("Cannot open file '%s'.", openFileDialog.GetPath());
+  #           return;
+  #       }
+  #   
+  #       ...
+  #   }
+  # 
+  # The typical usage for the save file dialog is instead somewhat simpler: 
+  # 
+  #   void MyFrame::OnSaveAs(wxCommandEvent& WXUNUSED(event))
+  #   {
+  #       wxFileDialog
+  #           saveFileDialog(this, _("Save XYZ file"), "", "",
+  #                          "XYZ files (*.xyz)|*.xyz", wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
+  #   
+  #       if (saveFileDialog.ShowModal() == wxID_CANCEL)
+  #           return;     // the user changed idea...
+  #   
+  #       // save the current contents in the file;
+  #       // this can be done with e.g. wxWidgets output streams:
+  #       wxFileOutputStream output_stream(saveFileDialog.GetPath());
+  #       if (!output_stream.IsOk())
+  #       {
+  #           wxLogError("Cannot save current contents in file '%s'.", saveFileDialog.GetPath());
+  #           return;
+  #       }
+  #   
+  #       ...
+  #   }
+  # 
+  # == 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"
+  # 
+  # On Mac macOS in the open file dialog the filter choice box is not shown by default. Instead all given wildcards are applied at the same time: So in the above example all bmp, gif and png files are displayed. To enforce the display of the filter choice set the corresponding {Wx::SystemOptions} before calling the file open dialog: 
+  # 
+  #   wxSystemOptions::SetOption(wxOSX_FILEDIALOG_ALWAYS_SHOW_TYPES, 1)
+  #  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 {Wx::MSW} 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.
+  # === Styles
+  # 
+  # This class supports the following styles:
+  #  
+  # - {Wx::FD_DEFAULT_STYLE}: Equivalent to {Wx::FD_OPEN}. 
+  # - {Wx::FD_OPEN}: This is an open dialog; usually this means that the default button's label of the dialog is "Open". Cannot be combined with {Wx::FD_SAVE}. 
+  # - {Wx::FD_SAVE}: This is a save dialog; usually this means that the default button's label of the dialog is "Save". Cannot be combined with {Wx::FD_OPEN}. 
+  # - {Wx::FD_OVERWRITE_PROMPT}: For save dialog only: prompt for a confirmation if a file will be overwritten. This style is always enabled on {Wx::OSX} and cannot be disabled. 
+  # - {Wx::FD_NO_FOLLOW}: Directs the dialog to return the path and file name of the selected shortcut file, not its target as it does by default. Currently this flag is only implemented in {Wx::MSW} and {Wx::OSX} (where it prevents aliases from being resolved). The non-dereferenced link path is always returned, even without this flag, under Unix and so using it there doesn't do anything. This flag was added in wxWidgets 3.1.0. 
+  # - {Wx::FD_FILE_MUST_EXIST}: For open dialog only: the user may only select files that actually exist. Notice that under macOS the file dialog with {Wx::FD_OPEN} style always behaves as if this style was specified, because it is impossible to choose a file that doesn't exist from a standard macOS file dialog. 
+  # - {Wx::FD_MULTIPLE}: For open dialog only: allows selecting multiple files. 
+  # - {Wx::FD_CHANGE_DIR}: Change the current working directory (when the dialog is dismissed) to the directory where the file(s) chosen by the user are. 
+  # - {Wx::FD_PREVIEW}: Show the preview of the selected files (currently only supported by {Wx::GTK}). 
+  # - {Wx::FD_SHOW_HIDDEN}: Show hidden files. This flag was added in wxWidgets 3.1.3 
+  # 
+  # === 
+  # 
+  # Category:  Common Dialogs
+  # @see wxFileDialog Overview
+  # @see  file_selector 
+  # 
+  # 
+  class FileDialog < Dialog
+  
+    # Constructor.
+    # Use {Wx::FileDialog#show_modal} to show the dialog.
+    # @param parent [Wx::Window]  Parent window.
+    # @param message [String]  Message to show on the dialog.
+    # @param defaultDir [String]  The default directory, or the empty string.
+    # @param defaultFile [String]  The default filename, or the empty string.
+    # @param wildcard [String]  A wildcard, such as "*.*" or "BMP files (*.bmp)|*.bmp|GIF files (*.gif)|*.gif". Note that the native Motif dialog has some limitations with respect to wildcards; see the Remarks section above.
+    # @param style [Integer]  A dialog style. See <code>wxFD_*</code> styles for more info.
+    # @param pos [Array(Integer, Integer), Wx::Point]  Dialog position. Not implemented.
+    # @param size [Array(Integer, Integer), Wx::Size]  Dialog size. Not implemented.
+    # @param name [String]  Dialog name. Not implemented.
+    # @return [FileDialog]
+    def initialize(parent, message=Wx::FILE_SELECTOR_PROMPT_STR, defaultDir=Wx::EMPTY_STRING, defaultFile=Wx::EMPTY_STRING, wildcard=Wx::FILE_SELECTOR_DEFAULT_WILDCARD_STR, style=Wx::FD_DEFAULT_STYLE, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, name=Wx::FILE_DIALOG_NAME_STR) end
+    
+    # Returns the path of the file currently selected in dialog.
+    # Notice that this file is not necessarily going to be accepted by the user, so calling this function mostly makes sense from an update UI event handler of a custom file dialog extra control to update its state depending on the currently selected file.
+    # Currently this function is fully implemented under GTK and MSW and always returns an empty string elsewhere.
+    # 
+    # The path of the currently selected file or an empty string if nothing is selected.
+    # @see Wx::FileDialog#set_extra_control_creator 
+    # @return [String]
+    def get_currently_selected_filename; end
+    alias_method :currently_selected_filename, :get_currently_selected_filename
+    
+    # Returns the file type filter index currently selected in dialog.
+    # Notice that this file type filter is not necessarily going to be the one finally accepted by the user, so calling this function mostly makes sense from an update UI event handler of a custom file dialog extra control to update its state depending on the currently selected file type filter.
+    # Currently this function is fully implemented under macOS and MSW and always returns {Wx::NOT_FOUND} elsewhere.
+    # 
+    # The 0-based index of the currently selected file type filter or {Wx::NOT_FOUND} if nothing is selected.
+    # @see Wx::FileDialog#set_extra_control_creator 
+    # 
+    # @see Wx::FileDialog#get_filter_index 
+    # 
+    # @see Wx::FileDialog#set_filter_index 
+    # @return [Integer]
+    def get_currently_selected_filter_index; end
+    alias_method :currently_selected_filter_index, :get_currently_selected_filter_index
+    
+    # Returns the default directory.
+    # @return [String]
+    def get_directory; end
+    alias_method :directory, :get_directory
+    
+    # If functions {Wx::FileDialog#set_extra_control_creator} and {Wx::FileDialog#show_modal} were called, returns the extra window.
+    # Otherwise returns NULL.
+    # @return [Wx::Window]
+    def get_extra_control; end
+    alias_method :extra_control, :get_extra_control
+    
+    # Returns the default filename.
+    # This function can't be used with dialogs which have the {Wx::FD_MULTIPLE} style, use {Wx::FileDialog#get_filenames} instead.
+    # @return [String]
+    def get_filename; end
+    alias_method :filename, :get_filename
+    
+    # Fills the array filenames with the names of the files chosen.
+    # This function should only be used with the dialogs which have {Wx::FD_MULTIPLE} style, use {Wx::FileDialog#get_filename} for the others.
+    # Note that under Windows, if the user selects shortcuts, the filenames include paths, since the application cannot determine the full path of each referenced file by appending the directory containing the shortcuts to the filename.
+    # @return [Array<String>]
+    def get_filenames; end
+    alias_method :filenames, :get_filenames
+    
+    # Returns the index into the list of filters supplied, optionally, in the wildcard parameter.
+    # Before the dialog is shown, this is the index which will be used when the dialog is first displayed.
+    # After the dialog is shown, this is the index selected by the user.
+    # @return [Integer]
+    def get_filter_index; end
+    alias_method :filter_index, :get_filter_index
+    
+    # Returns the message that will be displayed on the dialog.
+    # @return [String]
+    def get_message; end
+    alias_method :message, :get_message
+    
+    # Returns the full path (directory and filename) of the selected file.
+    # This function can't be used with dialogs which have the {Wx::FD_MULTIPLE} style, use {Wx::FileDialog#get_paths} instead.
+    # @return [String]
+    def get_path; end
+    alias_method :path, :get_path
+    
+    # Fills the array paths with the full paths of the files chosen.
+    # This function should only be used with the dialogs which have {Wx::FD_MULTIPLE} style, use {Wx::FileDialog#get_path} for the others.
+    # @return [Array<String>]
+    def get_paths; end
+    alias_method :paths, :get_paths
+    
+    # Returns the file dialog wildcard.
+    # @return [String]
+    def get_wildcard; end
+    alias_method :wildcard, :get_wildcard
+    
+    # Set the hook to be used for customizing the dialog contents.
+    # This function can be called before calling {Wx::FileDialog#show_modal} to specify that the dialog contents should be customized using the provided hook. See {Wx::FileDialogCustomizeHook} documentation and Dialogs Sample for the examples of using it.
+    # In order to define a custom hook object, <code>Wx::/filedlgcustomize.h</code> must be included in addition to the usual <code>Wx::/filedlg.h</code> header.
+    # 
+    # true if the hook was successfully set or false if customizing the file dialog is not supported by the current platform.
+    # @param customizeHook [Wx::FileDialogCustomizeHook]  The hook object that will be used by the dialog. This object must remain valid at least until {Wx::FileDialog#show_modal} returns.
+    # @return [true,false]
+    def set_customize_hook(customizeHook) end
+    alias_method :customize_hook=, :set_customize_hook
+    
+    # Sets the default directory.
+    # @param directory [String] 
+    # @return [void]
+    def set_directory(directory) end
+    alias_method :directory=, :set_directory
+    
+    # Sets the default filename.
+    # In {Wx::GTK} this will have little effect unless a default directory has previously been set.
+    # @param setfilename [String] 
+    # @return [void]
+    def set_filename(setfilename) end
+    alias_method :filename=, :set_filename
+    
+    # Sets the default filter index, starting from zero.
+    # @param filterIndex [Integer] 
+    # @return [void]
+    def set_filter_index(filterIndex) end
+    alias_method :filter_index=, :set_filter_index
+    
+    # Sets the message that will be displayed on the dialog.
+    # @param message [String] 
+    # @return [void]
+    def set_message(message) end
+    alias_method :message=, :set_message
+    
+    # Sets the path (the combined directory and filename that will be returned when the dialog is dismissed).
+    # @param path [String] 
+    # @return [void]
+    def set_path(path) end
+    alias_method :path=, :set_path
+    
+    # Sets the wildcard, which can contain multiple file types, for example: "BMP files (*.bmp)|*.bmp|GIF files (*.gif)|*.gif".
+    # Note that the native Motif dialog has some limitations with respect to wildcards; see the Remarks section above.
+    # @param wildCard [String] 
+    # @return [void]
+    def set_wildcard(wildCard) end
+    alias_method :wildcard=, :set_wildcard
+    
+    # Shows the dialog, returning {Wx::StandardID::ID_OK} if the user pressed OK, and {Wx::StandardID::ID_CANCEL} otherwise.
+    # @return [Integer]
+    def show_modal; end
+    
+  end # FileDialog
+  
+
+end