include/wx/univ/combobox.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/univ/combobox.h
   3 // Purpose:     the universal combobox
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     30.08.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 /*
  13    A few words about all the classes defined in this file are probably in
  14    order: why do we need extra wxComboControl and wxComboPopup classes?
  15
  16    This is because a traditional combobox is a combination of a text control
  17    (with a button allowing to open the pop down list) with a listbox and
  18    wxComboBox class is exactly such control, however we want to also have other
  19    combinations - in fact, we want to allow anything at all to be used as pop
  20    down list, not just a wxListBox.
  21
  22    So we define a base wxComboControl which can use any control as pop down
  23    list and wxComboBox deriving from it which implements the standard wxWindows
  24    combobox API. wxComboControl needs to be told somehow which control to use
  25    and this is done by SetPopupControl(). However, we need something more than
  26    just a wxControl in this method as, for example, we need to call
  27    SetSelection("initial text value") and wxControl doesn't have such method.
  28    So we also need a wxComboPopup which is just a very simple interface which
  29    must be implemented by a control to be usable as a popup.
  30
  31    We couldn't derive wxComboPopup from wxControl as this would make it
  32    impossible to have a class deriving from both wxListBx and from it, so
  33    instead it is just a mix-in.
  34  */
  35
  36 #ifndef _WX_UNIV_COMBOBOX_H_
  37 #define _WX_UNIV_COMBOBOX_H_
  38
  39 #ifdef __GNUG__
  40     #pragma interface "univcombobox.h"
  41 #endif
  42
  43 class WXDLLEXPORT wxComboControl;
  44 class WXDLLEXPORT wxListBox;
  45 class WXDLLEXPORT wxPopupComboWindow;
  46 class WXDLLEXPORT wxTextCtrl;
  47 class WXDLLEXPORT wxButton;
  48
  49 // ----------------------------------------------------------------------------
  50 // the actions supported by this control
  51 // ----------------------------------------------------------------------------
  52
  53 // all actions of single line text controls are supported
  54
  55 // popup/dismiss the choice window
  56 #define wxACTION_COMBOBOX_POPUP     _T("popup")
  57 #define wxACTION_COMBOBOX_DISMISS   _T("dismiss")
  58
  59 // choose the next/prev/specified (by numArg) item
  60 #define wxACTION_COMBOBOX_SELECT_NEXT _T("next")
  61 #define wxACTION_COMBOBOX_SELECT_PREV _T("prev")
  62 #define wxACTION_COMBOBOX_SELECT      _T("select")
  63
  64 // ----------------------------------------------------------------------------
  65 // wxComboPopup is the interface which must be implemented by a control to be
  66 // used as a popup by wxComboControl
  67 // ----------------------------------------------------------------------------
  68
  69 class WXDLLEXPORT wxComboPopup
  70 {
  71 public:
  72     wxComboPopup(wxComboControl *combo) { m_combo = combo; }
  73
  74     // we must have an associated control which is subclassed by the combobox
  75     virtual wxControl *GetControl() = 0;
  76
  77     // called before showing the control to set the initial selection - notice
  78     // that the text passed to this method might not correspond to any valid
  79     // item (if the user edited it directly), in which case the method should
  80     // just return FALSE but not emit any errors
  81     virtual bool SetSelection(const wxString& value) = 0;
  82
  83     // called immediately after the control is shown
  84     virtual void OnShow() = 0;
  85
  86 protected:
  87     wxComboControl *m_combo;
  88 };
  89
  90 // ----------------------------------------------------------------------------
  91 // wxComboControl: a combination of a (single line) text control with a button
  92 // opening a popup window which contains the control from which the user can
  93 // choose the value directly.
  94 // ----------------------------------------------------------------------------
  95
  96 class WXDLLEXPORT wxComboControl : public wxControl
  97 {
  98 public:
  99     // construction
 100     wxComboControl()
 101     {
 102         Init();
 103     }
 104
 105     wxComboControl(wxWindow *parent,
 106                    wxWindowID id,
 107                    const wxString& value = wxEmptyString,
 108                    const wxPoint& pos = wxDefaultPosition,
 109                    const wxSize& size = wxDefaultSize,
 110                    long style = 0,
 111                    const wxValidator& validator = wxDefaultValidator,
 112                    const wxString& name = wxComboBoxNameStr)
 113     {
 114         Init();
 115
 116         (void)Create(parent, id, value, pos, size, style, validator, name);
 117     }
 118
 119     bool Create(wxWindow *parent,
 120                 wxWindowID id,
 121                 const wxString& value = wxEmptyString,
 122                 const wxPoint& pos = wxDefaultPosition,
 123                 const wxSize& size = wxDefaultSize,
 124                 long style = 0,
 125                 const wxValidator& validator = wxDefaultValidator,
 126                 const wxString& name = wxComboBoxNameStr);
 127
 128     virtual ~wxComboControl();
 129
 130     // a combo control needs a control for popup window it displays
 131     void SetPopupControl(wxComboPopup *popup);
 132     wxComboPopup *GetPopupControl() const { return m_popup; }
 133
 134     // show/hide popup window
 135     void ShowPopup();
 136     void HidePopup();
 137
 138     // return TRUE if the popup is currently shown
 139     bool IsPopupShown() const { return m_isPopupShown; }
 140
 141     // get the popup window containing the popup control
 142     wxPopupComboWindow *GetPopupWindow() const { return m_winPopup; }
 143
 144     // get the text control which is part of the combobox
 145     wxTextCtrl *GetText() const { return m_text; }
 146
 147     // implementation only from now on
 148     // -------------------------------
 149
 150     // notifications from wxComboPopup (shouldn't be called by anybody else)
 151
 152     // called when the user selects something in the popup: this normally hides
 153     // the popup and sets the text to the new value
 154     virtual void OnSelect(const wxString& value);
 155
 156     // called when the user dismisses the popup
 157     virtual void OnDismiss();
 158
 159     // forward these functions to all subcontrols
 160     virtual bool Enable(bool enable = TRUE);
 161     virtual bool Show(bool show = TRUE);
 162
 163 protected:
 164     // override the base class virtuals involved into geometry calculations
 165     virtual wxSize DoGetBestClientSize() const;
 166     virtual void DoMoveWindow(int x, int y, int width, int height);
 167     virtual void DoSetSize(int x, int y,
 168                            int width, int height,
 169                            int sizeFlags = wxSIZE_AUTO);
 170
 171     // we have our own input handler and our own actions
 172     virtual bool PerformAction(const wxControlAction& action,
 173                                long numArg = 0l,
 174                                const wxString& strArg = wxEmptyString);
 175
 176     // event handlers
 177     void OnKey(wxKeyEvent& event);
 178
 179     // common part of all ctors
 180     void Init();
 181
 182 private:
 183     // the text control and button we show all the time
 184     wxTextCtrl *m_text;
 185     wxButton *m_btn;
 186
 187     // the popup control
 188     wxComboPopup *m_popup;
 189
 190     // and the popup window containing it
 191     wxPopupComboWindow *m_winPopup;
 192
 193     // the height of the combobox popup as calculated in Create()
 194     wxCoord m_heightPopup;
 195
 196     // is the popup window currenty shown?
 197     bool m_isPopupShown;
 198
 199     DECLARE_EVENT_TABLE()
 200 };
 201
 202 // ----------------------------------------------------------------------------
 203 // wxComboBox: a combination of text control and a listbox
 204 // ----------------------------------------------------------------------------
 205
 206 class WXDLLEXPORT wxComboBox : public wxComboControl, public wxComboBoxBase
 207 {
 208 public:
 209     // ctors and such
 210     wxComboBox() { Init(); }
 211
 212     wxComboBox(wxWindow *parent,
 213                wxWindowID id,
 214                const wxString& value = wxEmptyString,
 215                const wxPoint& pos = wxDefaultPosition,
 216                const wxSize& size = wxDefaultSize,
 217                int n = 0,
 218                const wxString *choices = (const wxString *) NULL,
 219                long style = 0,
 220                const wxValidator& validator = wxDefaultValidator,
 221                const wxString& name = wxComboBoxNameStr)
 222     {
 223         Init();
 224
 225         (void)Create(parent, id, value, pos, size, n, choices,
 226                      style, validator, name);
 227     }
 228
 229     bool Create(wxWindow *parent,
 230                 wxWindowID id,
 231                 const wxString& value = wxEmptyString,
 232                 const wxPoint& pos = wxDefaultPosition,
 233                 const wxSize& size = wxDefaultSize,
 234                 int n = 0,
 235                 const wxString choices[] = (const wxString *) NULL,
 236                 long style = 0,
 237                 const wxValidator& validator = wxDefaultValidator,
 238                 const wxString& name = wxComboBoxNameStr);
 239
 240
 241     virtual ~wxComboBox();
 242
 243     // the wxUniversal-specific methods
 244     // --------------------------------
 245
 246     // implement the combobox interface
 247
 248     // wxTextCtrl methods
 249     virtual wxString GetValue() const;
 250     virtual void SetValue(const wxString& value);
 251     virtual void Copy();
 252     virtual void Cut();
 253     virtual void Paste();
 254     virtual void SetInsertionPoint(long pos);
 255     virtual void SetInsertionPointEnd();
 256     virtual long GetInsertionPoint() const;
 257     virtual long GetLastPosition() const;
 258     virtual void Replace(long from, long to, const wxString& value);
 259     virtual void Remove(long from, long to);
 260     virtual void SetSelection(long from, long to);
 261     virtual void SetEditable(bool editable);
 262
 263     // wxControlWithItems methods
 264     virtual void Clear();
 265     virtual void Delete(int n);
 266     virtual int GetCount() const;
 267     virtual wxString GetString(int n) const;
 268     virtual void SetString(int n, const wxString& s);
 269     virtual int FindString(const wxString& s) const;
 270     virtual void Select(int n);
 271     virtual int GetSelection() const;
 272     void SetSelection(int n) { Select(n); }
 273
 274     void SetStringSelection(const wxString& s) {  }
 275
 276     // we have to redefine these functions here to avoid ambiguities in classes
 277     // deriving from us which would arise otherwise because we inherit these
 278     // methods (with different signatures) from both wxItemContainer via
 279     // wxComboBoxBase (with "int n" parameter) and from wxEvtHandler via
 280     // wxControl and wxComboControl (without)
 281     //
 282     // hopefully, a smart compiler can optimize away these simple inline
 283     // wrappers so we don't suffer much from this
 284
 285     void SetClientData(void *data)
 286     {
 287         wxControl::SetClientData(data);
 288     }
 289
 290     void *GetClientData() const
 291     {
 292         return wxControl::GetClientData();
 293     }
 294
 295     void SetClientObject(wxClientData *data)
 296     {
 297         wxControl::SetClientObject(data);
 298     }
 299
 300     wxClientData *GetClientObject() const
 301     {
 302         return wxControl::GetClientObject();
 303     }
 304
 305     void SetClientData(int n, void* clientData)
 306     {
 307         wxItemContainer::SetClientData(n, clientData);
 308     }
 309
 310     void* GetClientData(int n) const
 311     {
 312         return wxItemContainer::GetClientData(n);
 313     }
 314
 315     void SetClientObject(int n, wxClientData* clientData)
 316     {
 317         wxItemContainer::SetClientObject(n, clientData);
 318     }
 319
 320     wxClientData* GetClientObject(int n) const
 321     {
 322         return wxItemContainer::GetClientObject(n);
 323     }
 324
 325 protected:
 326     virtual int DoAppend(const wxString& item);
 327     virtual void DoSetItemClientData(int n, void* clientData);
 328     virtual void* DoGetItemClientData(int n) const;
 329     virtual void DoSetItemClientObject(int n, wxClientData* clientData);
 330     virtual wxClientData* DoGetItemClientObject(int n) const;
 331
 332     // common part of all ctors
 333     void Init();
 334
 335     // get the associated listbox
 336     wxListBox *GetLBox() const { return m_lbox; }
 337
 338 private:
 339     // the popup listbox
 340     wxListBox *m_lbox;
 341
 342     //DECLARE_EVENT_TABLE()
 343     DECLARE_DYNAMIC_CLASS(wxComboBox)
 344 };
 345
 346 // ----------------------------------------------------------------------------
 347 // wxStdComboBoxInputHandler: allows the user to open/close the combo from kbd
 348 // ----------------------------------------------------------------------------
 349
 350 class WXDLLEXPORT wxStdComboBoxInputHandler : public wxStdInputHandler
 351 {
 352 public:
 353     wxStdComboBoxInputHandler(wxInputHandler *inphand);
 354
 355     virtual bool HandleKey(wxInputConsumer *consumer,
 356                            const wxKeyEvent& event,
 357                            bool pressed);
 358 };
 359
 360 #endif // _WX_UNIV_COMBOBOX_H_