wxruby3 0.9.0.pre.rc.2-x64-mingw-ucrt → 0.9.0-x64-mingw-ucrt

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

@@ -0,0 +1,755 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {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:
+  # 
+  # - Column reordering support, either by explicitly configuring the columns order and calling {Wx::HeaderCtrl#set_columns_order} or by dragging the columns interactively (if enabled).
+  # - Display of the icons in the header: this is often used to display a sort or reverse sort indicator when the column header is clicked.
+  # 
+  # Notice that this control itself doesn't do anything other than displaying the column headers. In particular column reordering and sorting must still be supported by the associated control displaying the real data under the header. Also remember to call {Wx::HeaderCtrl#scroll_window} method of the control if the associated data display window has a horizontal scrollbar, otherwise the headers wouldn't align with the data when the window is scrolled.
+  # This control is implemented using the native header control under MSW systems and a generic implementation elsewhere.
+  # 
+  # == Future Improvements
+  # 
+  # Some features are supported by the native MSW control and so could be easily implemented in this version of {Wx::HeaderCtrl} but need to be implemented in the generic version as well to be really useful. Please let us know if you need or, better, plan to work on implementing, any of them:
+  # 
+  # - Displaying bitmaps instead of or together with the text
+  # - Custom drawn headers
+  # - Filters associated with a column.
+  # === Styles
+  # 
+  # This class supports the following styles:
+  # 
+  # - {Wx::HD_ALLOW_REORDER}: If this style is specified (it is by default), the user can reorder the control columns by dragging them. 
+  # 
+  # - {Wx::HD_ALLOW_HIDE}: If this style is specified, the control shows a popup menu allowing the user to change the columns visibility on right mouse click. Notice that the program can always hide or show the columns, this style only affects the users capability to do it. 
+  # 
+  # - {Wx::HD_BITMAP_ON_RIGHT}: The column image, if any, will be shown on the right side if this style is used. Note that this style is only implemented in wxMSW currently and doesn't do anything under the other platforms. It is available since wxWidgets 3.1.1. 
+  # 
+  # - {Wx::HD_DEFAULT_STYLE}: Symbolic name for the default control style, currently equal to {Wx::HD_ALLOW_REORDER}. 
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::HeaderCtrlEvent} events.
+  # Event handler methods for events emitted by this class:
+  # 
+  # - {Wx::EvtHandler#evt_header_click}(id, meth = nil, &block): A column heading was clicked. 
+  # 
+  # - {Wx::EvtHandler#evt_header_right_click}(id, meth = nil, &block): A column heading was right clicked. 
+  # 
+  # - {Wx::EvtHandler#evt_header_middle_click}(id, meth = nil, &block): A column heading was clicked with the middle mouse button. 
+  # 
+  # - {Wx::EvtHandler#evt_header_dclick}(id, meth = nil, &block): A column heading was double clicked. 
+  # 
+  # - {Wx::EvtHandler#evt_header_right_dclick}(id, meth = nil, &block): A column heading was right double clicked. 
+  # 
+  # - {Wx::EvtHandler#evt_header_middle_dclick}(id, meth = nil, &block): A column heading was double clicked with the middle mouse button. 
+  # 
+  # - {Wx::EvtHandler#evt_header_separator_dclick}(id, meth = nil, &block): Separator to the right of the specified column was double clicked (this action is commonly used to resize the column to fit its contents width and the control provides {Wx::HeaderCtrl#update_column_width_to_fit} method to make implementing this easier). 
+  # 
+  # - {Wx::EvtHandler#evt_header_begin_resize}(id, meth = nil, &block): The user started to drag the separator to the right of the column with the specified index (this can only happen for the columns for which {Wx::HeaderColumn#is_resizeable} returns true). The event can be vetoed to prevent the column from being resized. If it isn't, the resizing and end resize (or dragging cancelled) events will be generated later. 
+  # 
+  # - {Wx::EvtHandler#evt_header_resizing}(id, meth = nil, &block): The user is dragging the column with the specified index resizing it and its current width is {Wx::HeaderCtrlEvent#get_width}. The event can be vetoed to stop the dragging operation completely at any time. 
+  # 
+  # - {Wx::EvtHandler#evt_header_end_resize}(id, meth = nil, &block): The user stopped dragging the column by releasing the mouse. The column should normally be resized to the value of {Wx::HeaderCtrlEvent#get_width}. 
+  # 
+  # - {Wx::EvtHandler#evt_header_begin_reorder}(id, meth = nil, &block): The user started to drag the column with the specified index (this can only happen for the controls with {Wx::HD_ALLOW_REORDER} style). This event can be vetoed to prevent the column from being reordered, otherwise the end reorder message will be generated later. 
+  # 
+  # - {Wx::EvtHandler#evt_header_end_reorder}(id, meth = nil, &block): The user dropped the column in its new location. The event can be vetoed to prevent the column from being placed at the new position or handled to update the display of the data in the associated control to match the new column location (available from {Wx::HeaderCtrlEvent#get_new_order}). 
+  # 
+  # - {Wx::EvtHandler#evt_header_dragging_cancelled}(id, meth = nil, &block): The resizing or reordering operation currently in progress was cancelled. This can happen if the user pressed Esc key while dragging the mouse or the mouse capture was lost for some other reason. You only need to handle this event if your application entered into some modal mode when resizing or reordering began, in which case it should handle this event in addition to the matching end resizing or reordering ones. 
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Controls}
+  # @see Wx::GRID::Grid
+  # @see  Wx::ListCtrl
+  # @see  Wx::DataViewCtrl 
+  # 
+  # 
+  class HeaderCtrl < Control
+  
+    # @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::HeaderCtrlNameStr)
+    #   Constructor creating the window.
+    #   Please see {Wx::HeaderCtrl#create} for the parameters documentation.
+    #   @param parent [Wx::Window] 
+    #   @param winid [Integer] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @param name [String] 
+    #   @return [Wx::HeaderCtrl]
+    def initialize(*args) end
+    
+    # Create the header control window.
+    # @param parent [Wx::Window]  The parent window. The header control should be typically positioned along the top edge of this window.
+    # @param winid [Integer]  Id of the control or {Wx::StandardID::ID_ANY} if you don't care.
+    # @param pos [Array(Integer, Integer), Wx::Point]  The initial position of the control.
+    # @param size [Array(Integer, Integer), Wx::Size]  The initial size of the control (usually not very useful as this control will typically be resized to have the same width as the associated data display control).
+    # @param style [Integer]  The control style, {Wx::HD_DEFAULT_STYLE} by default. Notice that the default style allows the user to reorder the columns by dragging them and you need to explicitly turn this feature off by using 
+    #   ```
+    #     wxHD_DEFAULT_STYLE & ~wxHD_ALLOW_REORDER 
+    #   ```
+    #    if this is undesirable.
+    # @param name [String]  The name of the control.
+    # @return [Boolean]
+    def create(parent, winid=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::HD_DEFAULT_STYLE, name=Wx::HeaderCtrlNameStr) 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]
+    def set_column_count(count) end
+    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]
+    def get_column_count; end
+    alias_method :column_count, :get_column_count
+    
+    # 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 
+    # @param order [Array<Integer>]  A permutation of all column indices, i.e. an array of size {Wx::HeaderCtrl#get_columns_order} containing all column indices exactly once. The n-th element of this array defines the index of the column shown at the n-th position from left (for the default left-to-right writing direction).
+    # @return [void]
+    def set_columns_order(order) end
+    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
+    alias_method :columns_order, :get_columns_order
+    
+    # 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]
+    def get_column_at(pos) end
+    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}.
+    # @return [Integer]
+    def get_column_pos(idx) end
+    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.
+    # 
+    # true if a column was shown or hidden or false if nothing was done, e.g. because the menu was cancelled.
+    # @param pt [Array(Integer, Integer), Wx::Point]  The position of the menu, in the header window coordinates.
+    # @param title [String]  The title for the menu if not empty.
+    # @return [Boolean]
+    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: 
+    # ```
+    #   wxMenu menu;
+    #   menu.Append(100, "Some custom command");
+    #   menu.AppendSeparator();
+    #   AddColumnsItems(menu, 200);
+    #   const int rc = GetPopupMenuSelectionFromUser(menu, pt);
+    #   if ( rc >= 200 )
+    #       ... toggle visibility of the column rc-200 ...
+    # ```
+    # @param menu [Wx::Menu]  The menu to append the items to. It may be currently empty or not.
+    # @param idColumnsBase [Integer]  The id for the menu item corresponding to the first column, the other ones are consecutive starting from it. It should be positive.
+    # @return [void]
+    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 
+    # @return [Boolean]
+    def show_customize_dialog; end
+    
+    # @overload get_column_title_width(col)
+    #   Returns width needed for given column's title.
+    #   @param col [Wx::HeaderColumn] 
+    #   @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]
+    def get_column_title_width(*args) end
+    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.
+    # @param pos [Integer]  The new position for the column idx.
+    # @return [void]
+    def self.move_column_in_order_array(order, idx, pos) end
+    
+    
+    protected
+    
+    # Method to be implemented by the derived classes to return the information for the given column.
+    # @param idx [Integer]  The column index, between 0 and the value last passed to {Wx::HeaderCtrl#set_column_count}.
+    # @return [Wx::HeaderColumn]
+    def get_column(idx) end
+    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.
+    # @param show [Boolean]  The new visibility value, true if the column is now shown or false if it is not hidden.
+    # @return [void]
+    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.
+    # @param order [Array<Integer>]  The new column order. This array uses the same convention as {Wx::HeaderCtrl#set_columns_order}.
+    # @return [void]
+    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
+    #   {
+    #   public:
+    #       ...
+    #   
+    #       void SetWidth(int width) { m_width = width; }
+    #       virtual int GetWidth() const { return m_width; }
+    #   
+    #   private:
+    #       int m_width;
+    #   };
+    #   
+    #   class MyHeaderCtrl : public wxHeaderCtrl
+    #   {
+    #   public:
+    #   protected:
+    #       virtual wxHeaderColumn& GetColumn(unsigned int idx) const
+    #       {
+    #           return m_cols[idx];
+    #       }
+    #   
+    #       virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle)
+    #       {
+    #           int widthContents = ... compute minimal width for column idx ...
+    #           m_cols[idx].SetWidth(wxMax(widthContents, widthTitle));
+    #           return true;
+    #       }
+    #   
+    #       wxVector<MyHeaderColumn> m_cols;
+    #   };
+    # ```
+    # 
+    # Base class version simply returns false.
+    # 
+    # true to indicate that the column was resized, i.e. {Wx::HeaderCtrl#get_column} now returns the new width value, and so must be refreshed or false meaning that the control didn't reach to the separator double click.
+    # @param idx [Integer]  The zero-based index of the column to update.
+    # @param widthTitle [Integer]  Contains minimal width needed to display the column header itself and will usually be used as a starting point for the fitting width calculation.
+    # @return [Boolean]
+    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] 
+    # @return [void]
+    def on_column_count_changing(count) end
+    
+  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.
+    # @return [String]
+    def get_title; end
+    alias_method :title, :get_title
+    
+    # This function exists only for backwards compatibility, it's recommended to override {Wx::HeaderColumn#get_bitmap_bundle} in the new code and override this one to do nothing, as it will never be called if {Wx::HeaderColumn#get_bitmap_bundle} is overridden.
+    # @return [Wx::Bitmap]
+    def get_bitmap; end
+    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]
+    def get_bitmap_bundle; end
+    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
+    alias_method :flags, :get_flags
+    
+    # Return true if the specified flag is currently set for this column.
+    # @param flag [Integer] 
+    # @return [Boolean]
+    def has_flag(flag) end
+    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
+    alias_method :shown?, :is_shown
+    
+    # Returns true if the column is currently used for sorting.
+    # @return [Boolean]
+    def is_sort_key; end
+    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
+    alias_method :sort_order_ascending?, :is_sort_order_ascending
+    
+  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}
+  # @see Wx::HeaderCtrl 
+  # 
+  # 
+  class HeaderCtrlSimple < HeaderCtrl
+  
+    # @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::HeaderCtrlNameStr)
+    #   Constructor creating the window.
+    #   Please see the base class {Wx::HeaderCtrl#create} method for the parameters description.
+    #   @param parent [Wx::Window] 
+    #   @param winid [Integer] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @param name [String] 
+    #   @return [Wx::HeaderCtrlSimple]
+    def initialize(*args) end
+    
+    # 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.
+    # @return [void]
+    def insert_column(col, idx) end
+    
+    # Append the column to the end of the control.
+    # 
+    # @see Wx::HeaderCtrlSimple#insert_column 
+    # @param col [Wx::HeaderColumnSimple] 
+    # @return [void]
+    def append_column(col) end
+    
+    # Delete the column at the given position.
+    # 
+    # @see Wx::HeaderCtrlSimple#insert_column
+    # @see  Wx::HeaderCtrlSimple#append_column 
+    # @param idx [Integer] 
+    # @return [void]
+    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}.
+    # @param show [Boolean]  Indicates whether the column should be shown (default) or hidden.
+    # @return [void]
+    def show_column(idx, show=true) end
+    
+    # Hide the column with the given index.
+    # This is the same as calling 
+    # ```
+    #   ShowColumn(idx, false) 
+    # ```
+    # .
+    # @param idx [Integer]  The index of the column to show or hide, from 0 to {Wx::HeaderCtrlSimple#get_column_count}.
+    # @return [void]
+    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.
+    # @return [void]
+    def show_sort_indicator(idx, sortOrder=true) end
+    
+    # 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
+    
+    
+    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] 
+    # @return [Integer]
+    def get_best_fitting_width(idx) end
+    alias_method :best_fitting_width, :get_best_fitting_width
+    
+  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.
+    # @param title [String] 
+    # @return [void]
+    def set_title(title) end
+    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]
+    def set_bitmap(bitmap) end
+    alias_method :bitmap=, :set_bitmap
+    
+    # Set the column width.
+    # @param width [Integer]  The column width in pixels or the special {Wx::COL_WIDTH_DEFAULT} (meaning to use default width) or {Wx::COL_WIDTH_AUTOSIZE} (size to fit the content) value.
+    # @return [void]
+    def set_width(width) end
+    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]
+    def set_min_width(minWidth) end
+    alias_method :min_width=, :set_min_width
+    
+    # Set the alignment of the column header.
+    # @param align [Wx::Alignment]  The text alignment in horizontal direction only or {Wx::Alignment::ALIGN_NOT} to use the default alignment, The possible values here are {Wx::Alignment::ALIGN_CENTRE}, {Wx::Alignment::ALIGN_LEFT} or {Wx::Alignment::ALIGN_RIGHT} with {Wx::Alignment::ALIGN_CENTRE_HORIZONTAL} being also supported as synonym for {Wx::Alignment::ALIGN_CENTRE} for consistency (but notice that {Wx::SettableHeaderColumn#get_alignment} never returns it).
+    # @return [void]
+    def set_alignment(align) end
+    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]
+    def set_flags(flags) end
+    alias_method :flags=, :set_flags
+    
+    # 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}.
+    # @return [void]
+    def change_flag(flag, set) end
+    
+    # Set the specified flag for the column.
+    # 
+    # @see Wx::SettableHeaderColumn#set_flags 
+    # @param flag [Integer] 
+    # @return [void]
+    def set_flag(flag) end
+    alias_method :flag=, :set_flag
+    
+    # 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] 
+    # @return [void]
+    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] 
+    # @return [void]
+    def set_resizeable(resizable) end
+    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] 
+    # @return [void]
+    def set_sortable(sortable) end
+    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]
+    def set_reorderable(reorderable) end
+    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] 
+    # @return [void]
+    def set_hidden(hidden) end
+    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.
+    # @return [void]
+    def set_sort_order(ascending) end
+    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 
+    # @return [void]
+    def toggle_sort_order; end
+    
+  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(...);
+  #   wxHeaderColumnSimple col("Title");
+  #   col.SetWidth(100);
+  #   col.SetSortable(100);
+  #   header->AppendColumn(col);
+  # ```
+  # 
+  # === 
+  # 
+  # 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] 
+    #   @param align [Wx::Alignment] 
+    #   @param flags [Integer] 
+    #   @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] 
+    #   @param align [Wx::Alignment] 
+    #   @param flags [Integer] 
+    #   @return [Wx::HeaderColumnSimple]
+    def initialize(*args) end
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @param title [String] 
+    # @return [void]
+    def set_title(title) end
+    alias_method :title=, :set_title
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [String]
+    def get_title; end
+    alias_method :title, :get_title
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    # @return [void]
+    def set_bitmap(bitmap) end
+    alias_method :bitmap=, :set_bitmap
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [Wx::Bitmap]
+    def get_bitmap; end
+    alias_method :bitmap, :get_bitmap
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [Wx::BitmapBundle]
+    def get_bitmap_bundle; end
+    alias_method :bitmap_bundle, :get_bitmap_bundle
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @param width [Integer] 
+    # @return [void]
+    def set_width(width) end
+    alias_method :width=, :set_width
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [Integer]
+    def get_width; end
+    alias_method :width, :get_width
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @param minWidth [Integer] 
+    # @return [void]
+    def set_min_width(minWidth) end
+    alias_method :min_width=, :set_min_width
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [Integer]
+    def get_min_width; end
+    alias_method :min_width, :get_min_width
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @param align [Wx::Alignment] 
+    # @return [void]
+    def set_alignment(align) end
+    alias_method :alignment=, :set_alignment
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [Wx::Alignment]
+    def get_alignment; end
+    alias_method :alignment, :get_alignment
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @param flags [Integer] 
+    # @return [void]
+    def set_flags(flags) end
+    alias_method :flags=, :set_flags
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [Integer]
+    def get_flags; end
+    alias_method :flags, :get_flags
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [Boolean]
+    def is_sort_key; end
+    alias_method :sort_key?, :is_sort_key
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @param ascending [Boolean] 
+    # @return [void]
+    def set_sort_order(ascending) end
+    alias_method :sort_order=, :set_sort_order
+    
+    # Trivial implementations of the base class pure virtual functions.
+    # @return [Boolean]
+    def is_sort_order_ascending; end
+    alias_method :sort_order_ascending?, :is_sort_order_ascending
+    
+  end # HeaderColumnSimple
+  
+
+end