wxruby3 0.9.2-x64-mingw-ucrt → 0.9.4-x64-mingw-ucrt

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

@@ -7,6 +7,7 @@
 module Wx
 
   # Objects of this class are similar in appearance to the normal {Wx::Buttons} but are similar to the links in a web page in functionality.
+  # 
   # Pressing such button usually results in switching to another window of the program and so they can be used as a replacement for the "Next" button in a multi-page dialog (such as {Wx::Wizard}), for example.
   # Their advantage compared to the ordinary {Wx::Buttons} is that they emphasize the action of switching the window and also that they allow to give more detailed explanation to the user because, in addition to the short button label, they also show a longer description string.
   # The short, title-like, part of the label is called the main label and the longer description is the note. Both of them can be set and queried independently using {Wx::CommandLinkButton}-specific methods such as {Wx::CommandLinkButton#set_main_label} or {Wx::CommandLinkButton#get_note} or also via {Wx::CommandLinkButton#set_label} and {Wx::CommandLinkButton#get_label} methods inherited from {Wx::Button}. When using the latter, the main label and the note are concatenated into a single string using a new line character between them (notice that the note part can have more new lines in it).
@@ -26,10 +27,12 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
+    #   
     #   Use {Wx::CommandLinkButton#create} to really create the control.
     #   @return [Wx::CommandLinkButton]
     # @overload initialize(parent, id, mainLabel=(''), note=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BUTTON_NAME_STR)
     #   Constructor really creating a command Link button.
+    #   
     #   The button will be decorated with stock icons under GTK+ 2.
     #   @see Wx::CommandLinkButton#create
     #   @see  Wx::Validator 
@@ -46,6 +49,7 @@ module Wx
     def initialize(*args) end
     
     # Button creation function for two-step creation.
+    # 
     # For more details, see {Wx::CommandLinkButton#initialize}.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
@@ -60,6 +64,7 @@ module Wx
     def create(parent, id, mainLabel=(''), note=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BUTTON_NAME_STR) end
     
     # Sets a new main label and note for the button.
+    # 
     # Neither of the arguments can be empty, if you need to change just the label or just the note, use {Wx::CommandLinkButton#set_main_label} or {Wx::CommandLinkButton#set_note} instead of this function.
     # @param mainLabel [String]  New main label to use.
     # @param note [String]  New note to use.
@@ -73,6 +78,7 @@ module Wx
     alias_method :label=, :set_label
     
     # Returns the string label for the button.
+    # 
     # A string with the main label and note concatenated together with a newline separating them.
     # @see Wx::CommandLinkButton#set_label
     # @return [String]
@@ -92,12 +98,14 @@ module Wx
     alias_method :note=, :set_note
     
     # Returns the current main label.
+    # 
     # Main label currently displayed.
     # @return [String]
     def get_main_label; end
     alias_method :main_label, :get_main_label
     
     # Returns the currently used note.
+    # 
     # Note currently displayed.
     # @return [String]
     def get_note; end

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

@@ -7,6 +7,7 @@
 module Wx
 
   # Instances of this class may be used to add a question mark button that when pressed, puts the application into context-help mode.
+  # 
   # It does this by creating a {Wx::ContextHelp} object which itself generates a {Wx::EVT_HELP} event when the user clicks on a window.
   # On Windows, you may add a question-mark icon to a dialog by use of the {Wx::DIALOG_EX_CONTEXTHELP} extra style, but on other platforms you will have to add a button explicitly, usually next to OK, Cancel or similar buttons.
   # 
@@ -19,11 +20,12 @@ module Wx
   class ContextHelpButton < BitmapButton
   
     # Constructor, creating and showing a context help button.
+    # 
     # <div class="wxrb-remark">
     # <b>Remark:</b>
     # <p>Normally you only need pass the parent window to the constructor, and use the defaults for the remaining parameters. 
     # </p>
-    # </div>>
+    # </div>
     # @param parent [Wx::Window]  Parent window. Must not be NULL.
     # @param id [Integer]  Button identifier. Defaults to {Wx::StandardID::ID_CONTEXT_HELP}.
     # @param pos [Array(Integer, Integer), Wx::Point]  Button position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
@@ -35,6 +37,7 @@ module Wx
   end # ContextHelpButton
   
   # This class changes the cursor to a query and puts the application into a 'context-sensitive help mode'.
+  # 
   # When the user left-clicks on a window within the specified window, a {Wx::EVT_HELP} event is sent to that control, and the application may respond to it by popping up some help.
   # For example: 
   # ```ruby
@@ -63,6 +66,7 @@ module Wx
   class ContextHelp < Object
   
     # Constructs a context help object, calling {Wx::ContextHelp#begin_context_help} if doNow is true (the default).
+    # 
     # If window is NULL, the top window is used.
     # @param window [Wx::Window] 
     # @param doNow [Boolean] 
@@ -70,6 +74,7 @@ module Wx
     def initialize(window=nil, doNow=true) end
     
     # Puts the application into context-sensitive help mode.
+    # 
     # window is the window which will be used to catch events; if NULL, the top window will be used.
     # Returns true if the application was successfully put into context-sensitive help mode. This function only returns when the event loop has finished.
     # @param window [Wx::Window] 
@@ -77,6 +82,7 @@ module Wx
     def begin_context_help(window) end
     
     # Ends context-sensitive help mode.
+    # 
     # Not normally called by the application.
     # @return [Boolean]
     def end_context_help; end

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

@@ -7,6 +7,7 @@
 module Wx
 
   # This is the base class for a control or "widget".
+  # 
   # A control is generally a small window which processes user input and/or displays one or more item of data.
   # ### Events emitted by this class
   # 
@@ -52,12 +53,14 @@ module Wx
     
     # Simulates the effect of the user issuing a command to the item.
     # 
+    # 
     # @see Wx::CommandEvent 
     # @param event [Wx::CommandEvent] 
     # @return [void]
     def command(event) end
     
     # Returns the control's label, as it was passed to {Wx::Control#set_label}.
+    # 
     # Note that the returned string may contains mnemonics ("&" characters) if they were passed to the {Wx::Control#set_label} function; use {Wx::Control#get_label_text} if they are undesired.
     # Also note that the returned string is always the string which was passed to {Wx::Control#set_label} but may be different from the string passed to {Wx::Control#set_label_text} (since this last one escapes mnemonic characters).
     # @return [String]
@@ -65,6 +68,7 @@ module Wx
     alias_method :label, :get_label
     
     # Returns the control's label without mnemonics.
+    # 
     # Note that because of the stripping of the mnemonics the returned string may differ from the string which was passed to {Wx::Control#set_label} but should always be the same which was passed to {Wx::Control#set_label_text}.
     # @return [String]
     def get_label_text; end
@@ -72,6 +76,7 @@ module Wx
     
     # @overload get_size_from_text_size(xlen, ylen=-1)
     #   Determine the size needed by the control to leave the given area for its text.
+    #   
     #   This function is mostly useful with control displaying short amounts of text that can be edited by the user, e.g. {Wx::TextCtrl}, {Wx::ComboBox}, {Wx::SearchCtrl} etc. Typically it is used to size these controls for the maximal amount of input they are supposed to contain, for example: 
     #   ```ruby
     #     # Create a control for post code entry.
@@ -98,6 +103,7 @@ module Wx
     alias_method :size_from_text_size, :get_size_from_text_size
     
     # Determine the minimum size needed by the control to display the given text.
+    # 
     # The helper function that uses combination of {Wx::Control#get_size_from_text_size} and {Wx::Control#get_text_extent} which used together pretty often: 
     # ```ruby
     #   def get_size_from_text(text)
@@ -112,6 +118,7 @@ module Wx
     alias_method :size_from_text, :get_size_from_text
     
     # Sets the control's label.
+    # 
     # All "&" characters in the label are special and indicate that the following character is a mnemonic for this control and can be used to activate it from the keyboard (typically by using Alt key in combination with it). To insert a literal ampersand character, you need to double it, i.e. use "&&". If this behaviour is undesirable, use {Wx::Control#set_label_text} instead.
     # @param label [String] 
     # @return [void]
@@ -119,6 +126,7 @@ module Wx
     alias_method :label=, :set_label
     
     # Sets the control's label to exactly the given string.
+    # 
     # Unlike {Wx::Control#set_label}, this function shows exactly the text passed to it in the control, without interpreting ampersands in it in any way. Notice that it means that the control can't have any mnemonic defined for it using this function.
     # @see Wx::Control.escape_mnemonics 
     # @param text [String] 
@@ -127,6 +135,7 @@ module Wx
     alias_method :label_text=, :set_label_text
     
     # Sets the controls label to a string using markup.
+    # 
     # Simple markup supported by this function can be used to apply different fonts or colours to different parts of the control label when supported. If markup is not supported by the control or platform, it is simply stripped and {Wx::Control#set_label} is used with the resulting string.
     # For example, 
     # ```ruby
@@ -219,6 +228,7 @@ module Wx
     alias_method :label_markup=, :set_label_markup
     
     # Returns the given str string without mnemonics ("&" characters).
+    # 
     # <div class="wxrb-note">
     # <b>Note:</b>
     # <p>This function is identical to {Wx::Control#get_label_text} and is provided mostly for symmetry with {Wx::Control.escape_mnemonics}. 
@@ -229,6 +239,7 @@ module Wx
     def self.remove_mnemonics(str) end
     
     # Escapes the special mnemonics characters ("&") in the given string.
+    # 
     # This function can be helpful if you need to set the controls label to a user-provided string. If the string contains ampersands, they wouldn't appear on the display but be used instead to indicate that the character following the first of them can be used as a control mnemonic. While this can sometimes be desirable (e.g. to allow the user to configure mnemonics of the controls), more often you will want to use this function before passing a user-defined string to {Wx::Control#set_label}. Alternatively, if the label is entirely user-defined, you can just call {Wx::Control#set_label_text} directly  but this function must be used if the label is a combination of a part defined by program containing the control mnemonics and a user-defined part.
     # 
     # The same string with the ampersands in it doubled.
@@ -237,6 +248,7 @@ module Wx
     def self.escape_mnemonics(text) end
     
     # Replaces parts of the label string with ellipsis, if needed, so that it fits into maxWidth pixels if possible.
+    # 
     # Note that this function does not guarantee that the returned string will always be shorter than maxWidth; if maxWidth is extremely small, ellipsized text may be larger.
     # @param label [String]  The string to ellipsize
     # @param dc [Wx::DC]  The DC used to retrieve the character widths through the {Wx::DC#get_partial_text_extents} function.

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

@@ -7,6 +7,7 @@
 module Wx
 
   # This is convenience class that derives from both {Wx::Control} and {Wx::ItemContainer}.
+  # 
   # It is used as basis for some wxWidgets controls ({Wx::Choice} and {Wx::ListBox}).
   # 
   # Category:  {Wx::Controls}
@@ -18,22 +19,26 @@ module Wx
   
     # @overload append(item)
     #   Appends item into the control.
+    #   
     #   The return value is the index of the newly inserted item. Note that this may be different from the last one if the control is sorted (e.g. has {Wx::LB_SORT} or {Wx::CB_SORT} style).
     #   @param item [String]  String to add.
     #   @return [Integer]
     # @overload append(item, clientData)
     #   Appends item into the control.
+    #   
     #   The return value is the index of the newly inserted item. Note that this may be different from the last one if the control is sorted (e.g. has {Wx::LB_SORT} or {Wx::CB_SORT} style).
     #   @param item [String]  String to add.
     #   @param clientData [Object]  Pointer to client data to associate with the new item.
     #   @return [Integer]
     # @overload append(items)
     #   Appends several items at once into the control.
+    #   
     #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
     #   @param items [Array<String>]  Array of strings to insert.
     #   @return [Integer]
     # @overload append(items, clientData)
     #   Appends several items at once into the control.
+    #   
     #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
     #   @param items [Array<String>]  Array of strings to insert.
     #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
@@ -41,29 +46,34 @@ module Wx
     def append(*args) end
     
     # Returns a pointer to the client data associated with the given item (if any).
-    # It is an error to call this function for a control which doesn't have untyped client data at all although it is OK to call it even if the given item doesn't have any client data associated with it (but other items do).
+    # 
+    # It is an error to call this function for a control which doesn't have typed client data at all although it is OK to call it even if the given item doesn't have any client data associated with it (but other items do).
+    # Notice that the returned pointer is still owned by the control and will be deleted by it, use {Wx::ControlWithItems#detach_client_object} if you want to remove the pointer from the control.
     # 
     # A pointer to the client data, or NULL if not present.
     # @param n [Integer]  The zero-based position of the item.
     # @return [Object]
-    def get_client_data(n) end
-    alias_method :client_data, :get_client_data
+    def get_client_object(n) end
+    alias_method :client_object, :get_client_object
     
-    # Associates the given untyped client data pointer with the given item.
-    # Note that it is an error to call this function if any typed client data pointers had been associated with the control items before.
+    # Associates the given typed client data pointer with the given item: the data object will be deleted when the item is deleted (either explicitly by using {Wx::ControlWithItems#delete} or implicitly when the control itself is destroyed).
+    # 
+    # Note that it is an error to call this function if any untyped client data pointers had been associated with the control items before.
     # @param n [Integer]  The zero-based item index.
     # @param data [Object]  The client data to associate with the item.
     # @return [void]
-    def set_client_data(n, data) end
+    def set_client_object(n, data) end
     
     # @overload insert(item, pos)
     #   Inserts item into the control.
+    #   
     #   The return value is the index of the newly inserted item. If the insertion failed for some reason, -1 is returned.
     #   @param item [String]  String to add.
     #   @param pos [Integer]  Position to insert item before, zero based.
     #   @return [Integer]
     # @overload insert(item, pos, clientData)
     #   Inserts item into the control.
+    #   
     #   The return value is the index of the newly inserted item. If the insertion failed for some reason, -1 is returned.
     #   @param item [String]  String to add.
     #   @param pos [Integer]  Position to insert item before, zero based.
@@ -71,6 +81,7 @@ module Wx
     #   @return [Integer]
     # @overload insert(items, pos)
     #   Inserts several items at once into the control.
+    #   
     #   Notice that calling this method is usually much faster than inserting them one by one if you need to insert a lot of items.
     #   
     #   The return value is the index of the last inserted item. If the insertion failed for some reason, -1 is returned.
@@ -79,6 +90,7 @@ module Wx
     #   @return [Integer]
     # @overload insert(items, pos, clientData)
     #   Inserts several items at once into the control.
+    #   
     #   Notice that calling this method is usually much faster than inserting them one by one if you need to insert a lot of items.
     #   
     #   The return value is the index of the last inserted item. If the insertion failed for some reason, -1 is returned.
@@ -90,11 +102,13 @@ module Wx
     
     # @overload set(items)
     #   Replaces the current control contents with the given items.
+    #   
     #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
     #   @param items [Array<String>]  Array of strings to insert.
     #   @return [void]
     # @overload set(items, clientData)
     #   Replaces the current control contents with the given items.
+    #   
     #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
     #   @param items [Array<String>]  Array of strings to insert.
     #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
@@ -102,11 +116,13 @@ module Wx
     def set(*args) end
     
     # Removes all items from the control.
+    # 
     # {Wx::ControlWithItems#clear} also deletes the client data of the existing items if it is owned by the control.
     # @return [void]
     def clear; end
     
     # Deletes an item from the control.
+    # 
     # The client data associated with the item will be also deleted if it is owned by the control. Note that it is an error (signalled by an assert failure in debug builds) to remove an item with the index negative or greater or equal than the number of items in the control.
     # If there is a currently selected item below the item being deleted, i.e. if {Wx::ControlWithItems#get_selection} returns a valid index greater than or equal to n, the selection is invalidated when this function is called. However if the selected item appears before the item being deleted, the selection is preserved unchanged.
     # @see Wx::ControlWithItems#clear 
@@ -114,18 +130,31 @@ module Wx
     # @return [void]
     def delete(n) end
     
+    # Returns the client object associated with the given item and transfers its ownership to the caller.
+    # 
+    # This method, unlike {Wx::ControlWithItems#get_client_object}, expects the caller to delete the returned pointer. It also replaces the internally stored pointer with NULL, i.e. completely detaches the client object pointer from the control.
+    # It's an error to call this method unless {Wx::ControlWithItems#has_client_object_data} returns true.
+    # 
+    # The associated client object pointer to be deleted by caller or NULL.
+    # @param n [Integer]  The zero-based item index.
+    # @return [Object]
+    def detach_client_object(n) end
+    
     # Returns true, if either untyped data (<code>void*</code>) or object data ({Wx::ClientData}*) is associated with the items of the control.
     # @return [Boolean]
     def has_client_data; end
     alias_method :has_client_data?, :has_client_data
     
-    # Returns true, if untyped data (<code>void*</code>) is associated with the items of the control.
+    # Returns true, if object data is associated with the items of the control.
+    # 
+    # Object data pointers have the type <code>wxClientData*</code> instead of <code>void*</code> and, importantly, are owned by the control, i.e. will be deleted by it, unlike their untyped counterparts.
     # @return [Boolean]
-    def has_client_untyped_data; end
-    alias_method :has_client_untyped_data?, :has_client_untyped_data
+    def has_client_object_data; end
+    alias_method :has_client_object_data?, :has_client_object_data
     
     # Returns the number of items in the control.
     # 
+    # 
     # @see Wx::ControlWithItems#is_empty 
     # @return [Integer]
     def get_count; end
@@ -133,12 +162,14 @@ module Wx
     
     # Returns true if the control is empty or false if it has some items.
     # 
+    # 
     # @see Wx::ControlWithItems#get_count 
     # @return [Boolean]
     def is_empty; end
     alias_method :empty?, :is_empty
     
     # Returns the label of the item with the given index.
+    # 
     # The index must be valid, i.e. less than the value returned by {Wx::ControlWithItems#get_count}, otherwise an assert is triggered. Notably, this function can't be called if the control is empty.
     # 
     # The label of the item.
@@ -159,6 +190,7 @@ module Wx
     def set_string(n, string) end
     
     # Finds an item whose label matches the given string.
+    # 
     # The zero-based position of the item, or {Wx::NOT_FOUND} if the string was not found.
     # @param string [String]  String to find.
     # @param caseSensitive [Boolean]  Whether search is case sensitive (default is not).
@@ -166,6 +198,7 @@ module Wx
     def find_string(string, caseSensitive=false) end
     
     # Sets the selection to the given item n or removes the selection entirely if n == {Wx::NOT_FOUND}.
+    # 
     # Note that this does not cause any command events to be emitted nor does it deselect any other items in the controls which support multiple selections.
     # @see Wx::ControlWithItems#set_string
     # @see  Wx::ControlWithItems#set_string_selection 
@@ -175,6 +208,7 @@ module Wx
     alias_method :selection=, :set_selection
     
     # Returns the index of the selected item or {Wx::NOT_FOUND} if no item is selected.
+    # 
     # The position of the current selection.
     # @see Wx::ControlWithItems#set_selection
     # @see  Wx::ControlWithItems#get_string_selection 
@@ -183,6 +217,7 @@ module Wx
     alias_method :selection, :get_selection
     
     # Selects the item with the specified string in the control.
+    # 
     # This method doesn't cause any command events to be emitted.
     # Notice that this method is case-insensitive, i.e. the string is compared with all the elements of the control case-insensitively and the first matching entry is selected, even if it doesn't have exactly the same case as this string and there is an exact match afterwards.
     # 
@@ -194,6 +229,7 @@ module Wx
     
     # Returns the label of the selected item or an empty string if no item is selected.
     # 
+    # 
     # @see Wx::ControlWithItems#get_selection 
     # @return [String]
     def get_string_selection; end

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

@@ -7,7 +7,7 @@
 module Wx
 
   # wxRuby version string
-  Wx::WXRUBY_VERSION = '0.9.2'
+  Wx::WXRUBY_VERSION = '0.9.4'
 
   # 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 = 2
+  Wx::WXRUBY_RELEASE = 4
 
   # Convenience string for WxWidgets version info
   WXWIDGETS_VERSION = '3.2.4'

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

@@ -11,6 +11,7 @@ module Wx
   NULL_CURSOR = nil
   
   # A cursor is a small bitmap usually used for denoting where the mouse pointer is, with a picture that might indicate the interpretation of a mouse click.
+  # 
   # As with icons, cursors in X and MS Windows are created in a different manner. Therefore, separate cursors 
   # will be created for the different environments. Platform-specific methods for creating a {Wx::Cursor} object 
   # are catered for, and this is an occasion where conditional compilation will probably be required 
@@ -40,6 +41,7 @@ module Wx
     #   @return [Wx::Cursor]
     # @overload initialize(cursorName, type=Wx::CURSOR_DEFAULT_TYPE, hotSpotX=0, hotSpotY=0)
     #   Constructs a cursor by passing a string resource name or filename.
+    #   
     #   The arguments hotSpotX and hotSpotY are only used when there's no hotspot info in the resource/image-file to load (e.g. when using {Wx::BitmapType::BITMAP_TYPE_ICO} under WXMSW or {Wx::BitmapType::BITMAP_TYPE_XPM} under WXGTK).
     #   @param cursorName [String]  The name of the resource or the image file to load.
     #   @param type [Wx::BitmapType]  Icon type to load. It defaults to {Wx::CURSOR_DEFAULT_TYPE}, which is a \#define associated to different values on different platforms:
@@ -58,6 +60,7 @@ module Wx
     #   @return [Wx::Cursor]
     # @overload initialize(image)
     #   Constructs a cursor from a {Wx::Image}.
+    #   
     #   If cursor are monochrome on the current platform, colors with the RGB elements all greater than 127 will be foreground, colors less than this background. The mask (if any) will be used to specify the transparent area.
     #   In WXMSW the foreground will be white and the background black. If the cursor is larger than 32x32 it is resized.
     #   In WXGTK, colour cursors and alpha channel are supported (starting from GTK+ 2.2). Otherwise the two most frequent colors will be used for foreground and background. In any case, the cursor will be displayed at the size of the image.
@@ -81,6 +84,7 @@ module Wx
     alias_method :ok?, :is_ok
     
     # Returns the coordinates of the cursor hot spot.
+    # 
     # The hot spot is the point at which the mouse is actually considered to be when this cursor is used.
     # This method is currently only implemented in WXMSW and WXGTK2+ and simply returns {Wx::DEFAULT_POSITION} in the other ports.
     # @return [Wx::Point]

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

@@ -7,6 +7,7 @@
 module Wx
 
   # A {Wx::DataFormat} is an encapsulation of a platform-specific format handle which is used by the system for the clipboard and drag and drop operations.
+  # 
   # The applications are usually only interested in, for example, pasting data from the clipboard only if the data is in a format the program understands and a data format is something which uniquely identifies this format.
   # On the system level, a data format is usually just a number (CLIPFORMAT under Windows or Atom under X11, for example) and the standard formats are, indeed, just numbers which can be implicitly converted to {Wx::DataFormat}. The standard formats are:
   # 

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

@@ -11,6 +11,7 @@ module Wx
   FORMAT_INVALID = nil
   
   # A {Wx::DataObject} represents data that can be copied to or from the clipboard, or dragged and dropped.
+  # 
   # The important thing about {Wx::DataObject} is that this is a 'smart' piece of data unlike 'dumb' data containers such as memory buffers or files. Being 'smart' here means that the data object itself should know what data formats it supports and how to render itself in each of its supported formats.
   # A supported format, incidentally, is exactly the format in which the data can be requested from a data object or from which the data object may be set. In the general case, an object may support different formats on 'input' and 'output', i.e. it may be able to render itself in a given format but not be created from data on this format or vice versa. {Wx::DataObject} defines the {Wx::DataObject::Direction} enumeration type which distinguishes between them.
   # See {Wx::DataFormat} documentation for more about formats.
@@ -78,13 +79,15 @@ module Wx
     def initialize; end
     
     # Copies all formats supported in the given direction dir to the array pointed to by formats.
+    # 
     # There must be enough space for GetFormatCount(dir) formats in it.
-    # @param dir [Wx::wxDataObject::Direction] 
+    # @param dir [Wx::DataObject::Direction] 
     # @return [Array<Wx::DataFormat>]
     def get_all_formats(dir=Wx::RTC::RichTextBufferDataObject::Direction::Get) end
     alias_method :all_formats, :get_all_formats
     
     # The method will write the data of the format format to the buffer buf.
+    # 
     # In other words, copy the data from this object in the given format to the supplied buffer. Returns true on success, false on failure.
     # @param format [Wx::DataFormat] 
     # @return [String]
@@ -92,19 +95,21 @@ module Wx
     alias_method :data_here, :get_data_here
     
     # Returns the number of available formats for rendering or setting the data.
-    # @param dir [Wx::wxDataObject::Direction] 
+    # @param dir [Wx::DataObject::Direction] 
     # @return [Integer]
     def get_format_count(dir=Wx::RTC::RichTextBufferDataObject::Direction::Get) end
     alias_method :format_count, :get_format_count
     
     # Returns the preferred format for either rendering the data (if dir is Get, its default value) or for setting it.
+    # 
     # Usually this will be the native format of the {Wx::DataObject}.
-    # @param dir [Wx::wxDataObject::Direction] 
+    # @param dir [Wx::DataObject::Direction] 
     # @return [Wx::DataFormat]
     def get_preferred_format(dir=Wx::RTC::RichTextBufferDataObject::Direction::Get) end
     alias_method :preferred_format, :get_preferred_format
     
     # Set the data in the format format of the length len provided in the buffer buf.
+    # 
     # In other words, copy length bytes of data from the buffer to this data object.
     # 
     # true on success, false on failure.
@@ -115,7 +120,7 @@ module Wx
     
     # Returns true if this format is supported.
     # @param format [Wx::DataFormat] 
-    # @param dir [Wx::wxDataObject::Direction] 
+    # @param dir [Wx::DataObject::Direction] 
     # @return [Boolean]
     def is_supported(format, dir=Wx::RTC::RichTextBufferDataObject::Direction::Get) end
     alias_method :supported?, :is_supported
@@ -131,6 +136,7 @@ module Wx
     def initialize(format=Wx::FORMAT_INVALID) end
     
     # Returns the (one and only one) format supported by this object.
+    # 
     # It is assumed that the format is supported in both directions.
     # @return [Wx::DataFormat]
     def get_format; end
@@ -139,6 +145,7 @@ module Wx
   end # DataObjectSimple
   
   # {Wx::DataObjectComposite} is the simplest {Wx::DataObject} derivation which may be used to support multiple formats.
+  # 
   # It contains several {Wx::DataObjectSimple} objects and supports any format supported by at least one of them. Only one of these data objects is preferred (the first one if not explicitly changed by using the second parameter of {Wx::DataObjectComposite#add}) and its format determines the preferred format of the composite data object as well.
   # See {Wx::DataObject} documentation for the reasons why you might prefer to use {Wx::DataObject} directly instead of {Wx::DataObjectComposite} for efficiency reasons.
   # This example shows how a composite data object capable of storing either bitmaps or file names (presumably of bitmap files) can be initialized and used:
@@ -204,15 +211,17 @@ module Wx
     def add(dataObject, preferred=false) end
     
     # Report the format passed to the {Wx::DataObjectComposite#set_data} method.
+    # 
     # This should be the format of the data object within the composite that received data from the clipboard or the DnD operation. You can use this method to find out what kind of data object was received.
     # @return [Wx::DataFormat]
     def get_received_format; end
     alias_method :received_format, :get_received_format
     
     # Returns the pointer to the object which supports the passed format for the specified direction.
+    # 
     # NULL is returned if the specified format is not supported for this direction dir. The returned pointer is owned by {Wx::DataObjectComposite} itself and shouldn't be deleted by caller.
     # @param format [Wx::DataFormat] 
-    # @param dir [Wx::wxDataObject::Direction] 
+    # @param dir [Wx::DataObject::Direction] 
     # @return [Wx::DataObjectSimple]
     def get_object(format, dir=DataObject::Get) end
     alias_method :object, :get_object
@@ -220,6 +229,7 @@ module Wx
   end # DataObjectComposite
   
   # {Wx::BitmapDataObject} is a specialization of {Wx::DataObject} for bitmap data.
+  # 
   # It can be used without change to paste data into the {Wx::Clipboard} or a {Wx::DropSource}. A user may wish to derive a new class from this class for providing a bitmap on-demand in order to minimize memory consumption when offering data in several formats, such as a bitmap and GIF.
   # This class may be used as is, but {Wx::BitmapDataObject#get_bitmap} may be overridden to increase efficiency.
   # 
@@ -241,12 +251,14 @@ module Wx
     def initialize(bitmap=Wx::NULL_BITMAP) end
     
     # Returns the bitmap associated with the data object.
+    # 
     # You may wish to override this method when offering data on-demand, but this is not required by wxWidgets' internals. Use this method to get data in bitmap form from the {Wx::Clipboard}.
     # @return [Wx::Bitmap]
     def get_bitmap; end
     alias_method :bitmap, :get_bitmap
     
     # Sets the bitmap associated with the data object.
+    # 
     # This method is called when the data object receives data. Usually there will be no reason to override this function.
     # @param bitmap [Wx::Bitmap] 
     # @return [void]
@@ -256,6 +268,7 @@ module Wx
   end # BitmapDataObject
   
   # {Wx::FileDataObject} is a specialization of {Wx::DataObject} for file names.
+  # 
   # The program works with it just as if it were a list of absolute file names, but internally it uses the same format as Explorer and other compatible programs under Windows or GNOME/KDE file manager under Unix which makes it possible to receive files from them using this class.
   # 
   # Category:  Clipboard and Drag & Drop
@@ -286,6 +299,7 @@ module Wx
   end # FileDataObject
   
   # {Wx::TextDataObject} is a specialization of {Wx::DataObjectSimple} for text data.
+  # 
   # It can be used without change to paste data into the {Wx::Clipboard} or a {Wx::DropSource}. A user may wish to derive a new class from this class for providing text on-demand in order to minimize memory consumption when offering data in several formats, such as plain text and RTF because by default the text is stored in a string in this class, but it might as well be generated when requested. For this, {Wx::TextDataObject#get_text_length} and {Wx::TextDataObject#get_text} will have to be overridden.
   # Note that if you already have the text inside a string, you will not achieve any efficiency gain by overriding these functions because copying {Wx::Strings} is already a very efficient operation (data is not actually copied because {Wx::Strings} are reference counted).
   # 
@@ -306,18 +320,21 @@ module Wx
     def initialize(text=('')) end
     
     # Returns the text associated with the data object.
+    # 
     # You may wish to override this method when offering data on-demand, but this is not required by wxWidgets' internals. Use this method to get data in text form from the {Wx::Clipboard}.
     # @return [String]
     def get_text; end
     alias_method :text, :get_text
     
     # Returns the data size.
+    # 
     # By default, returns the size of the text data set in the constructor or using {Wx::TextDataObject#set_text}. This can be overridden to provide text size data on-demand. It is recommended to return the text length plus 1 for a trailing zero, but this is not strictly required.
     # @return [Integer]
     def get_text_length; end
     alias_method :text_length, :get_text_length
     
     # Sets the text associated with the data object.
+    # 
     # This method is called when the data object receives the data and, by default, copies the text into the member variable. If you want to process the text on the fly you may wish to override this function.
     # @param strText [String] 
     # @return [void]
@@ -327,6 +344,7 @@ module Wx
   end # TextDataObject
   
   # {Wx::CustomDataObject} is a specialization of {Wx::DataObjectSimple} for some application-specific data in arbitrary (either custom or one of the standard ones).
+  # 
   # The only restriction is that it is supposed that this data can be copied bitwise (i.e. with <code>memcpy()</code>), so it would be a bad idea to make it contain a C++ object (though C struct is fine).
   # By default, {Wx::CustomDataObject} stores the data inside in a buffer. To put the data into the buffer you may use either {Wx::CustomDataObject#set_data} or {Wx::CustomDataObject#take_data} depending on whether you want the object to make a copy of data or not.
   # This class may be used as is, but if you don't want store the data inside the object but provide it on demand instead, you should override {Wx::CustomDataObject#get_size}, {Wx::CustomDataObject#get_data} and {Wx::CustomDataObject#set_data} (or may be only the first two or only the last one if you only allow reading/writing the data).
@@ -339,6 +357,7 @@ module Wx
   class CustomDataObject < DataObjectSimple
   
     # The constructor accepts a format argument which specifies the (single) format supported by this object.
+    # 
     # If it isn't set here, {Wx::DataObjectSimple#set_format} should be used.
     # @param format [Wx::DataFormat] 
     # @return [Wx::CustomDataObject]
@@ -347,6 +366,7 @@ module Wx
   end # CustomDataObject
   
   # {Wx::ImageDataObject} is a specialization of {Wx::DataObject} for image data.
+  # 
   # It can be used e.g. when you need to put on and retrieve from the clipboard a {Wx::Image} with its metadata (like image resolution).
   # 
   # Category:  Clipboard and Drag & Drop
@@ -378,6 +398,7 @@ module Wx
   end # ImageDataObject
   
   # {Wx::URLDataObject} is a {Wx::DataObject} containing an URL and can be used e.g.
+  # 
   # when you need to put an URL on or retrieve it from the clipboard:
   # 
   # ```ruby
@@ -399,6 +420,7 @@ module Wx
   class URLDataObject < DataObject
   
     # Constructor, may be used to initialize the URL.
+    # 
     # If url is empty, {Wx::URLDataObject#set_url} can be used later.
     # @param url [String] 
     # @return [Wx::URLDataObject]