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

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

@@ -0,0 +1,960 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  # 
+  CC_SPECIAL_DCLICK = 256
+  
+  # 
+  # 
+  CC_STD_BUTTON = 512
+  
+  # 
+  # 
+  # 
+  # 
+  class OwnerDrawnComboBoxPaintingFlags < Wx::Enum
+  
+    # Combo control is being painted, instead of a list item.
+    # 
+    ODCB_PAINTING_CONTROL = Wx::OwnerDrawnComboBoxPaintingFlags.new(1)
+    
+    # An item with selection background is being painted.
+    # 
+    ODCB_PAINTING_SELECTED = Wx::OwnerDrawnComboBoxPaintingFlags.new(2)
+    
+  end # OwnerDrawnComboBoxPaintingFlags
+  
+  # Double-clicking cycles item if {Wx::CB_READONLY} is also used.
+  # 
+  ODCB_DCLICK_CYCLES = 256
+  
+  # If used, control itself is not custom paint using callback.
+  # 
+  ODCB_STD_CONTROL_PAINT = 4096
+  
+  # A combo control is a generic combobox that allows totally custom popup.
+  # In addition it has other customization features. For instance, position and size of the dropdown button can be changed.
+  # 
+  # == Setting Custom Popup for wxComboCtrl
+  # 
+  # {Wx::ComboCtrl} needs to be told somehow which control to use and this is done by {Wx::ComboCtrl#set_popup_control}. However, we need something more than just a {Wx::Control} in this method as, for example, we need to call SetStringValue("initial text value") and {Wx::Control} doesn't have such method. So we also need a {Wx::ComboPopup} which is an interface which must be implemented by a control to be usable as a popup.
+  # We couldn't derive {Wx::ComboPopup} from {Wx::Control} as this would make it impossible to have a class deriving from a wxWidgets control and from it, so instead it is just a mix-in.
+  # Here's a minimal sample of {Wx::ListView} popup:
+  # 
+  # ```
+  #   #include <wx/combo.h>
+  #   #include <wx/listctrl.h>
+  #   
+  #   class wxListViewComboPopup : public wxListView, public wxComboPopup
+  #   {
+  #   public:
+  #       // Initialize member variables
+  #       virtual void Init()
+  #       {
+  #           m_value = -1;
+  #       }
+  #   
+  #       // Create popup control
+  #       virtual bool Create(wxWindow* parent)
+  #       {
+  #           return wxListView::Create(parent,1,wxPoint(0,0),wxDefaultSize);
+  #       }
+  #   
+  #       // Return pointer to the created control
+  #       virtual wxWindow *GetControl() { return this; }
+  #   
+  #       // Translate string into a list selection
+  #       virtual void SetStringValue(const wxString& s)
+  #       {
+  #           int n = wxListView::FindItem(-1,s);
+  #           if ( n >= 0 && n < wxListView::GetItemCount() )
+  #               wxListView::Select(n);
+  #       }
+  #   
+  #       // Get list selection as a string
+  #       virtual wxString GetStringValue() const
+  #       {
+  #           if ( m_value >= 0 )
+  #           return wxListView::GetItemText(m_value);
+  #           return wxEmptyString;
+  #       }
+  #   
+  #       // Do mouse hot-tracking (which is typical in list popups)
+  #       void OnMouseMove(wxMouseEvent& event)
+  #       {
+  #           // TODO: Move selection to cursor
+  #       }
+  #   
+  #       // On mouse left up, set the value and close the popup
+  #       void OnMouseClick(wxMouseEvent& WXUNUSED(event))
+  #       {
+  #           m_value = wxListView::GetFirstSelected();
+  #   
+  #           // TODO: Send event as well
+  #   
+  #           Dismiss();
+  #       }
+  #   
+  #   protected:
+  #   
+  #       int m_value; // current item index
+  #   
+  #   private:
+  #       wxDECLARE_EVENT_TABLE();
+  #   };
+  #   
+  #   wxBEGIN_EVENT_TABLE(wxListViewComboPopup, wxListView)
+  #       EVT_MOTION(wxListViewComboPopup::OnMouseMove)
+  #       EVT_LEFT_UP(wxListViewComboPopup::OnMouseClick)
+  #   wxEND_EVENT_TABLE()
+  # ```
+  # 
+  # Here's how you would create and populate it in a dialog constructor:
+  # 
+  # ```
+  #   wxComboCtrl* comboCtrl = new wxComboCtrl(this, wxID_ANY, wxEmptyString);
+  #   
+  #   wxListViewComboPopup* popupCtrl = new wxListViewComboPopup();
+  #   
+  #   // It is important to call SetPopupControl() as soon as possible
+  #   comboCtrl->SetPopupControl(popupCtrl);
+  #   
+  #   // Populate using wxListView methods
+  #   popupCtrl->InsertItem(popupCtrl->GetItemCount(), "First Item");
+  #   popupCtrl->InsertItem(popupCtrl->GetItemCount(), "Second Item");
+  #   popupCtrl->InsertItem(popupCtrl->GetItemCount(), "Third Item");
+  # ```
+  # 
+  # === Styles
+  # 
+  # This class supports the following styles:
+  # 
+  # - {Wx::CB_READONLY}: Text will not be editable. 
+  # 
+  # - {Wx::CB_SORT}: Sorts the entries in the list alphabetically. 
+  # 
+  # - {Wx::TE_PROCESS_ENTER}: The control will generate the event {Wx::EVT_TEXT_ENTER} (otherwise pressing Enter key is either processed internally by the control or used for navigation between dialog controls). Windows only. 
+  # 
+  # - {Wx::CC_SPECIAL_DCLICK}: Double-clicking triggers a call to popup's OnComboDoubleClick. Actual behaviour is defined by a derived class. For instance, {Wx::OwnerDrawnComboBox} will cycle an item. This style only applies if {Wx::CB_READONLY} is used as well. 
+  # 
+  # - {Wx::CC_STD_BUTTON}: Drop button will behave more like a standard push button. 
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::CommandEvent} events.
+  # Event handler methods for events emitted by this class:
+  # 
+  # - {Wx::EvtHandler#evt_text}(id, meth = nil, &block): Process a {Wx::EVT_TEXT} event, when the text changes. 
+  # 
+  # - {Wx::EvtHandler#evt_text_enter}(id, meth = nil, &block): Process a {Wx::EVT_TEXT_ENTER} event, when RETURN is pressed in the combo control. 
+  # 
+  # - {Wx::EvtHandler#evt_combobox_dropdown}(id, meth = nil, &block): Process a {Wx::EVT_COMBOBOX_DROPDOWN} event, which is generated when the popup window is shown (drops down). 
+  # 
+  # - {Wx::EvtHandler#evt_combobox_closeup}(id, meth = nil, &block): Process a {Wx::EVT_COMBOBOX_CLOSEUP} event, which is generated when the popup window of the combo control disappears (closes up). You should avoid adding or deleting items in this event. 
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> wxMSW Appearance
+  #   </td><td> wxGTK Appearance
+  #   </td><td> wxOSX Appearance
+  #   </td></tr></table></div>
+  # @see Wx::ComboBox
+  # @see  Wx::Choice
+  # @see  Wx::OwnerDrawnComboBox
+  # @see  Wx::ComboPopup
+  # @see  Wx::CommandEvent 
+  # 
+  # 
+  class ComboCtrl < Control
+  
+    include Wx::TextEntry
+  
+    # @overload set_margins(pt)
+    #   Attempts to set the control margins.
+    #   When margins are given as {Wx::Point}, x indicates the left and y the top margin. Use -1 to indicate that an existing value should be used.
+    #   true if setting of all requested margins was successful.
+    #   @param pt [Array(Integer, Integer), Wx::Point] 
+    #   @return [Boolean]
+    # @overload set_margins(left, top=-1)
+    #   Attempts to set the control margins.
+    #   When margins are given as {Wx::Point}, x indicates the left and y the top margin. Use -1 to indicate that an existing value should be used.
+    #   true if setting of all requested margins was successful.
+    #   @param left [Integer] 
+    #   @param top [Integer] 
+    #   @return [Boolean]
+    def set_margins(*args) end
+    alias_method :margins=, :set_margins
+    
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [Wx::ComboCtrl]
+    # @overload initialize(parent, id=Wx::StandardID::ID_ANY, value=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ComboBoxNameStr)
+    #   Constructor, creating and showing a combo control.
+    #   
+    #   @see Wx::ComboCtrl#create
+    #   @see  Wx::Validator 
+    #   @param parent [Wx::Window]  Parent window. Must not be NULL.
+    #   @param id [Integer]  Window identifier. The value {Wx::StandardID::ID_ANY} indicates a default value.
+    #   @param value [String]  Initial selection string. An empty string indicates no selection.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. If {Wx::DEFAULT_SIZE} is specified then the window is sized appropriately.
+    #   @param style [Integer]  Window style. See {Wx::ComboCtrl}.
+    #   @param validator [Wx::Validator]  Window validator.
+    #   @param name [String]  Window name.
+    #   @return [Wx::ComboCtrl]
+    def initialize(*args) end
+    
+    # Copies the selected text to the clipboard.
+    # @return [void]
+    def copy; end
+    
+    # Creates the combo control for two-step construction.
+    # Derived classes should call or replace this function. See {Wx::ComboCtrl#initialize} for further details.
+    # @param parent [Wx::Window] 
+    # @param id [Integer] 
+    # @param value [String] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param validator [Wx::Validator] 
+    # @param name [String] 
+    # @return [Boolean]
+    def create(parent, id=Wx::StandardID::ID_ANY, value=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ComboBoxNameStr) end
+    
+    # Copies the selected text to the clipboard and removes the selection.
+    # @return [void]
+    def cut; end
+    
+    # Dismisses the popup window.
+    # Notice that calling this function will generate a {Wx::EVT_COMBOBOX_CLOSEUP} event.
+    # @return [void]
+    def dismiss; end
+    
+    # Enables or disables popup animation, if any, depending on the value of the argument.
+    # @param enable [Boolean] 
+    # @return [void]
+    def enable_popup_animation(enable=true) end
+    
+    # Returns true if given key combination should toggle the popup.
+    # @param event [Wx::KeyEvent] 
+    # @return [Boolean]
+    def is_key_popup_toggle(event) end
+    alias_method :key_popup_toggle?, :is_key_popup_toggle
+    
+    # Prepare background of combo control or an item in a dropdown list in a way typical on platform.
+    # This includes painting the focus/disabled background and setting the clipping region.
+    # Unless you plan to paint your own focus indicator, you should always call this in your {Wx::ComboPopup#paint_combo_control} implementation. In addition, it sets pen and text colour to what looks good and proper against the background.
+    # flags: {Wx::RendererNative} flags: {Wx::CONTROL_ISSUBMENU}: is drawing a list item instead of combo control {Wx::CONTROL_SELECTED}: list item is selected {Wx::CONTROL_DISABLED}: control/item is disabled
+    # @param dc [Wx::DC] 
+    # @param rect [Wx::Rect] 
+    # @param flags [Integer] 
+    # @return [void]
+    def prepare_background(dc, rect, flags) end
+    
+    # Returns true if focus indicator should be drawn in the control.
+    # @return [Boolean]
+    def should_draw_focus; end
+    
+    # Returns disabled button bitmap that has been set with {Wx::ComboCtrl#set_button_bitmaps}.
+    # The disabled state bitmap.
+    # @return [Wx::Bitmap]
+    def get_bitmap_disabled; end
+    alias_method :bitmap_disabled, :get_bitmap_disabled
+    
+    # Returns button mouse hover bitmap that has been set with {Wx::ComboCtrl#set_button_bitmaps}.
+    # The mouse hover state bitmap.
+    # @return [Wx::Bitmap]
+    def get_bitmap_hover; end
+    alias_method :bitmap_hover, :get_bitmap_hover
+    
+    # Returns default button bitmap that has been set with {Wx::ComboCtrl#set_button_bitmaps}.
+    # The normal state bitmap.
+    # @return [Wx::Bitmap]
+    def get_bitmap_normal; end
+    alias_method :bitmap_normal, :get_bitmap_normal
+    
+    # Returns depressed button bitmap that has been set with {Wx::ComboCtrl#set_button_bitmaps}.
+    # The depressed state bitmap.
+    # @return [Wx::Bitmap]
+    def get_bitmap_pressed; end
+    alias_method :bitmap_pressed, :get_bitmap_pressed
+    
+    # Returns current size of the dropdown button.
+    # @return [Wx::Size]
+    def get_button_size; end
+    alias_method :button_size, :get_button_size
+    
+    # Returns custom painted area in control.
+    # 
+    # @see Wx::ComboCtrl#set_custom_paint_width. 
+    # @return [Integer]
+    def get_custom_paint_width; end
+    alias_method :custom_paint_width, :get_custom_paint_width
+    
+    # Returns the current hint string.
+    # See {Wx::ComboCtrl#set_hint} for more information about hints.
+    # @return [String]
+    def get_hint; end
+    alias_method :hint, :get_hint
+    
+    # Returns the insertion point for the combo control's text field.
+    # Under Windows, this function always returns 0 if the combo control doesn't have the focus.
+    # @return [Integer]
+    def get_insertion_point; end
+    alias_method :insertion_point, :get_insertion_point
+    
+    # Returns the last position in the combo control text field.
+    # @return [Integer]
+    def get_last_position; end
+    alias_method :last_position, :get_last_position
+    
+    # Returns the margins used by the control.
+    # The x field of the returned point is the horizontal margin and the y field is the vertical one.
+    # If given margin cannot be accurately determined, its value will be set to -1.
+    # @see Wx::ComboCtrl#set_margins
+    # @return [Wx::Point]
+    def get_margins; end
+    alias_method :margins, :get_margins
+    
+    # Returns current popup interface that has been set with {Wx::ComboCtrl#set_popup_control}.
+    # @return [Wx::ComboPopup]
+    def get_popup_control; end
+    alias_method :popup_control, :get_popup_control
+    
+    # Returns popup window containing the popup control.
+    # @return [Wx::Window]
+    def get_popup_window; end
+    alias_method :popup_window, :get_popup_window
+    
+    # Get the text control which is part of the combo control.
+    # @return [Wx::TextCtrl]
+    def get_text_ctrl; end
+    alias_method :text_ctrl, :get_text_ctrl
+    
+    # Returns area covered by the text field (includes everything except borders and the dropdown button).
+    # @return [Wx::Rect]
+    def get_text_rect; end
+    alias_method :text_rect, :get_text_rect
+    
+    # Returns text representation of the current value.
+    # For writable combo control it always returns the value in the text field.
+    # @return [String]
+    def get_value; end
+    alias_method :value, :get_value
+    
+    # Returns true if the popup is currently shown.
+    # @return [Boolean]
+    def is_popup_shown; end
+    alias_method :popup_shown?, :is_popup_shown
+    
+    # Returns true if the popup window is in the given state.
+    # Possible values are:
+    # 
+    # {Wx::ComboCtrl::Hidden} 
+    # Popup window is hidden. 
+    # 
+    # {Wx::ComboCtrl::Animating} 
+    # Popup window is being shown, but the popup animation has not yet finished. 
+    # 
+    # {Wx::ComboCtrl::Visible} 
+    # Popup window is fully visible.
+    # @param state [Integer] 
+    # @return [Boolean]
+    def is_popup_window_state(state) end
+    alias_method :popup_window_state?, :is_popup_window_state
+    
+    # Implement in a derived class to define what happens on dropdown button click.
+    # Default action is to show the popup.
+    # If you implement this to do something else than show the popup, you must then also implement {Wx::ComboCtrl#do_set_popup_control} to always return NULL.
+    # @return [void]
+    def on_button_click; end
+    
+    # Pastes text from the clipboard to the text field.
+    # @return [void]
+    def paste; end
+    
+    # Shows the popup portion of the combo control.
+    # Notice that calling this function will generate a {Wx::EVT_COMBOBOX_DROPDOWN} event.
+    # @return [void]
+    def popup; end
+    
+    # Removes the text between the two positions in the combo control text field.
+    # @param from [Integer]  The first position.
+    # @param to [Integer]  The last position.
+    # @return [void]
+    def remove(from, to) end
+    
+    # Replaces the text between two positions with the given text, in the combo control text field.
+    # @param from [Integer]  The first position.
+    # @param to [Integer]  The second position.
+    # @param text [String]  The text to insert.
+    # @return [void]
+    def replace(from, to, text) end
+    
+    # Sets custom dropdown button graphics.
+    # @param bmpNormal [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  Default button image.
+    # @param pushButtonBg [Boolean]  If true, blank push button background is painted below the image.
+    # @param bmpPressed [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  Depressed button image.
+    # @param bmpHover [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  Button image when mouse hovers above it. This should be ignored on platforms and themes that do not generally draw different kind of button on mouse hover.
+    # @param bmpDisabled [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  Disabled button image.
+    # @return [void]
+    def set_button_bitmaps(bmpNormal, pushButtonBg=false, bmpPressed=(Wx::BitmapBundle.new()), bmpHover=(Wx::BitmapBundle.new()), bmpDisabled=(Wx::BitmapBundle.new())) end
+    alias_method :button_bitmaps=, :set_button_bitmaps
+    
+    # Sets size and position of dropdown button.
+    # @param width [Integer]  Button width. Value = 0 specifies default.
+    # @param height [Integer]  Button height. Value = 0 specifies default.
+    # @param side [Integer]  Indicates which side the button will be placed. Value can be {Wx::Direction::LEFT} or {Wx::Direction::RIGHT}.
+    # @param spacingX [Integer]  Horizontal spacing around the button. Default is 0.
+    # @return [void]
+    def set_button_position(width=-1, height=-1, side=Wx::Direction::RIGHT, spacingX=0) end
+    alias_method :button_position=, :set_button_position
+    
+    # Set width, in pixels, of custom painted area in control without {Wx::CB_READONLY} style.
+    # In read-only {Wx::OwnerDrawnComboBox}, this is used to indicate area that is not covered by the focus rectangle.
+    # @param width [Integer] 
+    # @return [void]
+    def set_custom_paint_width(width) end
+    alias_method :custom_paint_width=, :set_custom_paint_width
+    
+    # Sets a hint shown in an empty unfocused combo control.
+    # Notice that hints are known as cue banners under MSW or placeholder strings under macOS.
+    # @see Wx::TextEntry#set_hint
+    # @param hint [String] 
+    # @return [Boolean]
+    def set_hint(hint) end
+    alias_method :hint=, :set_hint
+    
+    # Sets the insertion point in the text field.
+    # @param pos [Integer]  The new insertion point.
+    # @return [void]
+    def set_insertion_point(pos) end
+    alias_method :insertion_point=, :set_insertion_point
+    
+    # Sets the insertion point at the end of the combo control text field.
+    # @return [void]
+    def set_insertion_point_end; end
+    
+    # Uses the given window instead of the default text control as the main window of the combo control.
+    # By default, combo controls without {Wx::CB_READONLY} style create a {Wx::TextCtrl} which shows the current value and allows to edit it. This method allows to use some other window instead of this {Wx::TextCtrl}.
+    # This method can be called after creating the combo fully, however in this case a {Wx::TextCtrl} is unnecessarily created just to be immediately destroyed when it's replaced by a custom window. If you wish to avoid this, you can use the following approach, also shown in the combo sample:
+    # 
+    # ```
+    #   // Create the combo control using its default ctor.
+    #   wxComboCtrl* combo = new wxComboCtrl();
+    #   
+    #   // Create the custom main control using its default ctor too.
+    #   SomeWindow* main = new SomeWindow();
+    #   
+    #   // Set the custom main control before creating the combo.
+    #   combo->SetMainControl(main);
+    #   
+    #   // And only create it now: wxTextCtrl won't be unnecessarily
+    #   // created because the combo already has a main window.
+    #   combo->Create(panel, wxID_ANY, wxEmptyString);
+    #   
+    #   // Finally create the main window itself, now that its parent was
+    #   // created.
+    #   main->Create(combo, ...);
+    # ```
+    # 
+    # Note that when a custom main window is used, none of the methods of this class inherited from {Wx::TextEntry}, such as {Wx::ComboCtrl#set_value}, {Wx::ComboCtrl#replace}, {Wx::ComboCtrl#set_insertion_point} etc do anything and simply return.
+    # @param win [Wx::Window] 
+    # @return [void]
+    def set_main_control(win) end
+    alias_method :main_control=, :set_main_control
+    
+    # Set side of the control to which the popup will align itself.
+    # Valid values are {Wx::Direction::LEFT}, {Wx::Direction::RIGHT} and 0. The default value 0 means that the most appropriate side is used (which, currently, is always {Wx::Direction::LEFT}).
+    # @param anchorSide [Integer] 
+    # @return [void]
+    def set_popup_anchor(anchorSide) end
+    alias_method :popup_anchor=, :set_popup_anchor
+    
+    # Set popup interface class derived from {Wx::ComboPopup}.
+    # This method should be called as soon as possible after the control has been created, unless {Wx::ComboCtrl#on_button_click} has been overridden.
+    # @param popup [Wx::ComboPopup] 
+    # @return [void]
+    def set_popup_control(popup) end
+    alias_method :popup_control=, :set_popup_control
+    
+    # Extends popup size horizontally, relative to the edges of the combo control.
+    # Popup minimum width may override arguments. It is up to the popup to fully take this into account.
+    # @param extLeft [Integer]  How many pixel to extend beyond the left edge of the control. Default is 0.
+    # @param extRight [Integer]  How many pixel to extend beyond the right edge of the control. Default is 0.
+    # @return [void]
+    def set_popup_extents(extLeft, extRight) end
+    
+    # Sets preferred maximum height of the popup.
+    # Value -1 indicates the default.
+    # @param height [Integer] 
+    # @return [void]
+    def set_popup_max_height(height) end
+    alias_method :popup_max_height=, :set_popup_max_height
+    
+    # Sets minimum width of the popup.
+    # If wider than combo control, it will extend to the left.
+    # Value -1 indicates the default. Also, popup implementation may choose to ignore this.
+    # @param width [Integer] 
+    # @return [void]
+    def set_popup_min_width(width) end
+    alias_method :popup_min_width=, :set_popup_min_width
+    
+    # Selects the text between the two positions, in the combo control text field.
+    # @param from [Integer]  The first position.
+    # @param to [Integer]  The second position.
+    # @return [void]
+    def set_selection(from, to) end
+    
+    # Sets the text for the text field without affecting the popup.
+    # Thus, unlike {Wx::ComboCtrl#set_value}, it works equally well with combo control using {Wx::CB_READONLY} style.
+    # @param value [String] 
+    # @return [void]
+    def set_text(value) end
+    alias_method :text=, :set_text
+    
+    # Set a custom window style for the embedded {Wx::TextCtrl}.
+    # Usually you will need to use this during two-step creation, just before {Wx::ComboCtrl#create}. For example:
+    # 
+    # ```
+    #   wxComboCtrl* comboCtrl = new wxComboCtrl();
+    #   
+    #   // Let's make the text right-aligned
+    #   comboCtrl->SetTextCtrlStyle(wxTE_RIGHT);
+    #   
+    #   comboCtrl->Create(parent, wxID_ANY, wxEmptyString);
+    # ```
+    # @param style [Integer] 
+    # @return [void]
+    def set_text_ctrl_style(style) end
+    alias_method :text_ctrl_style=, :set_text_ctrl_style
+    
+    # Sets the text for the combo control text field.
+    # For a combo control with {Wx::CB_READONLY} style the string must be accepted by the popup (for instance, exist in the dropdown list), otherwise the call to {Wx::ComboCtrl#set_value} is ignored.
+    # @param value [String] 
+    # @return [void]
+    def set_value(value) end
+    alias_method :value=, :set_value
+    
+    # Changes value of the control as if user had done it by selecting an item from a combo box drop-down list.
+    # @param value [String] 
+    # @return [void]
+    def set_value_by_user(value) end
+    alias_method :value_by_user=, :set_value_by_user
+    
+    # Undoes the last edit in the text field.
+    # Windows only.
+    # @return [void]
+    def undo; end
+    
+    # Enable or disable usage of an alternative popup window, which guarantees ability to focus the popup control, and allows common native controls to function normally.
+    # This alternative popup window is usually a {Wx::Dialog}, and as such, when it is shown, its parent top-level window will appear as if the focus has been lost from it.
+    # @param enable [Boolean] 
+    # @return [void]
+    def use_alt_popup_window(enable=true) end
+    
+    # Returns features supported by {Wx::ComboCtrl}.
+    # If needed feature is missing, you need to instead use {Wx::GenericComboCtrl}, which however may lack a native look and feel (but otherwise sports identical API).
+    # Value returned is a combination of the flags defined in {Wx::ComboCtrlFeatures}.
+    # @return [Integer]
+    def self.get_features; end
+    
+    
+    protected
+    
+    # This member function is not normally called in application code.
+    # Instead, it can be implemented in a derived class to create a custom popup animation.
+    # The parameters are the same as those for {Wx::ComboCtrl#do_show_popup}.
+    # true if animation finishes before the function returns, false otherwise. In the latter case you need to manually call {Wx::ComboCtrl#do_show_popup} after the animation ends.
+    # @param rect [Wx::Rect] 
+    # @param flags [Integer] 
+    # @return [Boolean]
+    def animate_show(rect, flags) end
+    
+    # This member function is not normally called in application code.
+    # Instead, it can be implemented in a derived class to return default {Wx::ComboPopup}, in case popup is NULL.
+    # If you have implemented {Wx::ComboCtrl#on_button_click} to do something else than show the popup, then {Wx::ComboCtrl#do_set_popup_control} must always set popup to NULL.
+    # @param popup [Wx::ComboPopup] 
+    # @return [void]
+    def do_set_popup_control(popup) end
+    
+    # This member function is not normally called in application code.
+    # Instead, it must be called in a derived class to make sure popup is properly shown after a popup animation has finished (but only if {Wx::ComboCtrl#animate_show} did not finish the animation within its function scope).
+    # @param rect [Wx::Rect]  Position to show the popup window at, in screen coordinates.
+    # @param flags [Integer]  Combination of any of the following: {Wx::ComboCtrl::ShowAbove}, and {Wx::ComboCtrl::CanDeferShow}.
+    # @return [void]
+    def do_show_popup(rect, flags) end
+    
+  end # ComboCtrl
+  
+  # In order to use a custom popup with {Wx::ComboCtrl}, an interface class must be derived from {Wx::ComboPopup}.
+  # For more information on how to use it, see Setting Custom Popup for wxComboCtrl.
+  # === 
+  # 
+  # Category:  {Wx::Controls}
+  # @see Wx::ComboCtrl 
+  # 
+  # 
+  # 
+  # @note  In wxRuby this is a mixin module instead of a (base) class.
+  module ComboPopup
+  
+    # Default constructor.
+    # It is recommended that internal variables are prepared in {Wx::ComboPopup#init} instead (because m_combo is not valid in constructor).
+    # @return [Wx::ComboPopup]
+    def initialize; end
+    
+    # The derived class must implement this to create the popup control.
+    # true if the call succeeded, false otherwise.
+    # @param parent [Wx::Window] 
+    # @return [Boolean]
+    def create(parent) end
+    
+    # You only need to implement this member function if you create your popup class in non-standard way.
+    # The default implementation can handle both multiple-inherited popup control (as seen in {Wx::ComboCtrl} samples) and one allocated separately in heap.
+    # If you do completely re-implement this function, make sure it calls Destroy() for the popup control and also deletes this object (usually as the last thing).
+    # @return [void]
+    def destroy_popup; end
+    
+    # Utility function that hides the popup.
+    # @return [void]
+    def dismiss; end
+    
+    # Implement to customize matching of value string to an item container entry.
+    # Default implementation always return true and does not alter trueItem.
+    # @param item [String]  String entered, usually by user or from SetValue() call.
+    # @param trueItem [String]  When item matches an entry, but the entry's string representation is not exactly the same (case mismatch, for example), then the true item string should be written back to here, if it is not a NULL pointer.
+    # @return [Boolean]
+    def find_item(item, trueItem=nil) end
+    
+    # The derived class may implement this to return adjusted size for the popup control, according to the variables given.
+    # This function is called each time popup is about to be shown.
+    # @param minWidth [Integer]  Preferred minimum width.
+    # @param prefHeight [Integer]  Preferred height. May be -1 to indicate no preference.
+    # @param maxHeight [Integer]  Max height for window, as limited by screen size.
+    # @return [Wx::Size]
+    def get_adjusted_size(minWidth, prefHeight, maxHeight) end
+    alias_method :adjusted_size, :get_adjusted_size
+    
+    # Returns pointer to the associated parent {Wx::ComboCtrl}.
+    # @return [Wx::ComboCtrl]
+    def get_combo_ctrl; end
+    alias_method :combo_ctrl, :get_combo_ctrl
+    
+    # The derived class must implement this to return pointer to the associated control created in {Wx::ComboPopup#create}.
+    # @return [Wx::Window]
+    def get_control; end
+    alias_method :control, :get_control
+    
+    # The derived class must implement this to return string representation of the value.
+    # @return [String]
+    def get_string_value; end
+    alias_method :string_value, :get_string_value
+    
+    # The derived class must implement this to initialize its internal variables.
+    # This method is called immediately after construction finishes. m_combo member variable has been initialized before the call.
+    # @return [void]
+    def init; end
+    
+    # Utility method that returns true if Create has been called.
+    # Useful in conjunction with {Wx::ComboPopup#lazy_create}.
+    # @return [Boolean]
+    def is_created; end
+    alias_method :created?, :is_created
+    
+    # The derived class may implement this to return true if it wants to delay call to {Wx::ComboPopup#create} until the popup is shown for the first time.
+    # It is more efficient, but on the other hand it is often more convenient to have the control created immediately.
+    # Base implementation returns false.
+    # @return [Boolean]
+    def lazy_create; end
+    
+    # The derived class may implement this to do something when the parent {Wx::ComboCtrl} gets double-clicked.
+    # @return [void]
+    def on_combo_double_click; end
+    
+    # The derived class may implement this to receive key events from the parent {Wx::ComboCtrl}.
+    # Events not handled should be skipped, as usual.
+    # @param event [Wx::KeyEvent] 
+    # @return [void]
+    def on_combo_key_event(event) end
+    
+    # The derived class may implement this to do special processing when popup is hidden.
+    # @return [void]
+    def on_dismiss; end
+    
+    # The derived class may implement this to do special processing when popup is shown.
+    # @return [void]
+    def on_popup; end
+    
+    # The derived class may implement this to paint the parent {Wx::ComboCtrl}.
+    # Default implementation draws value as string.
+    # @param dc [Wx::DC] 
+    # @param rect [Wx::Rect] 
+    # @return [void]
+    def paint_combo_control(dc, rect) end
+    
+    # The derived class must implement this to receive string value changes from {Wx::ComboCtrl}.
+    # @param value [String] 
+    # @return [void]
+    def set_string_value(value) end
+    alias_method :string_value=, :set_string_value
+    
+  end # ComboPopup
+  
+  # {Wx::OwnerDrawnComboBox} is a combobox with owner-drawn list items.
+  # In essence, it is a {Wx::ComboCtrl} with {Wx::VListBox} popup and {Wx::ControlWithItems} interface.
+  # Implementing item drawing and measuring is similar to {Wx::VListBox}. Application needs to subclass {Wx::OwnerDrawnComboBox} and implement {Wx::OwnerDrawnComboBox#on_draw_item}, {Wx::OwnerDrawnComboBox#on_measure_item} and {Wx::OwnerDrawnComboBox#on_measure_item_width}.
+  # === Styles
+  # 
+  # This class supports the following styles:
+  # 
+  # - {Wx::ODCB_DCLICK_CYCLES}: Double-clicking cycles item if {Wx::CB_READONLY} is also used. Synonymous with {Wx::CC_SPECIAL_DCLICK}. 
+  # 
+  # - {Wx::ODCB_STD_CONTROL_PAINT}: Control itself is not custom painted using OnDrawItem. Even if this style is not used, writable {Wx::OwnerDrawnComboBox} is never custom painted unless {Wx::OwnerDrawnComboBox#set_custom_paint_width} is called. 
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::CommandEvent} events.
+  # Event handler methods for events emitted by this class:
+  # 
+  # - {Wx::EvtHandler#evt_combobox}(id, meth = nil, &block): Process a {Wx::EVT_COMBOBOX} event, when an item on the list is selected. Note that calling {Wx::OwnerDrawnComboBox#get_value} returns the new value of selection. 
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> wxMSW Appearance
+  #   </td><td> wxGTK Appearance
+  #   </td><td> wxOSX Appearance
+  #   </td></tr></table></div>
+  # @see Wx::ComboCtrl window styles and Window Styles.
+  # 
+  # @see Events emitted by Wx::ComboCtrl.
+  # 
+  # @see Wx::ComboCtrl
+  # @see  Wx::ComboBox
+  # @see  Wx::VListBox
+  # @see  Wx::CommandEvent 
+  # 
+  # 
+  class OwnerDrawnComboBox < ComboCtrl
+  
+    # @overload create(parent, id, value=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ComboBoxNameStr)
+    #   Creates the combobox for two-step construction.
+    #   See {Wx::OwnerDrawnComboBox#initialize} for further details.
+    #   Derived classes should call or replace this function.
+    #   @param parent [Wx::Window] 
+    #   @param id [Integer] 
+    #   @param value [String] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @param validator [Wx::Validator] 
+    #   @param name [String] 
+    #   @return [Boolean]
+    # @overload create(parent, id, value, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ComboBoxNameStr)
+    #   Creates the combobox for two-step construction.
+    #   See {Wx::OwnerDrawnComboBox#initialize} for further details.
+    #   Derived classes should call or replace this function.
+    #   @param parent [Wx::Window] 
+    #   @param id [Integer] 
+    #   @param value [String] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param choices [Array<String>] 
+    #   @param style [Integer] 
+    #   @param validator [Wx::Validator] 
+    #   @param name [String] 
+    #   @return [Boolean]
+    def create(*args) end
+    
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [Wx::OwnerDrawnComboBox]
+    # @overload initialize(parent, id, value, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=("comboBox"))
+    #   Constructor, creating and showing a owner-drawn combobox.
+    #   
+    #   @see Wx::OwnerDrawnComboBox#create
+    #   @see  Wx::Validator 
+    #   @param parent [Wx::Window]  Parent window. Must not be NULL.
+    #   @param id [Integer]  Window identifier. The value {Wx::StandardID::ID_ANY} indicates a default value.
+    #   @param value [String]  Initial selection string. An empty string indicates no selection.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. If {Wx::DEFAULT_SIZE} is specified then the window is sized appropriately.
+    #   @param choices [Array<String>]  An array of strings with which to initialise the control.
+    #   @param style [Integer]  Window style. See {Wx::OwnerDrawnComboBox}.
+    #   @param validator [Wx::Validator]  Window validator.
+    #   @param name [String]  Window name.
+    #   @return [Wx::OwnerDrawnComboBox]
+    def initialize(*args) end
+    
+    # {Wx::OwnerDrawnComboBox#is_empty} is not available in this class.
+    # This method is documented here only to notice that it can't be used with this class because of the ambiguity between the methods with the same name inherited from {Wx::ItemContainer} and {Wx::TextEntry} base classes.
+    # Because of this, any attempt to call it results in a compilation error and you should use either {Wx::OwnerDrawnComboBox#is_list_empty} or {Wx::OwnerDrawnComboBox#is_text_empty} depending on what exactly do you want to test.
+    # @return [Boolean]
+    def is_empty; end
+    alias_method :empty?, :is_empty
+    
+    # Returns true if the list of combobox choices is empty.
+    # Use this method instead of (not available in this class) {Wx::OwnerDrawnComboBox#is_empty} to test if the list of items is empty.
+    # @return [Boolean]
+    def is_list_empty; end
+    alias_method :list_empty?, :is_list_empty
+    
+    # Returns true if the text of the combobox is empty.
+    # Use this method instead of (not available in this class) {Wx::OwnerDrawnComboBox#is_empty} to test if the text currently entered into the combobox is empty.
+    # @return [Boolean]
+    def is_text_empty; end
+    alias_method :text_empty?, :is_text_empty
+    
+    # Returns index to the widest item in the list.
+    # @return [Integer]
+    def get_widest_item; end
+    alias_method :widest_item, :get_widest_item
+    
+    # Returns width of the widest item in the list.
+    # @return [Integer]
+    def get_widest_item_width; end
+    alias_method :widest_item_width, :get_widest_item_width
+    
+    # @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.
+    #   @return [Integer]
+    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).
+    # 
+    # 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
+    
+    # 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.
+    # @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
+    
+    # @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.
+    #   @param clientData [Object]  Pointer to client data to associate with the new item.
+    #   @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.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param pos [Integer]  Position to insert the items before, zero based.
+    #   @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.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param pos [Integer]  Position to insert the items before, zero based.
+    #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
+    #   @return [Integer]
+    def insert(*args) end
+    
+    # @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.
+    #   @return [void]
+    def set(*args) 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::OwnerDrawnComboBox#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::OwnerDrawnComboBox#clear 
+    # @param n [Integer]  The zero-based item index.
+    # @return [void]
+    def delete(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
+    
+    
+    protected
+    
+    # This method is used to draw the items background and, maybe, a border around it.
+    # The base class version implements a reasonable default behaviour which consists in drawing the selected item with the standard background colour and drawing a border around the item if it is either selected or current.
+    # flags has the same meaning as with {Wx::OwnerDrawnComboBox#on_draw_item}.
+    # @param dc [Wx::DC] 
+    # @param rect [Wx::Rect] 
+    # @param item [Integer] 
+    # @param flags [Integer] 
+    # @return [void]
+    def on_draw_background(dc, rect, item, flags) end
+    
+    # The derived class may implement this function to actually draw the item with the given index on the provided DC.
+    # If function is not implemented, the item text is simply drawn, as if the control was a normal combobox.
+    # @param dc [Wx::DC]  The device context to use for drawing
+    # @param rect [Wx::Rect]  The bounding rectangle for the item being drawn (DC clipping region is set to this rectangle before calling this function)
+    # @param item [Integer]  The index of the item to be drawn
+    # @param flags [Integer]  A combination of the {Wx::OwnerDrawnComboBoxPaintingFlags} enumeration values.
+    # @return [void]
+    def on_draw_item(dc, rect, item, flags) end
+    
+    # The derived class may implement this method to return the height of the specified item (in pixels).
+    # The default implementation returns text height, as if this control was a normal combobox.
+    # @param item [Integer] 
+    # @return [Integer]
+    def on_measure_item(item) end
+    
+    # The derived class may implement this method to return the width of the specified item (in pixels).
+    # If -1 is returned, then the item text width is used.
+    # The default implementation returns -1.
+    # @param item [Integer] 
+    # @return [Integer]
+    def on_measure_item_width(item) end
+    
+  end # OwnerDrawnComboBox
+  
+
+end