]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: univ/combobox.cpp | |
3 | // Purpose: wxComboControl and wxComboBox implementation | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 15.12.00 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com) | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | #ifdef __GNUG__ | |
21 | #pragma implementation "univcombobox.h" | |
22 | #endif | |
23 | ||
24 | #include "wx/wxprec.h" | |
25 | ||
26 | #ifdef __BORLANDC__ | |
27 | #pragma hdrstop | |
28 | #endif | |
29 | ||
30 | #if wxUSE_COMBOBOX | |
31 | ||
32 | #ifndef WX_PRECOMP | |
33 | #include "wx/log.h" | |
34 | ||
35 | #include "wx/button.h" | |
36 | #include "wx/combobox.h" | |
37 | #include "wx/listbox.h" | |
38 | #include "wx/textctrl.h" | |
39 | #include "wx/bmpbuttn.h" | |
40 | ||
41 | #include "wx/validate.h" | |
42 | #endif | |
43 | ||
44 | #include "wx/popupwin.h" | |
45 | ||
46 | #include "wx/univ/renderer.h" | |
47 | #include "wx/univ/inphand.h" | |
48 | #include "wx/univ/theme.h" | |
49 | ||
50 | /* | |
51 | The keyboard event flow: | |
52 | ||
53 | 1. they always come to the text ctrl | |
54 | 2. it forwards the ones it doesn't process to the wxComboControl | |
55 | 3. which passes them to the popup window if it is popped up | |
56 | */ | |
57 | ||
58 | // ---------------------------------------------------------------------------- | |
59 | // wxComboButton is just a normal button except that it sends commands to the | |
60 | // combobox and not its parent | |
61 | // ---------------------------------------------------------------------------- | |
62 | ||
63 | class wxComboButton : public wxBitmapButton | |
64 | { | |
65 | public: | |
66 | wxComboButton(wxComboControl *combo) | |
67 | : wxBitmapButton(combo->GetParent(), -1, wxNullBitmap, | |
68 | wxDefaultPosition, wxDefaultSize, | |
69 | wxBORDER_NONE | wxBU_EXACTFIT) | |
70 | { | |
71 | m_combo = combo; | |
72 | ||
73 | wxBitmap bmpNormal, bmpFocus, bmpPressed, bmpDisabled; | |
74 | ||
75 | GetRenderer()->GetComboBitmaps(&bmpNormal, | |
76 | &bmpFocus, | |
77 | &bmpPressed, | |
78 | &bmpDisabled); | |
79 | ||
80 | SetBitmapLabel(bmpNormal); | |
81 | SetBitmapFocus(bmpFocus.Ok() ? bmpFocus : bmpNormal); | |
82 | SetBitmapSelected(bmpPressed.Ok() ? bmpPressed : bmpNormal); | |
83 | SetBitmapDisabled(bmpDisabled.Ok() ? bmpDisabled : bmpNormal); | |
84 | ||
85 | SetBestSize(wxDefaultSize); | |
86 | } | |
87 | ||
88 | protected: | |
89 | void OnButton(wxCommandEvent& event) { m_combo->ShowPopup(); } | |
90 | ||
91 | virtual wxSize DoGetBestClientSize() const | |
92 | { | |
93 | const wxBitmap& bmp = GetBitmapLabel(); | |
94 | ||
95 | return wxSize(bmp.GetWidth(), bmp.GetHeight()); | |
96 | ||
97 | } | |
98 | ||
99 | private: | |
100 | wxComboControl *m_combo; | |
101 | ||
102 | DECLARE_EVENT_TABLE() | |
103 | }; | |
104 | ||
105 | // ---------------------------------------------------------------------------- | |
106 | // wxComboListBox is a listbox modified to be used as a popup window in a | |
107 | // combobox | |
108 | // ---------------------------------------------------------------------------- | |
109 | ||
110 | class wxComboListBox : public wxListBox, public wxComboPopup | |
111 | { | |
112 | public: | |
113 | // ctor and dtor | |
114 | wxComboListBox(wxComboControl *combo, int style = 0); | |
115 | virtual ~wxComboListBox(); | |
116 | ||
117 | // implement wxComboPopup methods | |
118 | virtual bool SetSelection(const wxString& value); | |
119 | virtual wxControl *GetControl() { return this; } | |
120 | virtual void OnShow(); | |
121 | ||
122 | protected: | |
123 | // we shouldn't return height too big from here | |
124 | virtual wxSize DoGetBestClientSize() const; | |
125 | ||
126 | // filter mouse move events happening outside the list box | |
127 | void OnMouseMove(wxMouseEvent& event); | |
128 | ||
129 | // set m_clicked value from here | |
130 | void OnLeftUp(wxMouseEvent& event); | |
131 | ||
132 | // called whenever the user selects or activates a listbox item | |
133 | void OnSelect(wxCommandEvent& event); | |
134 | ||
135 | // used to process wxUniv actions | |
136 | bool PerformAction(const wxControlAction& action, | |
137 | long numArg, | |
138 | const wxString& strArg); | |
139 | ||
140 | private: | |
141 | // has the mouse been released on this control? | |
142 | bool m_clicked; | |
143 | ||
144 | DECLARE_EVENT_TABLE() | |
145 | }; | |
146 | ||
147 | // ---------------------------------------------------------------------------- | |
148 | // wxComboTextCtrl is a simple text ctrl which forwards | |
149 | // wxEVT_COMMAND_TEXT_UPDATED events and all key events to the combobox | |
150 | // ---------------------------------------------------------------------------- | |
151 | ||
152 | class wxComboTextCtrl : public wxTextCtrl | |
153 | { | |
154 | public: | |
155 | wxComboTextCtrl(wxComboControl *combo, | |
156 | const wxString& value, | |
157 | long style, | |
158 | const wxValidator& validator); | |
159 | ||
160 | protected: | |
161 | void OnKey(wxKeyEvent& event); | |
162 | void OnText(wxCommandEvent& event); | |
163 | ||
164 | private: | |
165 | wxComboControl *m_combo; | |
166 | ||
167 | DECLARE_EVENT_TABLE() | |
168 | }; | |
169 | ||
170 | // ---------------------------------------------------------------------------- | |
171 | // event tables and such | |
172 | // ---------------------------------------------------------------------------- | |
173 | ||
174 | BEGIN_EVENT_TABLE(wxComboButton, wxButton) | |
175 | EVT_BUTTON(-1, wxComboButton::OnButton) | |
176 | END_EVENT_TABLE() | |
177 | ||
178 | BEGIN_EVENT_TABLE(wxComboListBox, wxListBox) | |
179 | EVT_LISTBOX(-1, wxComboListBox::OnSelect) | |
180 | EVT_LISTBOX_DCLICK(-1, wxComboListBox::OnSelect) | |
181 | EVT_MOTION(wxComboListBox::OnMouseMove) | |
182 | EVT_LEFT_UP(wxComboListBox::OnLeftUp) | |
183 | END_EVENT_TABLE() | |
184 | ||
185 | BEGIN_EVENT_TABLE(wxComboControl, wxControl) | |
186 | EVT_KEY_DOWN(wxComboControl::OnKey) | |
187 | EVT_KEY_UP(wxComboControl::OnKey) | |
188 | END_EVENT_TABLE() | |
189 | ||
190 | BEGIN_EVENT_TABLE(wxComboTextCtrl, wxTextCtrl) | |
191 | EVT_KEY_DOWN(wxComboTextCtrl::OnKey) | |
192 | EVT_KEY_UP(wxComboTextCtrl::OnKey) | |
193 | EVT_TEXT(-1, wxComboTextCtrl::OnText) | |
194 | END_EVENT_TABLE() | |
195 | ||
196 | IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl) | |
197 | ||
198 | // ============================================================================ | |
199 | // implementation | |
200 | // ============================================================================ | |
201 | ||
202 | // ---------------------------------------------------------------------------- | |
203 | // wxComboControl creation | |
204 | // ---------------------------------------------------------------------------- | |
205 | ||
206 | void wxComboControl::Init() | |
207 | { | |
208 | m_popup = (wxComboPopup *)NULL; | |
209 | m_winPopup = (wxPopupComboWindow *)NULL; | |
210 | m_isPopupShown = FALSE; | |
211 | m_btn = NULL; | |
212 | m_text = NULL; | |
213 | } | |
214 | ||
215 | bool wxComboControl::Create(wxWindow *parent, | |
216 | wxWindowID id, | |
217 | const wxString& value, | |
218 | const wxPoint& pos, | |
219 | const wxSize& size, | |
220 | long style, | |
221 | const wxValidator& validator, | |
222 | const wxString& name) | |
223 | { | |
224 | // first create our own window, i.e. the one which will contain all | |
225 | // subcontrols | |
226 | style &= ~wxBORDER_NONE; | |
227 | style |= wxBORDER_SUNKEN; | |
228 | if ( !wxControl::Create(parent, id, pos, size, style, validator, name) ) | |
229 | return FALSE; | |
230 | ||
231 | // create the text control and the button as our siblings (*not* children), | |
232 | // don't care about size/position here - they will be set in DoMoveWindow() | |
233 | m_btn = new wxComboButton(this); | |
234 | m_text = new wxComboTextCtrl(this, | |
235 | value, | |
236 | style & wxCB_READONLY ? wxTE_READONLY : 0, | |
237 | validator); | |
238 | ||
239 | // for compatibility with the other ports, the height specified is the | |
240 | // combined height of the combobox itself and the popup | |
241 | if ( size.y == -1 ) | |
242 | { | |
243 | // ok, use default height for popup too | |
244 | m_heightPopup = -1; | |
245 | } | |
246 | else | |
247 | { | |
248 | m_heightPopup = size.y - DoGetBestSize().y; | |
249 | } | |
250 | ||
251 | SetBestSize(size); | |
252 | Move(pos); | |
253 | ||
254 | // create the popup window immediately here to allow creating the controls | |
255 | // with parent == GetPopupWindow() from the derived class ctor | |
256 | m_winPopup = new wxPopupComboWindow(this); | |
257 | ||
258 | // have to disable this window to avoid interfering it with message | |
259 | // processing to the text and the button... but pretend it is enabled to | |
260 | // make IsEnabled() return TRUE | |
261 | wxControl::Enable(FALSE); // don't use non virtual Disable() here! | |
262 | m_isEnabled = TRUE; | |
263 | ||
264 | CreateInputHandler(wxINP_HANDLER_COMBOBOX); | |
265 | ||
266 | return TRUE; | |
267 | } | |
268 | ||
269 | wxComboControl::~wxComboControl() | |
270 | { | |
271 | // as the button and the text control are the parent's children and not | |
272 | // ours, we have to delete them manually - they are not deleted | |
273 | // automatically by wxWindows when we're deleted | |
274 | delete m_btn; | |
275 | delete m_text; | |
276 | ||
277 | delete m_winPopup; | |
278 | } | |
279 | ||
280 | // ---------------------------------------------------------------------------- | |
281 | // geometry stuff | |
282 | // ---------------------------------------------------------------------------- | |
283 | ||
284 | void wxComboControl::DoSetSize(int x, int y, | |
285 | int width, int height, | |
286 | int sizeFlags) | |
287 | { | |
288 | // combo height is always fixed | |
289 | wxControl::DoSetSize(x, y, width, DoGetBestSize().y, sizeFlags); | |
290 | } | |
291 | ||
292 | wxSize wxComboControl::DoGetBestClientSize() const | |
293 | { | |
294 | wxSize sizeBtn = m_btn->GetBestSize(), | |
295 | sizeText = m_text->GetBestSize(); | |
296 | ||
297 | return wxSize(sizeBtn.x + sizeText.x, wxMax(sizeBtn.y, sizeText.y)); | |
298 | } | |
299 | ||
300 | void wxComboControl::DoMoveWindow(int x, int y, int width, int height) | |
301 | { | |
302 | wxControl::DoMoveWindow(x, y, width, height); | |
303 | ||
304 | // position the subcontrols inside the client area | |
305 | wxRect rectBorders = GetRenderer()->GetBorderDimensions(GetBorder()); | |
306 | x += rectBorders.x; | |
307 | y += rectBorders.y; | |
308 | width -= rectBorders.x + rectBorders.width; | |
309 | height -= rectBorders.y + rectBorders.height; | |
310 | ||
311 | wxSize sizeBtn = m_btn->GetBestSize(); | |
312 | ||
313 | wxCoord wText = width - sizeBtn.x; | |
314 | wxPoint p = GetParent() ? GetParent()->GetClientAreaOrigin() : wxPoint(0,0); | |
315 | m_text->SetSize(x - p.x, y - p.y, wText, height); | |
316 | m_btn->SetSize(x - p.x + wText, y - p.y, sizeBtn.x, height); | |
317 | } | |
318 | ||
319 | // ---------------------------------------------------------------------------- | |
320 | // operations | |
321 | // ---------------------------------------------------------------------------- | |
322 | ||
323 | bool wxComboControl::Enable(bool enable) | |
324 | { | |
325 | if ( !wxControl::Enable(enable) ) | |
326 | return FALSE; | |
327 | ||
328 | m_btn->Enable(enable); | |
329 | m_text->Enable(enable); | |
330 | ||
331 | return TRUE; | |
332 | } | |
333 | ||
334 | bool wxComboControl::Show(bool show) | |
335 | { | |
336 | if ( !wxControl::Show(show) ) | |
337 | return FALSE; | |
338 | ||
339 | if (m_btn) | |
340 | m_btn->Show(show); | |
341 | ||
342 | if (m_text) | |
343 | m_text->Show(show); | |
344 | ||
345 | return TRUE; | |
346 | } | |
347 | ||
348 | // ---------------------------------------------------------------------------- | |
349 | // popup window handling | |
350 | // ---------------------------------------------------------------------------- | |
351 | ||
352 | void wxComboControl::SetPopupControl(wxComboPopup *popup) | |
353 | { | |
354 | m_popup = popup; | |
355 | } | |
356 | ||
357 | void wxComboControl::ShowPopup() | |
358 | { | |
359 | wxCHECK_RET( m_popup, _T("no popup to show in wxComboControl") ); | |
360 | wxCHECK_RET( !IsPopupShown(), _T("popup window already shown") ); | |
361 | ||
362 | wxControl *control = m_popup->GetControl(); | |
363 | ||
364 | // size and position the popup window correctly | |
365 | m_winPopup->SetSize(GetSize().x, | |
366 | m_heightPopup == -1 ? control->GetBestSize().y | |
367 | : m_heightPopup); | |
368 | wxSize sizePopup = m_winPopup->GetClientSize(); | |
369 | control->SetSize(0, 0, sizePopup.x, sizePopup.y); | |
370 | ||
371 | // some controls don't accept the size we give then: e.g. a listbox may | |
372 | // require more space to show its last row | |
373 | wxSize sizeReal = control->GetSize(); | |
374 | if ( sizeReal != sizePopup ) | |
375 | { | |
376 | m_winPopup->SetClientSize(sizeReal); | |
377 | } | |
378 | ||
379 | m_winPopup->PositionNearCombo(); | |
380 | ||
381 | // show it | |
382 | m_popup->OnShow(); | |
383 | m_winPopup->Popup(m_text); | |
384 | m_text->SelectAll(); | |
385 | m_popup->SetSelection(m_text->GetValue()); | |
386 | ||
387 | m_isPopupShown = TRUE; | |
388 | } | |
389 | ||
390 | void wxComboControl::HidePopup() | |
391 | { | |
392 | wxCHECK_RET( m_popup, _T("no popup to hide in wxComboControl") ); | |
393 | wxCHECK_RET( IsPopupShown(), _T("popup window not shown") ); | |
394 | ||
395 | m_winPopup->Dismiss(); | |
396 | ||
397 | m_isPopupShown = FALSE; | |
398 | } | |
399 | ||
400 | void wxComboControl::OnSelect(const wxString& value) | |
401 | { | |
402 | m_text->SetValue(value); | |
403 | m_text->SelectAll(); | |
404 | ||
405 | OnDismiss(); | |
406 | } | |
407 | ||
408 | void wxComboControl::OnDismiss() | |
409 | { | |
410 | HidePopup(); | |
411 | m_text->SetFocus(); | |
412 | } | |
413 | ||
414 | // ---------------------------------------------------------------------------- | |
415 | // wxComboTextCtrl | |
416 | // ---------------------------------------------------------------------------- | |
417 | ||
418 | wxComboTextCtrl::wxComboTextCtrl(wxComboControl *combo, | |
419 | const wxString& value, | |
420 | long style, | |
421 | const wxValidator& validator) | |
422 | : wxTextCtrl(combo->GetParent(), -1, value, | |
423 | wxDefaultPosition, wxDefaultSize, | |
424 | wxBORDER_NONE | style, | |
425 | validator) | |
426 | { | |
427 | m_combo = combo; | |
428 | } | |
429 | ||
430 | void wxComboTextCtrl::OnText(wxCommandEvent& event) | |
431 | { | |
432 | if ( m_combo->IsPopupShown() ) | |
433 | { | |
434 | m_combo->GetPopupControl()->SetSelection(GetValue()); | |
435 | } | |
436 | ||
437 | // we need to make a copy of the event to have the correct originating | |
438 | // object and id | |
439 | wxCommandEvent event2 = event; | |
440 | event2.SetEventObject(m_combo); | |
441 | event2.SetId(m_combo->GetId()); | |
442 | ||
443 | // there is a small incompatibility with wxMSW here: the combobox gets the | |
444 | // event before the text control in our case which corresponds to SMW | |
445 | // CBN_EDITUPDATE notification and not CBN_EDITCHANGE one wxMSW currently | |
446 | // uses | |
447 | // | |
448 | // if this is really a problem, we can play games with the event handlers | |
449 | // to circumvent this | |
450 | (void)m_combo->ProcessEvent(event2); | |
451 | ||
452 | event.Skip(); | |
453 | } | |
454 | ||
455 | // pass the keys we don't process to the combo first | |
456 | void wxComboTextCtrl::OnKey(wxKeyEvent& event) | |
457 | { | |
458 | switch ( event.GetKeyCode() ) | |
459 | { | |
460 | case WXK_RETURN: | |
461 | // the popup control gets it first but only if it is shown | |
462 | if ( !m_combo->IsPopupShown() ) | |
463 | break; | |
464 | //else: fall through | |
465 | ||
466 | case WXK_UP: | |
467 | case WXK_DOWN: | |
468 | case WXK_ESCAPE: | |
469 | case WXK_PAGEDOWN: | |
470 | case WXK_PAGEUP: | |
471 | case WXK_PRIOR: | |
472 | case WXK_NEXT: | |
473 | (void)m_combo->ProcessEvent(event); | |
474 | return; | |
475 | } | |
476 | ||
477 | event.Skip(); | |
478 | } | |
479 | ||
480 | // ---------------------------------------------------------------------------- | |
481 | // wxComboListBox | |
482 | // ---------------------------------------------------------------------------- | |
483 | ||
484 | wxComboListBox::wxComboListBox(wxComboControl *combo, int style) | |
485 | : wxListBox(combo->GetPopupWindow(), -1, | |
486 | wxDefaultPosition, wxDefaultSize, | |
487 | 0, NULL, | |
488 | wxBORDER_SIMPLE | wxLB_INT_HEIGHT | style), | |
489 | wxComboPopup(combo) | |
490 | { | |
491 | // we don't react to the mouse events outside the window at all | |
492 | StopAutoScrolling(); | |
493 | } | |
494 | ||
495 | wxComboListBox::~wxComboListBox() | |
496 | { | |
497 | } | |
498 | ||
499 | bool wxComboListBox::SetSelection(const wxString& value) | |
500 | { | |
501 | // FindItem() would just find the current item for an empty string (it | |
502 | // always matches), but we want to show the first one in such case | |
503 | if ( value.empty() ) | |
504 | { | |
505 | if ( GetCount() ) | |
506 | { | |
507 | wxListBox::SetSelection(0); | |
508 | } | |
509 | //else: empty listbox - nothing to do | |
510 | } | |
511 | else if ( !FindItem(value) ) | |
512 | { | |
513 | // no match att all | |
514 | return FALSE; | |
515 | } | |
516 | ||
517 | return TRUE; | |
518 | } | |
519 | ||
520 | void wxComboListBox::OnSelect(wxCommandEvent& event) | |
521 | { | |
522 | if ( m_clicked ) | |
523 | { | |
524 | // first update the combo and close the listbox | |
525 | m_combo->OnSelect(event.GetString()); | |
526 | ||
527 | // next let the user code have the event | |
528 | ||
529 | // all fields are already filled by the listbox, just change the event | |
530 | // type and send it to the combo | |
531 | wxCommandEvent event2 = event; | |
532 | event2.SetEventType(wxEVT_COMMAND_COMBOBOX_SELECTED); | |
533 | event2.SetEventObject(m_combo); | |
534 | event2.SetId(m_combo->GetId()); | |
535 | m_combo->ProcessEvent(event2); | |
536 | } | |
537 | //else: ignore the events resultign from just moving the mouse initially | |
538 | } | |
539 | ||
540 | void wxComboListBox::OnShow() | |
541 | { | |
542 | // nobody clicked us yet | |
543 | m_clicked = FALSE; | |
544 | } | |
545 | ||
546 | bool wxComboListBox::PerformAction(const wxControlAction& action, | |
547 | long numArg, | |
548 | const wxString& strArg) | |
549 | ||
550 | { | |
551 | if ( action == wxACTION_LISTBOX_FIND ) | |
552 | { | |
553 | // we don't let the listbox handle this as instead of just using the | |
554 | // single key presses, as usual, we use the text ctrl value as prefix | |
555 | // and this is done by wxComboControl itself | |
556 | return TRUE; | |
557 | } | |
558 | ||
559 | return wxListBox::PerformAction(action, numArg, strArg); | |
560 | } | |
561 | ||
562 | void wxComboListBox::OnLeftUp(wxMouseEvent& event) | |
563 | { | |
564 | // we should dismiss the combo now | |
565 | m_clicked = TRUE; | |
566 | ||
567 | event.Skip(); | |
568 | } | |
569 | ||
570 | void wxComboListBox::OnMouseMove(wxMouseEvent& event) | |
571 | { | |
572 | // while a wxComboListBox is shown, it always has capture, so if it doesn't | |
573 | // we're about to go away anyhow (normally this shouldn't happen at all, | |
574 | // but I don't put assert here as it just might do on other platforms and | |
575 | // it doesn't break anythign anyhow) | |
576 | if ( this == wxWindow::GetCapture() ) | |
577 | { | |
578 | if ( HitTest(event.GetPosition()) == wxHT_WINDOW_INSIDE ) | |
579 | { | |
580 | event.Skip(); | |
581 | } | |
582 | //else: popup shouldn't react to the mouse motions outside it, it only | |
583 | // captures the mouse to be able to detect when it must be | |
584 | // dismissed, so don't call Skip() | |
585 | } | |
586 | } | |
587 | ||
588 | wxSize wxComboListBox::DoGetBestClientSize() const | |
589 | { | |
590 | // don't return size too big or we risk to not fit on the screen | |
591 | wxSize size = wxListBox::DoGetBestClientSize(); | |
592 | wxCoord hChar = GetCharHeight(); | |
593 | ||
594 | int nLines = size.y / hChar; | |
595 | ||
596 | // 10 is the same limit as used by wxMSW | |
597 | if ( nLines > 10 ) | |
598 | { | |
599 | size.y = 10*hChar; | |
600 | } | |
601 | ||
602 | return size; | |
603 | } | |
604 | ||
605 | // ---------------------------------------------------------------------------- | |
606 | // wxComboBox | |
607 | // ---------------------------------------------------------------------------- | |
608 | ||
609 | void wxComboBox::Init() | |
610 | { | |
611 | m_lbox = (wxListBox *)NULL; | |
612 | } | |
613 | ||
614 | bool wxComboBox::Create(wxWindow *parent, | |
615 | wxWindowID id, | |
616 | const wxString& value, | |
617 | const wxPoint& pos, | |
618 | const wxSize& size, | |
619 | int n, | |
620 | const wxString *choices, | |
621 | long style, | |
622 | const wxValidator& validator, | |
623 | const wxString& name) | |
624 | { | |
625 | if ( !wxComboControl::Create(parent, id, value, pos, size, style, | |
626 | validator, name) ) | |
627 | { | |
628 | return FALSE; | |
629 | } | |
630 | ||
631 | wxComboListBox *combolbox = | |
632 | new wxComboListBox(this, style & wxCB_SORT ? wxLB_SORT : 0); | |
633 | m_lbox = combolbox; | |
634 | m_lbox->Set(n, choices); | |
635 | ||
636 | SetPopupControl(combolbox); | |
637 | ||
638 | return TRUE; | |
639 | } | |
640 | ||
641 | wxComboBox::~wxComboBox() | |
642 | { | |
643 | } | |
644 | ||
645 | // ---------------------------------------------------------------------------- | |
646 | // wxComboBox methods forwarded to wxTextCtrl | |
647 | // ---------------------------------------------------------------------------- | |
648 | ||
649 | wxString wxComboBox::GetValue() const | |
650 | { | |
651 | return GetText()->GetValue(); | |
652 | } | |
653 | ||
654 | void wxComboBox::SetValue(const wxString& value) | |
655 | { | |
656 | GetText()->SetValue(value); | |
657 | } | |
658 | ||
659 | void wxComboBox::Copy() | |
660 | { | |
661 | GetText()->Copy(); | |
662 | } | |
663 | ||
664 | void wxComboBox::Cut() | |
665 | { | |
666 | GetText()->Cut(); | |
667 | } | |
668 | ||
669 | void wxComboBox::Paste() | |
670 | { | |
671 | GetText()->Paste(); | |
672 | } | |
673 | ||
674 | void wxComboBox::SetInsertionPoint(long pos) | |
675 | { | |
676 | GetText()->SetInsertionPoint(pos); | |
677 | } | |
678 | ||
679 | void wxComboBox::SetInsertionPointEnd() | |
680 | { | |
681 | GetText()->SetInsertionPointEnd(); | |
682 | } | |
683 | ||
684 | long wxComboBox::GetInsertionPoint() const | |
685 | { | |
686 | return GetText()->GetInsertionPoint(); | |
687 | } | |
688 | ||
689 | long wxComboBox::GetLastPosition() const | |
690 | { | |
691 | return GetText()->GetLastPosition(); | |
692 | } | |
693 | ||
694 | void wxComboBox::Replace(long from, long to, const wxString& value) | |
695 | { | |
696 | GetText()->Replace(from, to, value); | |
697 | } | |
698 | ||
699 | void wxComboBox::Remove(long from, long to) | |
700 | { | |
701 | GetText()->Remove(from, to); | |
702 | } | |
703 | ||
704 | void wxComboBox::SetSelection(long from, long to) | |
705 | { | |
706 | GetText()->SetSelection(from, to); | |
707 | } | |
708 | ||
709 | void wxComboBox::SetEditable(bool editable) | |
710 | { | |
711 | GetText()->SetEditable(editable); | |
712 | } | |
713 | ||
714 | // ---------------------------------------------------------------------------- | |
715 | // wxComboBox methods forwarded to wxListBox | |
716 | // ---------------------------------------------------------------------------- | |
717 | ||
718 | void wxComboBox::Clear() | |
719 | { | |
720 | GetLBox()->Clear(); | |
721 | } | |
722 | ||
723 | void wxComboBox::Delete(int n) | |
724 | { | |
725 | GetLBox()->Delete(n); | |
726 | } | |
727 | ||
728 | int wxComboBox::GetCount() const | |
729 | { | |
730 | return GetLBox()->GetCount(); | |
731 | } | |
732 | ||
733 | wxString wxComboBox::GetString(int n) const | |
734 | { | |
735 | return GetLBox()->GetString(n); | |
736 | } | |
737 | ||
738 | void wxComboBox::SetString(int n, const wxString& s) | |
739 | { | |
740 | GetLBox()->SetString(n, s); | |
741 | } | |
742 | ||
743 | int wxComboBox::FindString(const wxString& s) const | |
744 | { | |
745 | return GetLBox()->FindString(s); | |
746 | } | |
747 | ||
748 | void wxComboBox::Select(int n) | |
749 | { | |
750 | wxCHECK_RET( (n >= 0) && (n < GetCount()), _T("invalid combobox index") ); | |
751 | ||
752 | GetLBox()->SetSelection(n); | |
753 | GetText()->SetValue(GetLBox()->GetString(n)); | |
754 | } | |
755 | ||
756 | int wxComboBox::GetSelection() const | |
757 | { | |
758 | // if the current value isn't one of the listbox strings, return -1 | |
759 | return FindString(GetText()->GetValue()); | |
760 | } | |
761 | ||
762 | int wxComboBox::DoAppend(const wxString& item) | |
763 | { | |
764 | return GetLBox()->Append(item); | |
765 | } | |
766 | ||
767 | void wxComboBox::DoSetItemClientData(int n, void* clientData) | |
768 | { | |
769 | GetLBox()->SetClientData(n, clientData); | |
770 | } | |
771 | ||
772 | void *wxComboBox::DoGetItemClientData(int n) const | |
773 | { | |
774 | return GetLBox()->GetClientData(n); | |
775 | } | |
776 | ||
777 | void wxComboBox::DoSetItemClientObject(int n, wxClientData* clientData) | |
778 | { | |
779 | GetLBox()->SetClientObject(n, clientData); | |
780 | } | |
781 | ||
782 | wxClientData* wxComboBox::DoGetItemClientObject(int n) const | |
783 | { | |
784 | return GetLBox()->GetClientObject(n); | |
785 | } | |
786 | ||
787 | // ---------------------------------------------------------------------------- | |
788 | // input handling | |
789 | // ---------------------------------------------------------------------------- | |
790 | ||
791 | void wxComboControl::OnKey(wxKeyEvent& event) | |
792 | { | |
793 | if ( m_isPopupShown ) | |
794 | { | |
795 | // pass it to the popped up control | |
796 | (void)m_popup->GetControl()->ProcessEvent(event); | |
797 | } | |
798 | else // no popup | |
799 | { | |
800 | event.Skip(); | |
801 | } | |
802 | } | |
803 | ||
804 | bool wxComboControl::PerformAction(const wxControlAction& action, | |
805 | long numArg, | |
806 | const wxString& strArg) | |
807 | { | |
808 | bool processed = FALSE; | |
809 | if ( action == wxACTION_COMBOBOX_POPUP ) | |
810 | { | |
811 | if ( !m_isPopupShown ) | |
812 | { | |
813 | ShowPopup(); | |
814 | ||
815 | processed = TRUE; | |
816 | } | |
817 | } | |
818 | else if ( action == wxACTION_COMBOBOX_DISMISS ) | |
819 | { | |
820 | if ( m_isPopupShown ) | |
821 | { | |
822 | HidePopup(); | |
823 | ||
824 | processed = TRUE; | |
825 | } | |
826 | } | |
827 | ||
828 | if ( !processed ) | |
829 | { | |
830 | // pass along | |
831 | return wxControl::PerformAction(action, numArg, strArg); | |
832 | } | |
833 | ||
834 | return TRUE; | |
835 | } | |
836 | ||
837 | // ---------------------------------------------------------------------------- | |
838 | // wxStdComboBoxInputHandler | |
839 | // ---------------------------------------------------------------------------- | |
840 | ||
841 | wxStdComboBoxInputHandler::wxStdComboBoxInputHandler(wxInputHandler *inphand) | |
842 | : wxStdInputHandler(inphand) | |
843 | { | |
844 | } | |
845 | ||
846 | bool wxStdComboBoxInputHandler::HandleKey(wxInputConsumer *consumer, | |
847 | const wxKeyEvent& event, | |
848 | bool pressed) | |
849 | { | |
850 | if ( pressed ) | |
851 | { | |
852 | wxControlAction action; | |
853 | switch ( event.GetKeyCode() ) | |
854 | { | |
855 | case WXK_DOWN: | |
856 | action = wxACTION_COMBOBOX_POPUP; | |
857 | break; | |
858 | ||
859 | case WXK_ESCAPE: | |
860 | action = wxACTION_COMBOBOX_DISMISS; | |
861 | break; | |
862 | } | |
863 | ||
864 | if ( !!action ) | |
865 | { | |
866 | consumer->PerformAction(action); | |
867 | ||
868 | return TRUE; | |
869 | } | |
870 | } | |
871 | ||
872 | return wxStdInputHandler::HandleKey(consumer, event, pressed); | |
873 | } | |
874 | ||
875 | #endif // wxUSE_COMBOBOX |