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

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

@@ -7,22 +7,23 @@
 module Wx
 
   # A generic implementation of the GUI event loop.
-  # Category:  Application and Process Management
   # 
+  # Category:  Application and Process Management
   # 
-  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class GUIEventLoop < ::Object
   
     # @return [Wx::GUIEventLoop]
     def initialize; end
     
     # Start the event loop, return the exit code when it is finished.
+    # 
     # Logically, this method calls {Wx::GUIEventLoop#dispatch} in a loop until it returns false and also takes care of generating idle events during each loop iteration. However not all implementations of this class really implement it like this (e.g. WXGTK does not) so you shouldn't rely on {Wx::GUIEventLoop#dispatch} being called from inside this function.
     # The argument passed to {Wx::GUIEventLoop#exit} which terminated this event loop.
     # @return [Integer]
     def run; end
     
     # Return true if this event loop is currently running.
+    # 
     # Notice that even if this event loop hasn't terminated yet but has just spawned a nested (e.g. modal) event loop, this method would return false.
     # @return [Boolean]
     def is_running; end
@@ -34,6 +35,7 @@ module Wx
     alias_method :ok?, :is_ok
     
     # Exit the currently running loop with the given exit code.
+    # 
     # The loop will exit, i.e. its {Wx::GUIEventLoop#run} method will return, during the next event loop iteration.
     # Notice that this method can only be used if this event loop is the currently running one, i.e. its {Wx::GUIEventLoop#is_running} returns true. If this is not the case, an assert failure is triggered and nothing is done as outer event loops can't be exited from immediately. Use {Wx::GUIEventLoop#schedule_exit} if you'd like to exit this loop even if it doesn't run currently.
     # @param rc [Integer] 
@@ -41,6 +43,7 @@ module Wx
     def exit(rc=0) end
     
     # Schedule an exit from the loop with the given exit code.
+    # 
     # This method is similar to {Wx::GUIEventLoop#exit} but can be called even if this event loop is not the currently running one  and if it is the active loop, then it works in exactly the same way as {Wx::GUIEventLoop#exit}.
     # The loop will exit as soon as the control flow returns to it, i.e. after any nested loops terminate.
     # @param rc [Integer] 
@@ -48,11 +51,13 @@ module Wx
     def schedule_exit(rc=0) end
     
     # Return true if any events are available.
+    # 
     # If this method returns true, calling {Wx::GUIEventLoop#dispatch} will not block.
     # @return [Boolean]
     def pending; end
     
     # Dispatches the next event in the windowing system event queue.
+    # 
     # Blocks until an event appears if there are none currently (use {Wx::GUIEventLoop#pending} if this is not wanted).
     # This can be used for programming event loops, e.g.
     # 
@@ -68,6 +73,7 @@ module Wx
     def dispatch; end
     
     # Dispatch an event but not wait longer than the specified timeout for it.
+    # 
     # If an event is received before the specified timeout expires, it is processed and the function returns 1 normally or 0 if the event loop should quite. Otherwise, i.e. if the timeout expires, the functions returns -1 without processing any events.
     # 
     # 1 if an event was processed, 0 if the event loop should quit or -1 if the timeout expired.
@@ -84,6 +90,7 @@ module Wx
     def wake_up_idle; end
     
     # This virtual function is called when the application becomes idle and normally just sends {Wx::IdleEvent} to all interested parties.
+    # 
     # It should return true if more idle events are needed, false if not.
     # @return [Boolean]
     def process_idle; end
@@ -94,6 +101,7 @@ module Wx
     alias_method :yielding?, :is_yielding
     
     # Yields control to pending messages in the windowing system.
+    # 
     # This can be useful, for example, when a time-consuming process writes to a text window. Without an occasional yield, the text window will not be updated properly, and on systems with cooperative multitasking, other processes will not respond.
     # Caution should be exercised, however, since yielding may allow the user to perform actions which are not compatible with the current task. Disabling menu items or whole menus during processing can avoid unwanted reentrance of code: see {Wx::SafeYield} for a better function.
     # Note that {Wx::GUIEventLoop#yield} will not flush the message logs. This is intentional as calling {Wx::GUIEventLoop#yield} is usually done to quickly update the screen and popping up a message box dialog may be undesirable. If you do wish to flush the log messages immediately (otherwise it will be done during the next idle loop iteration), call {Wx::Log.flush_active}.
@@ -103,6 +111,7 @@ module Wx
     def yield(onlyIfNeeded=false) end
     
     # Works like {Wx::GUIEventLoop#yield} with onlyIfNeeded == true, except that it allows the caller to specify a mask of the {Wx::EventCategory} values which indicates which events should be processed and which should instead be "delayed" (i.e.
+    # 
     # processed by the main loop later).
     # Note that this is a safer alternative to {Wx::GUIEventLoop#yield} since it ensures that only the events you're interested to will be processed; i.e. this method helps to avoid unwanted reentrancies.
     # Note that currently only WXMSW and WXGTK do support selective yield of native events coming from the underlying GUI toolkit. wxWidgets events posted using {Wx::EvtHandler#add_pending_event} or {Wx::EvtHandler#queue_event} are instead selectively processed by all ports.
@@ -112,6 +121,7 @@ module Wx
     def yield_for(eventsToProcess) end
     
     # Returns true if the given event category is allowed inside a {Wx::GUIEventLoop#yield_for} call (i.e.
+    # 
     # compares the given category against the last mask passed to {Wx::GUIEventLoop#yield_for}).
     # @see Wx::Event#get_event_category 
     # @param cat [Wx::EventCategory] 

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

@@ -6,7 +6,52 @@
 
 module Wx
 
+  # 
+  # 
+  HD_ALLOW_REORDER = 1
+  
+  # 
+  # 
+  HD_ALLOW_HIDE = 2
+  
+  # 
+  # 
+  HD_BITMAP_ON_RIGHT = 4
+  
+  # 
+  # 
+  HD_DEFAULT_STYLE = 1
+  
+  # Special value used for column width meaning unspecified or default.
+  # 
+  COL_WIDTH_DEFAULT = -1
+  
+  # Size the column automatically to fit all values.
+  # 
+  COL_WIDTH_AUTOSIZE = -2
+  
+  # Column can be resized (included in default flags).
+  # 
+  COL_RESIZABLE = 1
+  
+  # Column can be clicked to toggle the sort order by its contents.
+  # 
+  COL_SORTABLE = 2
+  
+  # Column can be dragged to change its order (included in default).
+  # 
+  COL_REORDERABLE = 4
+  
+  # Column is not shown at all.
+  # 
+  COL_HIDDEN = 8
+  
+  # Default flags for {Wx::HeaderColumn} ctor.
+  # 
+  COL_DEFAULT_FLAGS = 5
+  
   # {Wx::HeaderCtrl} is the control containing the column headings which is usually used for display of tabular data.
+  # 
   # It is used as part of {Wx::GRID::Grid}, in generic version {Wx::DataViewCtrl} and report view of {Wx::ListCtrl} but can be also used independently. In general this class is meant to be used as part of another control which already stores the column information somewhere as it can't be used directly: instead you need to inherit from it and implement the {Wx::HeaderCtrl#get_column} method to provide column information. See {Wx::HeaderCtrlSimple} for a concrete control class which can be used directly.
   # In addition to labeling the columns, the control has the following features:
   # 
@@ -76,10 +121,12 @@ module Wx
   
     # @overload initialize()
     #   Default constructor not creating the underlying window.
+    #   
     #   You must use {Wx::HeaderCtrl#create} after creating the object using this constructor.
     #   @return [Wx::HeaderCtrl]
     # @overload initialize(parent, winid=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::HD_DEFAULT_STYLE, name=Wx::HEADER_CTRL_NAME_STR)
     #   Constructor creating the window.
+    #   
     #   Please see {Wx::HeaderCtrl#create} for the parameters documentation.
     #   @param parent [Wx::Window] 
     #   @param winid [Integer] 
@@ -105,6 +152,7 @@ module Wx
     def create(parent, winid=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::HD_DEFAULT_STYLE, name=Wx::HEADER_CTRL_NAME_STR) end
     
     # Set the number of columns in the control.
+    # 
     # The control will use {Wx::HeaderCtrl#get_column} to get information about all the new columns and refresh itself, i.e. this method also has the same effect as calling {Wx::HeaderCtrl#update_column} for all columns but it should only be used if the number of columns really changed.
     # @param count [Integer] 
     # @return [void]
@@ -112,6 +160,7 @@ module Wx
     alias_method :column_count=, :set_column_count
     
     # Return the number of columns in the control.
+    # 
     # Number of columns as previously set by {Wx::HeaderCtrl#set_column_count}.
     # @see Wx::HeaderCtrl#is_empty 
     # @return [Integer]
@@ -120,18 +169,21 @@ module Wx
     
     # Return whether the control has any columns.
     # 
+    # 
     # @see Wx::HeaderCtrl#get_column_count 
     # @return [Boolean]
     def is_empty; end
     alias_method :empty?, :is_empty
     
     # Update the column with the given index.
+    # 
     # When the value returned by {Wx::HeaderCtrl#get_column} changes, this method must be called to notify the control about the change and update the visual display to match the new column data.
     # @param idx [Integer]  The column index, must be less than {Wx::HeaderCtrl#get_column_count}.
     # @return [void]
     def update_column(idx) end
     
     # Change the columns display order.
+    # 
     # The display order defines the order in which the columns appear on the screen and does not affect the interpretation of indices by all the other class methods.
     # The order array specifies the column indices corresponding to the display positions.
     # @see Wx::ListCtrl#set_columns_order 
@@ -141,6 +193,7 @@ module Wx
     alias_method :columns_order=, :set_columns_order
     
     # Return the array describing the columns display order.
+    # 
     # For the controls without {Wx::HD_ALLOW_REORDER} style the returned array will be the same as was passed to {Wx::HeaderCtrl#set_columns_order} previously or define the default order (with n-th element being n) if it hadn't been called. But for the controls with {Wx::HD_ALLOW_REORDER} style, the columns can be also reordered by user.
     # @return [Array<Integer>]
     def get_columns_order; end
@@ -148,6 +201,7 @@ module Wx
     
     # Return the index of the column displayed at the given position.
     # 
+    # 
     # @see Wx::HeaderCtrl#get_column_pos 
     # @param pos [Integer]  The display position, e.g. 0 for the left-most column, 1 for the next one and so on until {Wx::HeaderCtrl#get_column_count} - 1.
     # @return [Integer]
@@ -155,6 +209,7 @@ module Wx
     alias_method :column_at, :get_column_at
     
     # Get the position at which this column is currently displayed.
+    # 
     # Notice that a valid position is returned even for the hidden columns currently.
     # @see Wx::HeaderCtrl#get_column_at 
     # @param idx [Integer]  The column index, must be less than {Wx::HeaderCtrl#get_column_count}.
@@ -163,11 +218,13 @@ module Wx
     alias_method :column_pos, :get_column_pos
     
     # Reset the columns order to the natural one.
+    # 
     # After calling this function, the column with index idx appears at position idx in the control.
     # @return [void]
     def reset_columns_order; end
     
     # Show the popup menu allowing the user to show or hide the columns.
+    # 
     # This functions shows the popup menu containing all columns with check marks for the ones which are currently shown and allows the user to check or uncheck them to toggle their visibility. It is called from the default EVT_HEADER_RIGHT_CLICK handler for the controls which have {Wx::HD_ALLOW_HIDE} style. And if the column has {Wx::HD_ALLOW_REORDER} style as well, the menu also contains an item to customize the columns shown using which results in {Wx::HeaderCtrl#show_customize_dialog} being called, please see its description for more details.
     # If a column was toggled, {Wx::HeaderCtrl#update_column_visibility} virtual function is called so it must be implemented for the controls with {Wx::HD_ALLOW_HIDE} style or if you call this function explicitly.
     # 
@@ -178,6 +235,7 @@ module Wx
     def show_columns_menu(pt, title=(())) end
     
     # Helper function appending the checkable items corresponding to all the columns to the given menu.
+    # 
     # This function is used by {Wx::HeaderCtrl#show_columns_menu} but can also be used if you show your own custom columns menu and still want all the columns shown in it. It appends menu items with column labels as their text and consecutive ids starting from idColumnsBase to the menu and checks the items corresponding to the currently visible columns.
     # Example of use: 
     # ```
@@ -195,6 +253,7 @@ module Wx
     def add_columns_items(menu, idColumnsBase=0) end
     
     # Show the column customization dialog.
+    # 
     # This function displays a modal dialog containing the list of all columns which the user can use to reorder them as well as show or hide individual columns.
     # If the user accepts the changes done in the dialog, the virtual methods {Wx::HeaderCtrl#update_column_visibility} and {Wx::HeaderCtrl#update_columns_order} will be called so they must be overridden in the derived class if this method is ever called. Please notice that the user will be able to invoke it interactively from the header popup menu if the control has both {Wx::HD_ALLOW_HIDE} and {Wx::HD_ALLOW_REORDER} styles.
     # @see Wx::RearrangeDialog 
@@ -207,6 +266,7 @@ module Wx
     #   @return [Integer]
     # @overload get_column_title_width(idx)
     #   Returns width needed for the column with the given index.
+    #   
     #   This is just a convenient wrapper for the overload taking {Wx::HeaderColumn}.
     #   @param idx [Integer] 
     #   @return [Integer]
@@ -214,6 +274,7 @@ module Wx
     alias_method :column_title_width, :get_column_title_width
     
     # Helper function to manipulate the array of column indices.
+    # 
     # This function reshuffles the array of column indices indexed by positions (i.e. using the same convention as for {Wx::HeaderCtrl#set_columns_order}) so that the column with the given index is found at the specified position.
     # @param order [Array<Integer>]  Array containing the indices of columns in order of their positions.
     # @param idx [Integer]  The index of the column to move.
@@ -231,6 +292,7 @@ module Wx
     alias_method :column, :get_column
     
     # Method called when the column visibility is changed by the user.
+    # 
     # This method is called from {Wx::HeaderCtrl#show_columns_menu} or {Wx::HeaderCtrl#show_customize_dialog} when the user interactively hides or shows a column. A typical implementation will simply update the internally stored column state. Notice that there is no need to call {Wx::HeaderCtrl#update_column} from this method as it is already done by {Wx::HeaderCtrl} itself.
     # The base class version doesn't do anything and must be overridden if this method is called.
     # @param idx [Integer]  The index of the column whose visibility was toggled.
@@ -239,6 +301,7 @@ module Wx
     def update_column_visibility(idx, show) end
     
     # Method called when the columns order is changed in the customization dialog.
+    # 
     # This method is only called from {Wx::HeaderCtrl#show_customize_dialog} when the user changes the order of columns. In particular it is not called if a single column changes place because the user dragged it to the new location, the EVT_HEADER_END_REORDER event handler should be used to react to this.
     # A typical implementation in a derived class will update the display order of the columns in the associated control, if any. Notice that there is no need to call {Wx::HeaderCtrl#set_columns_order} from it as {Wx::HeaderCtrl} does it itself.
     # The base class version doesn't do anything and must be overridden if this method is called.
@@ -247,6 +310,7 @@ module Wx
     def update_columns_order(order) end
     
     # Method which may be implemented by the derived classes to allow double clicking the column separator to resize the column to fit its contents.
+    # 
     # When a separator is double clicked, the default handler of EVT_HEADER_SEPARATOR_DCLICK event calls this function and refreshes the column if it returns true so to implement the resizing of the column to fit its width on header double click you need to implement this method using logic similar to this example: 
     # ```
     #   class MyHeaderColumn : public wxHeaderColumn
@@ -290,6 +354,7 @@ module Wx
     def update_column_width_to_fit(idx, widthTitle) end
     
     # Can be overridden in the derived class to update internal data structures when the number of the columns in the control changes.
+    # 
     # This method is called by {Wx::HeaderCtrl#set_column_count} before effectively changing the number of columns.
     # The base class version does nothing but it is good practice to still call it from the overridden version in the derived class.
     # @param count [Integer] 
@@ -299,13 +364,12 @@ module Wx
   end # HeaderCtrl
   
   # Represents a column header in controls displaying tabular data such as {Wx::DataViewCtrl} or {Wx::GRID::Grid}.
+  # 
   # Notice that this is an abstract base class which is implemented (usually using the information stored in the associated control) by the different controls using {Wx::HeaderCtrl}. As the control only needs to retrieve the information about the column, this class defines only the methods for accessing the various column properties but not for changing them as the setters might not be needed at all, e.g. if the column attributes can only be changed via the methods of the main associated control (this is the case for {Wx::GRID::Grid} for example). If you do want to allow changing them directly using the column itself, you should inherit from {Wx::SettableHeaderColumn} instead of this class.
   # Finally, if you don't already store the column information at all anywhere, you should use the concrete {Wx::HeaderColumnSimple} class and {Wx::HeaderCtrlSimple}.
   # 
   # Category:  {Wx::Controls}
   # 
-  # 
-  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class HeaderColumn < ::Object
   
     # Get the text shown in the column header.
@@ -319,6 +383,7 @@ module Wx
     alias_method :bitmap, :get_bitmap
     
     # Returns the bitmap in the header of the column, if any.
+    # 
     # If the column has no associated bitmap, empty {Wx::BitmapBundle} should be returned.
     # Override this function to return the bundle containing the bitmap to show in the column header. By default delegates to {Wx::HeaderColumn#get_bitmap} but should be overridden if the bitmaps are used.
     # @return [Wx::BitmapBundle]
@@ -326,24 +391,28 @@ module Wx
     alias_method :bitmap_bundle, :get_bitmap_bundle
     
     # Returns the current width of the column.
+    # 
     # Width of the column in pixels, never {Wx::COL_WIDTH_DEFAULT} or {Wx::COL_WIDTH_AUTOSIZE}.
     # @return [Integer]
     def get_width; end
     alias_method :width, :get_width
     
     # Return the minimal column width.
+    # 
     # The minimal width such that the user can't resize the column to lesser size (notice that it is still possible to set the column width to smaller value from the program code). Return 0 from here to allow resizing the column to arbitrarily small size.
     # @return [Integer]
     def get_min_width; end
     alias_method :min_width, :get_min_width
     
     # Returns the current column alignment.
+    # 
     # One of {Wx::Alignment::ALIGN_CENTRE}, {Wx::Alignment::ALIGN_LEFT} or {Wx::Alignment::ALIGN_RIGHT}.
     # @return [Wx::Alignment]
     def get_alignment; end
     alias_method :alignment, :get_alignment
     
     # Get the column flags.
+    # 
     # This method retrieves all the flags at once, you can also use {Wx::HeaderColumn#has_flag} to test for any individual flag or {Wx::HeaderColumn#is_resizeable}, {Wx::HeaderColumn#is_sortable}, {Wx::HeaderColumn#is_reorderable} and {Wx::HeaderColumn#is_hidden} to test for particular flags.
     # @return [Integer]
     def get_flags; end
@@ -356,30 +425,35 @@ module Wx
     alias_method :has_flag?, :has_flag
     
     # Return true if the column can be resized by the user.
+    # 
     # Equivalent to HasFlag({Wx::COL_RESIZABLE}).
     # @return [Boolean]
     def is_resizeable; end
     alias_method :resizeable?, :is_resizeable
     
     # Returns true if the column can be clicked by user to sort the control contents by the field in this column.
+    # 
     # This corresponds to {Wx::COL_SORTABLE} flag which is off by default.
     # @return [Boolean]
     def is_sortable; end
     alias_method :sortable?, :is_sortable
     
     # Returns true if the column can be dragged by user to change its order.
+    # 
     # This corresponds to {Wx::COL_REORDERABLE} flag which is on by default.
     # @return [Boolean]
     def is_reorderable; end
     alias_method :reorderable?, :is_reorderable
     
     # Returns true if the column is currently hidden.
+    # 
     # This corresponds to {Wx::COL_HIDDEN} flag which is off by default.
     # @return [Boolean]
     def is_hidden; end
     alias_method :hidden?, :is_hidden
     
     # Returns true if the column is currently shown.
+    # 
     # This corresponds to the absence of {Wx::COL_HIDDEN} flag.
     # @return [Boolean]
     def is_shown; end
@@ -391,6 +465,7 @@ module Wx
     alias_method :sort_key?, :is_sort_key
     
     # Returns true, if the sort order is ascending.
+    # 
     # Notice that it only makes sense to call this function if the column is used for sorting at all, i.e. if {Wx::HeaderColumn#is_sort_key} returns true.
     # @return [Boolean]
     def is_sort_order_ascending; end
@@ -399,6 +474,7 @@ module Wx
   end # HeaderColumn
   
   # {Wx::HeaderCtrlSimple} is a concrete header control which can be used directly, without inheriting from it as you need to do when using {Wx::HeaderCtrl} itself.
+  # 
   # When using it, you need to use simple {Wx::HeaderCtrlSimple#append_column}, {Wx::HeaderCtrlSimple#insert_column} and {Wx::HeaderCtrlSimple#delete_column} methods instead of setting the number of columns with {Wx::HeaderCtrlSimple#set_column_count} and returning the information about them from the overridden {Wx::HeaderCtrlSimple#get_column}.
   # 
   # Category:  {Wx::Controls}
@@ -409,10 +485,12 @@ module Wx
   
     # @overload initialize()
     #   Default constructor not creating the underlying window.
+    #   
     #   You must use {Wx::HeaderCtrlSimple#create} after creating the object using this constructor.
     #   @return [Wx::HeaderCtrlSimple]
     # @overload initialize(parent, winid=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::HD_DEFAULT_STYLE, name=Wx::HEADER_CTRL_NAME_STR)
     #   Constructor creating the window.
+    #   
     #   Please see the base class {Wx::HeaderCtrl#create} method for the parameters description.
     #   @param parent [Wx::Window] 
     #   @param winid [Integer] 
@@ -425,6 +503,7 @@ module Wx
     
     # Insert the column at the given position.
     # 
+    # 
     # @see Wx::HeaderCtrlSimple#append_column 
     # @param col [Wx::HeaderColumnSimple]  The column to insert. Notice that because of the existence of implicit conversion from {Wx::String} to {Wx::HeaderColumn} a string can be passed directly here.
     # @param idx [Integer]  The position of the new column, from 0 to {Wx::HeaderCtrlSimple#get_column_count}. Using {Wx::HeaderCtrlSimple#get_column_count} means to append the column to the end.
@@ -433,6 +512,7 @@ module Wx
     
     # Append the column to the end of the control.
     # 
+    # 
     # @see Wx::HeaderCtrlSimple#insert_column 
     # @param col [Wx::HeaderColumnSimple] 
     # @return [void]
@@ -440,6 +520,7 @@ module Wx
     
     # Delete the column at the given position.
     # 
+    # 
     # @see Wx::HeaderCtrlSimple#insert_column
     # @see  Wx::HeaderCtrlSimple#append_column 
     # @param idx [Integer] 
@@ -447,6 +528,7 @@ module Wx
     def delete_column(idx) end
     
     # Show or hide the column.
+    # 
     # Initially the column is shown by default or hidden if it was added with {Wx::COL_HIDDEN} flag set.
     # When a column is hidden, it doesn't appear at all on the screen but its index is still taken into account when working with other columns. E.g. if there are three columns 0, 1 and 2 and the column 1 is hidden you still need to use index 2 to refer to the last visible column.
     # @param idx [Integer]  The index of the column to show or hide, from 0 to {Wx::HeaderCtrlSimple#get_column_count}.
@@ -455,6 +537,7 @@ module Wx
     def show_column(idx, show=true) end
     
     # Hide the column with the given index.
+    # 
     # This is the same as calling 
     # ```
     #   ShowColumn(idx, false) 
@@ -465,6 +548,7 @@ module Wx
     def hide_column(idx) end
     
     # Update the column sort indicator.
+    # 
     # The sort indicator, if shown, is typically an arrow pointing upwards or downwards depending on whether the control contents is sorted in ascending or descending order.
     # @param idx [Integer]  The column to set the sort indicator for. If <code>-1</code> is given, then the currently shown sort indicator will be removed.
     # @param sortOrder [Boolean]  If true or false show the sort indicator corresponding to ascending or descending sort order respectively.
@@ -473,6 +557,7 @@ module Wx
     
     # Remove the sort indicator from the column being used as sort key.
     # 
+    # 
     # @see Wx::HeaderCtrlSimple#show_sort_indicator 
     # @return [void]
     def remove_sort_indicator; end
@@ -481,6 +566,7 @@ module Wx
     protected
     
     # This function can be overridden in the classes deriving from this control instead of overriding {Wx::HeaderCtrlSimple#update_column_width_to_fit}.
+    # 
     # To implement automatic column resizing to fit its contents width when the column divider is double clicked, you need to simply return the fitting width for the given column idx from this method, the control will automatically use the biggest value between the one returned from here and the one needed for the display of the column title itself.
     # The base class version returns -1 indicating that this function is not implemented.
     # @param idx [Integer] 
@@ -491,12 +577,11 @@ module Wx
   end # HeaderCtrlSimple
   
   # Adds methods to set the column attributes to {Wx::HeaderColumn}.
+  # 
   # This class adds setters for the column attributes defined by {Wx::HeaderColumn}. It is still an abstract base class and needs to be implemented before using it with {Wx::HeaderCtrl}.
   # 
   # Category:  {Wx::Controls}
   # 
-  # 
-  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SettableHeaderColumn < HeaderColumn
   
     # Set the text to display in the column header.
@@ -506,6 +591,7 @@ module Wx
     alias_method :title=, :set_title
     
     # Set the bitmap to be displayed in the column header.
+    # 
     # Notice that the bitmaps displayed in different columns of the same control must all be of the same size.
     # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
     # @return [void]
@@ -519,6 +605,7 @@ module Wx
     alias_method :width=, :set_width
     
     # Set the minimal column width.
+    # 
     # This method can be used with resizable columns (i.e. those for which {Wx::COL_RESIZABLE} flag is set in {Wx::SettableHeaderColumn#get_flags} or, alternatively, {Wx::SettableHeaderColumn#is_resizeable} returns true) to prevent the user from making them narrower than the given width.
     # @param minWidth [Integer]  The minimal column width in pixels, may be 0 to remove any previously set restrictions.
     # @return [void]
@@ -532,6 +619,7 @@ module Wx
     alias_method :alignment=, :set_alignment
     
     # Set the column flags.
+    # 
     # This method allows setting all flags at once, see also generic {Wx::SettableHeaderColumn#change_flag}, {Wx::SettableHeaderColumn#set_flag}, {Wx::SettableHeaderColumn#clear_flag} and {Wx::SettableHeaderColumn#toggle_flag} methods below as well as specific {Wx::SettableHeaderColumn#set_resizeable}, {Wx::SettableHeaderColumn#set_sortable}, {Wx::SettableHeaderColumn#set_reorderable} and {Wx::SettableHeaderColumn#set_hidden} ones.
     # @param flags [Integer]  Combination of {Wx::COL_RESIZABLE}, {Wx::COL_SORTABLE}, {Wx::COL_REORDERABLE} and {Wx::COL_HIDDEN} bit flags.
     # @return [void]
@@ -540,6 +628,7 @@ module Wx
     
     # Set or clear the given flag.
     # 
+    # 
     # @see Wx::SettableHeaderColumn#set_flags 
     # @param flag [Integer]  The flag to set or clear.
     # @param set [Boolean]  If true, set the flag, i.e. equivalent to calling {Wx::SettableHeaderColumn#set_flag}, otherwise clear it, as {Wx::SettableHeaderColumn#clear_flag}.
@@ -548,6 +637,7 @@ module Wx
     
     # Set the specified flag for the column.
     # 
+    # 
     # @see Wx::SettableHeaderColumn#set_flags 
     # @param flag [Integer] 
     # @return [void]
@@ -556,12 +646,14 @@ module Wx
     
     # Clear the specified flag for the column.
     # 
+    # 
     # @see Wx::SettableHeaderColumn#set_flags 
     # @param flag [Integer] 
     # @return [void]
     def clear_flag(flag) end
     
     # Toggle the specified flag for the column.
+    # 
     # If the flag is currently set, equivalent to {Wx::SettableHeaderColumn#clear_flag}, otherwise  to {Wx::SettableHeaderColumn#set_flag}.
     # @see Wx::SettableHeaderColumn#set_flags 
     # @param flag [Integer] 
@@ -569,6 +661,7 @@ module Wx
     def toggle_flag(flag) end
     
     # Call this to enable or disable interactive resizing of the column by the user.
+    # 
     # By default, the columns are resizable.
     # Equivalent to ChangeFlag({Wx::COL_RESIZABLE}, resizable).
     # @param resizable [Boolean] 
@@ -577,6 +670,7 @@ module Wx
     alias_method :resizeable=, :set_resizeable
     
     # Allow clicking the column to sort the control contents by the field in this column.
+    # 
     # By default, the columns are not sortable so you need to explicitly call this function to allow sorting by the field corresponding to this column.
     # Equivalent to ChangeFlag({Wx::COL_SORTABLE}, sortable).
     # @param sortable [Boolean] 
@@ -585,6 +679,7 @@ module Wx
     alias_method :sortable=, :set_sortable
     
     # Allow changing the column order by dragging it.
+    # 
     # Equivalent to ChangeFlag({Wx::COL_REORDERABLE}, reorderable).
     # @param reorderable [Boolean] 
     # @return [void]
@@ -592,6 +687,7 @@ module Wx
     alias_method :reorderable=, :set_reorderable
     
     # Hide or show the column.
+    # 
     # By default all columns are shown but some of them can be completely hidden from view by calling this function.
     # Equivalent to ChangeFlag({Wx::COL_HIDDEN}, hidden).
     # @param hidden [Boolean] 
@@ -600,11 +696,13 @@ module Wx
     alias_method :hidden=, :set_hidden
     
     # Don't use this column for sorting.
+    # 
     # This is the reverse of {Wx::SettableHeaderColumn#set_sort_order} and is called to indicate that this column is not used for sorting any longer.
     # @return [void]
     def unset_as_sort_key; end
     
     # Sets this column as the sort key for the associated control.
+    # 
     # This function indicates that this column is currently used for sorting the control and also sets the sorting direction. Notice that actual sorting is only done in the control associated with the header, this function doesn't do any sorting on its own.
     # Don't confuse this function with {Wx::SettableHeaderColumn#set_sortable} which should be used to indicate that the column may be used for sorting while this one is used to indicate that it currently is used for sorting. Of course, {Wx::SettableHeaderColumn#set_sort_order} can be only called for sortable columns.
     # @param ascending [Boolean]  If true, sort in ascending order, otherwise in descending order.
@@ -613,6 +711,7 @@ module Wx
     alias_method :sort_order=, :set_sort_order
     
     # Inverses the sort order.
+    # 
     # This function is typically called when the user clicks on a column used for sorting to change sort order from ascending to descending or vice versa.
     # @see Wx::SettableHeaderColumn#set_sort_order
     # @see  Wx::SettableHeaderColumn#is_sort_order_ascending 
@@ -622,6 +721,7 @@ module Wx
   end # SettableHeaderColumn
   
   # Simple container for the information about the column.
+  # 
   # This is a concrete class implementing all {Wx::SettableHeaderColumn} class methods in a trivial way, i.e. by just storing the information in the object itself. It is used by and with {Wx::HeaderCtrlSimple}, e.g. 
   # ```
   #   wxHeaderCtrlSimple * header = new wxHeaderCtrlSimple(...);
@@ -633,12 +733,11 @@ module Wx
   # 
   # Category:  {Wx::Controls}
   # 
-  # 
-  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class HeaderColumnSimple < SettableHeaderColumn
   
     # @overload initialize(title, width=Wx::COL_WIDTH_DEFAULT, align=Wx::Alignment::ALIGN_NOT, flags=Wx::COL_DEFAULT_FLAGS)
     #   Constructor for a column header.
+    #   
     #   The first constructor creates a header showing the given text title while the second one creates one showing the specified bitmap image.
     #   @param title [String] 
     #   @param width [Integer] 
@@ -647,6 +746,7 @@ module Wx
     #   @return [Wx::HeaderColumnSimple]
     # @overload initialize(bitmap, width=Wx::COL_WIDTH_DEFAULT, align=Wx::Alignment::ALIGN_CENTER, flags=Wx::COL_DEFAULT_FLAGS)
     #   Constructor for a column header.
+    #   
     #   The first constructor creates a header showing the given text title while the second one creates one showing the specified bitmap image.
     #   @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
     #   @param width [Integer] 

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

@@ -75,6 +75,7 @@ module Wx
   EVT_HEADER_DRAGGING_CANCELLED = 10169
   
   # Event class representing the events generated by {Wx::HeaderCtrl}.
+  # 
   # Category:  {Wx::Events}
   # @see Wx::HeaderCtrl 
   # 
@@ -82,7 +83,7 @@ module Wx
   class HeaderCtrlEvent < NotifyEvent
   
     # @overload initialize(commandType=Wx::EVT_NULL, winid=0)
-    #   @param commandType [Wx::Slider::EventType] 
+    #   @param commandType [Wx::Notebook::EventType] 
     #   @param winid [Integer] 
     #   @return [Wx::HeaderCtrlEvent]
     # @overload initialize(event)
@@ -91,6 +92,7 @@ module Wx
     def initialize(*args) end
     
     # Return the index of the column affected by this event.
+    # 
     # This method can be called for all header control events.
     # @return [Integer]
     def get_column; end
@@ -102,6 +104,7 @@ module Wx
     alias_method :column=, :set_column
     
     # Return the current width of the column.
+    # 
     # This method can only be called for the dragging events.
     # @return [Integer]
     def get_width; end
@@ -113,6 +116,7 @@ module Wx
     alias_method :width=, :set_width
     
     # Return the new order of the column.
+    # 
     # This method can only be called for a reorder event for which it indicates the tentative new position for the column {Wx::HeaderCtrlEvent#get_column} selected by the user. If the event is not vetoed, this will become the new column position in {Wx::HeaderCtrl#get_columns_order}.
     # @return [Integer]
     def get_new_order; end