]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/combobox.cpp
projects / wxWidgets.git / blob
? search:


b1bed06a0136f122202a7945b68fd5bab34e3f40
[wxWidgets.git] / src / gtk / combobox.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/combobox.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #if wxUSE_COMBOBOX
14
15 #include "wx/combobox.h"
16
17 #ifndef WX_PRECOMP
18 #include "wx/intl.h"
19 #include "wx/settings.h"
20 #include "wx/textctrl.h" // for wxEVT_COMMAND_TEXT_UPDATED
21 #include "wx/arrstr.h"
22 #endif
23
24 // We use GtkCombo which has been deprecated since GTK+ 2.3.0
25 // in favour of GtkComboBox for <GTK2.4 runtime
26 // We also use GtkList
27 #ifdef GTK_DISABLE_DEPRECATED
28 #undef GTK_DISABLE_DEPRECATED
29 #endif
30 #include "wx/gtk/private.h"
31
32 //-----------------------------------------------------------------------------
33 // data
34 //-----------------------------------------------------------------------------
35
36 extern bool g_blockEventsOnDrag;
37 static int g_SelectionBeforePopup = wxID_NONE; // this means the popup is hidden
38
39 //-----------------------------------------------------------------------------
40 // "changed" - typing and list item matches get changed, select-child
41 // if it doesn't match an item then just get a single changed
42 //-----------------------------------------------------------------------------
43
44 extern "C" {
45 static void
46 gtkcombo_text_changed_callback( GtkWidget *WXUNUSED(widget), wxComboBox *combo )
47 {
48 if (combo->m_ignoreNextUpdate)
49 {
50 combo->m_ignoreNextUpdate = false;
51 return;
52 }
53
54 if (!combo->m_hasVMT) return;
55
56 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
57 event.SetString( combo->GetValue() );
58 event.SetEventObject( combo );
59 combo->GetEventHandler()->ProcessEvent( event );
60 }
61 }
62
63 extern "C" {
64 static void
65 gtkcombo_dummy_callback(GtkEntry *WXUNUSED(entry), GtkCombo *WXUNUSED(combo))
66 {
67 }
68 }
69
70 extern "C" {
71 static void
72 gtkcombo_popup_hide_callback(GtkCombo *WXUNUSED(gtk_combo), wxComboBox *combo)
73 {
74 // when the popup is hidden, throw a SELECTED event only if the combobox
75 // selection changed.
76 const int curSelection = combo->GetCurrentSelection();
77
78 const bool hasChanged = curSelection != g_SelectionBeforePopup;
79
80 // reset the selection flag to value meaning that it is hidden and do it
81 // now, before generating the events, so that GetSelection() returns the
82 // new value from the event handler
83 g_SelectionBeforePopup = wxID_NONE;
84
85 if ( hasChanged )
86 {
87 wxCommandEvent event( wxEVT_COMMAND_COMBOBOX_SELECTED, combo->GetId() );
88 event.SetInt( curSelection );
89 event.SetString( combo->GetStringSelection() );
90 event.SetEventObject( combo );
91 combo->GetEventHandler()->ProcessEvent( event );
92
93 // for consistency with the other ports, send TEXT event
94 wxCommandEvent event2( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
95 event2.SetString( combo->GetStringSelection() );
96 event2.SetEventObject( combo );
97 combo->GetEventHandler()->ProcessEvent( event2 );
98 }
99 }
100 }
101
102 extern "C" {
103 static void
104 gtkcombo_popup_show_callback(GtkCombo *WXUNUSED(gtk_combo), wxComboBox *combo)
105 {
106 // store the combobox selection value before the popup is shown
107 g_SelectionBeforePopup = combo->GetCurrentSelection();
108 }
109 }
110
111 //-----------------------------------------------------------------------------
112 // "select-child" - click/cursor get select-child, changed, select-child
113 //-----------------------------------------------------------------------------
114
115 extern "C" {
116 static void
117 gtkcombo_combo_select_child_callback( GtkList *WXUNUSED(list), GtkWidget *WXUNUSED(widget), wxComboBox *combo )
118 {
119 if (!combo->m_hasVMT) return;
120
121 if (g_blockEventsOnDrag) return;
122
123 int curSelection = combo->GetCurrentSelection();
124
125 if (combo->m_prevSelection == curSelection) return;
126
127 GtkWidget *list = GTK_COMBO(combo->m_widget)->list;
128 gtk_list_unselect_item( GTK_LIST(list), combo->m_prevSelection );
129
130 combo->m_prevSelection = curSelection;
131
132 // Quickly set the value of the combo box
133 // as GTK+ does that only AFTER the event
134 // is sent.
135 g_signal_handlers_disconnect_by_func (GTK_COMBO (combo->GetHandle())->entry,
136 (gpointer) gtkcombo_text_changed_callback,
137 combo);
138 combo->SetValue( combo->GetStringSelection() );
139 g_signal_connect_after (GTK_COMBO (combo->GetHandle())->entry, "changed",
140 G_CALLBACK (gtkcombo_text_changed_callback), combo);
141
142 // throw a SELECTED event only if the combobox popup is hidden (wxID_NONE)
143 // because when combobox popup is shown, gtkcombo_combo_select_child_callback is
144 // called each times the mouse is over an item with a pressed button so a lot
145 // of SELECTED event could be generated if the user keep the mouse button down
146 // and select other items ...
147 if (g_SelectionBeforePopup == wxID_NONE)
148 {
149 wxCommandEvent event( wxEVT_COMMAND_COMBOBOX_SELECTED, combo->GetId() );
150 event.SetInt( curSelection );
151 event.SetString( combo->GetStringSelection() );
152 event.SetEventObject( combo );
153 combo->GetEventHandler()->ProcessEvent( event );
154
155 // for consistency with the other ports, don't generate text update
156 // events while the user is browsing the combobox neither
157 wxCommandEvent event2( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
158 event2.SetString( combo->GetValue() );
159 event2.SetEventObject( combo );
160 combo->GetEventHandler()->ProcessEvent( event2 );
161 }
162 }
163 }
164
165 #ifdef __WXGTK24__
166 extern "C" {
167 static void
168 gtkcombobox_text_changed_callback( GtkWidget *WXUNUSED(widget), wxComboBox *combo )
169 {
170 if (!combo->m_hasVMT) return;
171
172 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
173 event.SetString( combo->GetValue() );
174 event.SetEventObject( combo );
175 combo->GetEventHandler()->ProcessEvent( event );
176 }
177 }
178
179 extern "C" {
180 static void
181 gtkcombobox_changed_callback( GtkWidget *WXUNUSED(widget), wxComboBox *combo )
182 {
183 if (!combo->m_hasVMT) return;
184
185 if (combo->GetSelection() == -1)
186 return;
187
188 wxCommandEvent event( wxEVT_COMMAND_COMBOBOX_SELECTED, combo->GetId() );
189 event.SetInt( combo->GetSelection() );
190 event.SetString( combo->GetStringSelection() );
191 event.SetEventObject( combo );
192 combo->GetEventHandler()->ProcessEvent( event );
193 }
194 }
195
196 #endif
197
198 //-----------------------------------------------------------------------------
199 // wxComboBox
200 //-----------------------------------------------------------------------------
201
202 IMPLEMENT_DYNAMIC_CLASS(wxComboBox,wxControl)
203
204 BEGIN_EVENT_TABLE(wxComboBox, wxControl)
205 EVT_SIZE(wxComboBox::OnSize)
206 EVT_CHAR(wxComboBox::OnChar)
207
208 EVT_MENU(wxID_CUT, wxComboBox::OnCut)
209 EVT_MENU(wxID_COPY, wxComboBox::OnCopy)
210 EVT_MENU(wxID_PASTE, wxComboBox::OnPaste)
211 EVT_MENU(wxID_UNDO, wxComboBox::OnUndo)
212 EVT_MENU(wxID_REDO, wxComboBox::OnRedo)
213 EVT_MENU(wxID_CLEAR, wxComboBox::OnDelete)
214 EVT_MENU(wxID_SELECTALL, wxComboBox::OnSelectAll)
215
216 EVT_UPDATE_UI(wxID_CUT, wxComboBox::OnUpdateCut)
217 EVT_UPDATE_UI(wxID_COPY, wxComboBox::OnUpdateCopy)
218 EVT_UPDATE_UI(wxID_PASTE, wxComboBox::OnUpdatePaste)
219 EVT_UPDATE_UI(wxID_UNDO, wxComboBox::OnUpdateUndo)
220 EVT_UPDATE_UI(wxID_REDO, wxComboBox::OnUpdateRedo)
221 EVT_UPDATE_UI(wxID_CLEAR, wxComboBox::OnUpdateDelete)
222 EVT_UPDATE_UI(wxID_SELECTALL, wxComboBox::OnUpdateSelectAll)
223 END_EVENT_TABLE()
224
225 bool wxComboBox::Create( wxWindow *parent, wxWindowID id,
226 const wxString& value,
227 const wxPoint& pos, const wxSize& size,
228 const wxArrayString& choices,
229 long style, const wxValidator& validator,
230 const wxString& name )
231 {
232 wxCArrayString chs(choices);
233
234 return Create( parent, id, value, pos, size, chs.GetCount(),
235 chs.GetStrings(), style, validator, name );
236 }
237
238 bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
239 const wxPoint& pos, const wxSize& size,
240 int n, const wxString choices[],
241 long style, const wxValidator& validator,
242 const wxString& name )
243 {
244 m_ignoreNextUpdate = false;
245 m_prevSelection = 0;
246
247 if (!PreCreation( parent, pos, size ) ||
248 !CreateBase( parent, id, pos, size, style, validator, name ))
249 {
250 wxFAIL_MSG( wxT("wxComboBox creation failed") );
251 return false;
252 }
253
254 #ifdef __WXGTK24__
255 if (!gtk_check_version(2,4,0))
256 {
257 m_widget = gtk_combo_box_entry_new_text();
258 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
259
260 gtk_entry_set_editable( GTK_ENTRY( GTK_BIN(m_widget)->child ), TRUE );
261
262 for (int i = 0; i < n; i++)
263 {
264 gtk_combo_box_append_text( combobox, wxGTK_CONV( choices[i] ) );
265
266 m_clientDataList.Append( (wxObject*)NULL );
267 m_clientObjectList.Append( (wxObject*)NULL );
268 }
269 }
270 else
271 #endif
272 {
273 m_widget = gtk_combo_new();
274 GtkCombo* combo = GTK_COMBO(m_widget);
275
276 // Disable GTK's broken events ...
277 g_signal_handler_disconnect (combo->entry, combo->entry_change_id);
278 // ... and add surrogate handler.
279 combo->entry_change_id = g_signal_connect (combo->entry, "changed",
280 G_CALLBACK (gtkcombo_dummy_callback),
281 combo);
282
283 // make it more useable
284 gtk_combo_set_use_arrows_always( GTK_COMBO(m_widget), TRUE );
285
286 // and case-sensitive
287 gtk_combo_set_case_sensitive( GTK_COMBO(m_widget), TRUE );
288
289 if (style & wxNO_BORDER)
290 g_object_set (combo->entry, "has-frame", FALSE, NULL );
291
292 GtkWidget *list = combo->list;
293
294 for (int i = 0; i < n; i++)
295 {
296 GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( choices[i] ) );
297
298 m_clientDataList.Append( (wxObject*)NULL );
299 m_clientObjectList.Append( (wxObject*)NULL );
300
301 gtk_container_add( GTK_CONTAINER(list), list_item );
302
303 gtk_widget_show( list_item );
304 }
305 }
306
307
308 m_parent->DoAddChild( this );
309
310 GtkEntry *entry = NULL;
311 #ifdef __WXGTK24__
312 if (!gtk_check_version(2,4,0))
313 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
314 else
315 #endif
316 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
317
318 m_focusWidget = GTK_WIDGET( entry );
319
320 PostCreation(size);
321
322 #ifdef __WXGTK24__
323 if (!gtk_check_version(2,4,0))
324 ConnectWidget( m_widget );
325 else
326 #endif
327 ConnectWidget( GTK_COMBO(m_widget)->button );
328
329 #ifdef __WXGTK24__
330 if (!gtk_check_version(2,4,0))
331 {
332 gtk_entry_set_text( entry, wxGTK_CONV(value) );
333
334 if (style & wxCB_READONLY)
335 gtk_entry_set_editable( entry, FALSE );
336
337 g_signal_connect_after (entry, "changed",
338 G_CALLBACK (gtkcombobox_text_changed_callback), this);
339
340 g_signal_connect_after (m_widget, "changed",
341 G_CALLBACK (gtkcombobox_changed_callback), this);
342
343 }
344 else
345 #endif
346 {
347 GtkCombo *combo = GTK_COMBO(m_widget);
348 // MSW's combo box shows the value and the selection is -1
349 gtk_entry_set_text( entry, wxGTK_CONV(value) );
350 gtk_list_unselect_all( GTK_LIST(combo->list) );
351
352 if (style & wxCB_READONLY)
353 gtk_entry_set_editable( entry, FALSE );
354
355 // "show" and "hide" events are generated when user click on the combobox button which popups a list
356 // this list is the "popwin" gtk widget
357 g_signal_connect (GTK_COMBO(combo)->popwin, "hide",
358 G_CALLBACK (gtkcombo_popup_hide_callback), this);
359 g_signal_connect (GTK_COMBO(combo)->popwin, "show",
360 G_CALLBACK (gtkcombo_popup_show_callback), this);
361 g_signal_connect_after (combo->list, "select-child",
362 G_CALLBACK (gtkcombo_combo_select_child_callback),
363 this);
364 g_signal_connect_after (entry, "changed",
365 G_CALLBACK (gtkcombo_text_changed_callback), this);
366 }
367
368 SetInitialSize(size); // need this too because this is a wxControlWithItems
369
370 return true;
371 }
372
373 wxComboBox::~wxComboBox()
374 {
375 wxList::compatibility_iterator node = m_clientObjectList.GetFirst();
376 while (node)
377 {
378 wxClientData *cd = (wxClientData*)node->GetData();
379 if (cd) delete cd;
380 node = node->GetNext();
381 }
382 m_clientObjectList.Clear();
383
384 m_clientDataList.Clear();
385 }
386
387 void wxComboBox::SetFocus()
388 {
389 if ( m_hasFocus )
390 {
391 // don't do anything if we already have focus
392 return;
393 }
394
395 gtk_widget_grab_focus( m_focusWidget );
396 }
397
398 int wxComboBox::DoAppend( const wxString &item )
399 {
400 wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid combobox") );
401
402 #ifdef __WXGTK24__
403 if (!gtk_check_version(2,4,0))
404 {
405 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
406 gtk_combo_box_append_text( combobox, wxGTK_CONV( item ) );
407 }
408 else
409 #endif
410 {
411 DisableEvents();
412
413 GtkWidget *list = GTK_COMBO(m_widget)->list;
414 GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( item ) );
415
416 gtk_container_add( GTK_CONTAINER(list), list_item );
417
418 if (GTK_WIDGET_REALIZED(m_widget))
419 {
420 gtk_widget_realize( list_item );
421 gtk_widget_realize( GTK_BIN(list_item)->child );
422 }
423
424 // Apply current widget style to the new list_item
425 GtkRcStyle *style = CreateWidgetStyle();
426 if (style)
427 {
428 gtk_widget_modify_style(list_item, style);
429 GtkBin *bin = GTK_BIN( list_item );
430 GtkWidget *label = bin->child;
431 gtk_widget_modify_style( label, style );
432 gtk_rc_style_unref( style );
433 }
434
435 gtk_widget_show( list_item );
436
437 EnableEvents();
438 }
439
440 const unsigned int count = GetCount();
441
442 if ( m_clientDataList.GetCount() < count )
443 m_clientDataList.Append( (wxObject*) NULL );
444 if ( m_clientObjectList.GetCount() < count )
445 m_clientObjectList.Append( (wxObject*) NULL );
446
447 InvalidateBestSize();
448
449 return count - 1;
450 }
451
452 int wxComboBox::DoInsert(const wxString &item, unsigned int pos)
453 {
454 wxCHECK_MSG( !(GetWindowStyle() & wxCB_SORT), -1,
455 wxT("can't insert into sorted list"));
456
457 wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid combobox") );
458 wxCHECK_MSG( IsValidInsert(pos), -1, wxT("invalid index") );
459
460 unsigned int count = GetCount();
461
462 if (pos == count)
463 return Append(item);
464
465 #ifdef __WXGTK24__
466 if (!gtk_check_version(2,4,0))
467 {
468 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
469 gtk_combo_box_insert_text( combobox, pos, wxGTK_CONV( item ) );
470 }
471 else
472 #endif
473 {
474 DisableEvents();
475
476 GtkWidget *list = GTK_COMBO(m_widget)->list;
477 GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( item ) );
478
479 GList *gitem_list = g_list_alloc ();
480 gitem_list->data = list_item;
481 gtk_list_insert_items( GTK_LIST (list), gitem_list, pos );
482
483 if (GTK_WIDGET_REALIZED(m_widget))
484 {
485 gtk_widget_realize( list_item );
486 gtk_widget_realize( GTK_BIN(list_item)->child );
487
488 ApplyWidgetStyle();
489 }
490
491 gtk_widget_show( list_item );
492
493 EnableEvents();
494 }
495
496 count = GetCount();
497
498 if ( m_clientDataList.GetCount() < count )
499 m_clientDataList.Insert( pos, (wxObject*) NULL );
500 if ( m_clientObjectList.GetCount() < count )
501 m_clientObjectList.Insert( pos, (wxObject*) NULL );
502
503 InvalidateBestSize();
504
505 return pos;
506 }
507
508 void wxComboBox::DoSetItemClientData(unsigned int n, void* clientData)
509 {
510 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
511
512 wxList::compatibility_iterator node = m_clientDataList.Item( n );
513 if (!node) return;
514
515 node->SetData( (wxObject*) clientData );
516 }
517
518 void* wxComboBox::DoGetItemClientData(unsigned int n) const
519 {
520 wxCHECK_MSG( m_widget != NULL, NULL, wxT("invalid combobox") );
521
522 wxList::compatibility_iterator node = m_clientDataList.Item( n );
523
524 return node ? node->GetData() : NULL;
525 }
526
527 void wxComboBox::DoSetItemClientObject(unsigned int n, wxClientData* clientData)
528 {
529 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
530
531 wxList::compatibility_iterator node = m_clientObjectList.Item( n );
532 if (!node) return;
533
534 // wxItemContainer already deletes data for us
535
536 node->SetData( (wxObject*) clientData );
537 }
538
539 wxClientData* wxComboBox::DoGetItemClientObject(unsigned int n) const
540 {
541 wxCHECK_MSG( m_widget != NULL, (wxClientData*)NULL, wxT("invalid combobox") );
542
543 wxList::compatibility_iterator node = m_clientObjectList.Item( n );
544
545 return node ? (wxClientData*) node->GetData() : NULL;
546 }
547
548 void wxComboBox::Clear()
549 {
550 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
551
552 DisableEvents();
553
554 #ifdef __WXGTK24__
555 if (!gtk_check_version(2,4,0))
556 {
557 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
558 const unsigned int count = GetCount();
559 for (unsigned int i = 0; i < count; i++)
560 gtk_combo_box_remove_text( combobox, 0 );
561 }
562 else // GTK+ < 2.4.0
563 #endif // __WXGTK24__
564 {
565 GtkWidget *list = GTK_COMBO(m_widget)->list;
566 gtk_list_clear_items( GTK_LIST(list), 0, GetCount() );
567 }
568
569 wxList::compatibility_iterator node = m_clientObjectList.GetFirst();
570 while (node)
571 {
572 wxClientData *cd = (wxClientData*)node->GetData();
573 delete cd;
574 node = node->GetNext();
575 }
576 m_clientObjectList.Clear();
577
578 m_clientDataList.Clear();
579
580 EnableEvents();
581
582 InvalidateBestSize();
583 }
584
585 void wxComboBox::Delete(unsigned int n)
586 {
587 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
588
589 #ifdef __WXGTK24__
590 if (!gtk_check_version(2,4,0))
591 {
592 wxCHECK_RET( IsValid(n), wxT("invalid index") );
593
594 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
595 gtk_combo_box_remove_text( combobox, n );
596 }
597 else
598 #endif
599 {
600 GtkList *listbox = GTK_LIST( GTK_COMBO(m_widget)->list );
601
602 GList *child = g_list_nth( listbox->children, n );
603
604 if (!child)
605 {
606 wxFAIL_MSG(wxT("wrong index"));
607 return;
608 }
609
610 DisableEvents();
611
612 GList *list = g_list_append( (GList*) NULL, child->data );
613 gtk_list_remove_items( listbox, list );
614 g_list_free( list );
615
616 EnableEvents();
617 }
618
619 wxList::compatibility_iterator node = m_clientObjectList.Item( n );
620 if (node)
621 {
622 wxClientData *cd = (wxClientData*)node->GetData();
623 if (cd) delete cd;
624 m_clientObjectList.Erase( node );
625 }
626
627 node = m_clientDataList.Item( n );
628 if (node)
629 m_clientDataList.Erase( node );
630
631 InvalidateBestSize();
632 }
633
634 void wxComboBox::SetString(unsigned int n, const wxString &text)
635 {
636 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
637
638 #ifdef __WXGTK24__
639 if (!gtk_check_version(2,4,0))
640 {
641 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
642 wxCHECK_RET( IsValid(n), wxT("invalid index") );
643
644 GtkTreeModel *model = gtk_combo_box_get_model( combobox );
645 GtkTreeIter iter;
646 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
647 {
648 GValue value = { 0, };
649 g_value_init( &value, G_TYPE_STRING );
650 g_value_set_string( &value, wxGTK_CONV( text ) );
651 gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, 0, &value );
652 g_value_unset( &value );
653 }
654 }
655 else
656 #endif
657 {
658 GtkWidget *list = GTK_COMBO(m_widget)->list;
659
660 GList *child = g_list_nth( GTK_LIST(list)->children, n );
661 if (child)
662 {
663 GtkBin *bin = GTK_BIN( child->data );
664 GtkLabel *label = GTK_LABEL( bin->child );
665 gtk_label_set_text(label, wxGTK_CONV(text));
666 }
667 else
668 {
669 wxFAIL_MSG( wxT("wxComboBox: wrong index") );
670 }
671 }
672
673 InvalidateBestSize();
674 }
675
676 int wxComboBox::FindString( const wxString &item, bool bCase ) const
677 {
678 wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid combobox") );
679
680 #ifdef __WXGTK24__
681 if (!gtk_check_version(2,4,0))
682 {
683 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
684 GtkTreeModel* model = gtk_combo_box_get_model( combobox );
685 GtkTreeIter iter;
686 gtk_tree_model_get_iter_first( model, &iter );
687 if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter ))
688 return -1;
689 int count = 0;
690 do
691 {
692 GValue value = { 0, };
693 gtk_tree_model_get_value( model, &iter, 0, &value );
694 wxString str = wxGTK_CONV_BACK( g_value_get_string( &value ) );
695 g_value_unset( &value );
696
697 if (item.IsSameAs( str, bCase ) )
698 return count;
699
700 count++;
701
702 } while (gtk_tree_model_iter_next( model, &iter ));
703 }
704 else
705 #endif
706 {
707 GtkWidget *list = GTK_COMBO(m_widget)->list;
708
709 GList *child = GTK_LIST(list)->children;
710 int count = 0;
711 while (child)
712 {
713 GtkBin *bin = GTK_BIN( child->data );
714 GtkLabel *label = GTK_LABEL( bin->child );
715 wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) );
716
717 if (item.IsSameAs( str , bCase ) )
718 return count;
719
720 count++;
721 child = child->next;
722 }
723 }
724
725 return wxNOT_FOUND;
726 }
727
728 int wxComboBox::GetSelection() const
729 {
730 #ifdef __WXGTK24__
731 if (!gtk_check_version(2,4,0))
732 {
733 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
734 return gtk_combo_box_get_active( combobox );
735 }
736 else
737 #endif
738 // if the popup is currently opened, use the selection as it had been
739 // before it dropped down
740 return g_SelectionBeforePopup == wxID_NONE ? GetCurrentSelection()
741 : g_SelectionBeforePopup;
742 }
743
744 int wxComboBox::GetCurrentSelection() const
745 {
746 wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid combobox") );
747
748 #ifdef __WXGTK24__
749 if (!gtk_check_version(2,4,0))
750 {
751 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
752 return gtk_combo_box_get_active( combobox );
753 }
754 else
755 #endif
756 {
757 GtkWidget *list = GTK_COMBO(m_widget)->list;
758
759 GList *selection = GTK_LIST(list)->selection;
760 if (selection)
761 {
762 GList *child = GTK_LIST(list)->children;
763 int count = 0;
764 while (child)
765 {
766 if (child->data == selection->data) return count;
767 count++;
768 child = child->next;
769 }
770 }
771 }
772
773 return -1;
774 }
775
776 wxString wxComboBox::GetString(unsigned int n) const
777 {
778 wxCHECK_MSG( m_widget != NULL, wxEmptyString, wxT("invalid combobox") );
779
780 wxString str;
781
782 #ifdef __WXGTK24__
783 if (!gtk_check_version(2,4,0))
784 {
785 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
786 GtkTreeModel *model = gtk_combo_box_get_model( combobox );
787 GtkTreeIter iter;
788 if (gtk_tree_model_iter_nth_child (model, &iter, NULL, n))
789 {
790 GValue value = { 0, };
791 gtk_tree_model_get_value( model, &iter, 0, &value );
792 wxString tmp = wxGTK_CONV_BACK( g_value_get_string( &value ) );
793 g_value_unset( &value );
794 return tmp;
795 }
796 }
797 else
798 #endif
799 {
800 GtkWidget *list = GTK_COMBO(m_widget)->list;
801
802 GList *child = g_list_nth( GTK_LIST(list)->children, n );
803 if (child)
804 {
805 GtkBin *bin = GTK_BIN( child->data );
806 GtkLabel *label = GTK_LABEL( bin->child );
807 str = wxGTK_CONV_BACK( gtk_label_get_text(label) );
808 }
809 else
810 {
811 wxFAIL_MSG( wxT("wxComboBox: wrong index") );
812 }
813 }
814
815 return str;
816 }
817
818 wxString wxComboBox::GetStringSelection() const
819 {
820 wxCHECK_MSG( m_widget != NULL, wxEmptyString, wxT("invalid combobox") );
821
822 #ifdef __WXGTK24__
823 if (!gtk_check_version(2,4,0))
824 {
825 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
826 int sel = gtk_combo_box_get_active( combobox );
827 if (sel == -1)
828 return wxEmptyString;
829 return GetString(sel);
830 }
831 else
832 #endif
833 {
834 GtkWidget *list = GTK_COMBO(m_widget)->list;
835
836 GList *selection = GTK_LIST(list)->selection;
837 if (selection)
838 {
839 GtkBin *bin = GTK_BIN( selection->data );
840 GtkLabel *label = GTK_LABEL( bin->child );
841 wxString tmp( wxGTK_CONV_BACK( gtk_label_get_text(label) ) );
842 return tmp;
843 }
844
845 wxFAIL_MSG( wxT("wxComboBox: no selection") );
846 }
847
848 return wxEmptyString;
849 }
850
851 unsigned int wxComboBox::GetCount() const
852 {
853 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid combobox") );
854
855 #ifdef __WXGTK24__
856 if (!gtk_check_version(2,4,0))
857 {
858 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
859 GtkTreeModel* model = gtk_combo_box_get_model( combobox );
860 GtkTreeIter iter;
861 gtk_tree_model_get_iter_first( model, &iter );
862 if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter ))
863 return 0;
864 unsigned int ret = 1;
865 while (gtk_tree_model_iter_next( model, &iter ))
866 ret++;
867 return ret;
868 }
869 else
870 #endif
871 {
872 GtkWidget *list = GTK_COMBO(m_widget)->list;
873
874 GList *child = GTK_LIST(list)->children;
875 unsigned int count = 0;
876 while (child)
877 {
878 count++;
879 child = child->next;
880 }
881 return count;
882 }
883
884 return 0;
885 }
886
887 void wxComboBox::SetSelection( int n )
888 {
889 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
890
891 DisableEvents();
892
893 #ifdef __WXGTK24__
894 if (!gtk_check_version(2,4,0))
895 {
896 GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
897 gtk_combo_box_set_active( combobox, n );
898 }
899 else
900 #endif
901 {
902 GtkWidget *list = GTK_COMBO(m_widget)->list;
903 gtk_list_unselect_item( GTK_LIST(list), m_prevSelection );
904 gtk_list_select_item( GTK_LIST(list), n );
905 m_prevSelection = n;
906 }
907
908 EnableEvents();
909 }
910
911 wxString wxComboBox::GetValue() const
912 {
913 GtkEntry *entry = NULL;
914 #ifdef __WXGTK24__
915 if (!gtk_check_version(2,4,0))
916 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
917 else
918 #endif
919 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
920
921 wxString tmp( wxGTK_CONV_BACK( gtk_entry_get_text( entry ) ) );
922
923 #if 0
924 for (int i = 0; i < wxStrlen(tmp.c_str()) +1; i++)
925 {
926 wxChar c = tmp[i];
927 printf( "%d ", (int) (c) );
928 }
929 printf( "\n" );
930 #endif
931
932 return tmp;
933 }
934
935 void wxComboBox::SetValue( const wxString& value )
936 {
937 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
938
939 GtkEntry *entry = NULL;
940 #ifdef __WXGTK24__
941 if (!gtk_check_version(2,4,0))
942 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
943 else
944 #endif
945 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
946
947 wxString tmp;
948 if (!value.IsNull()) tmp = value;
949
950 DisableEvents();
951 gtk_entry_set_text( entry, wxGTK_CONV( tmp ) );
952 EnableEvents();
953
954 InvalidateBestSize();
955 }
956
957 void wxComboBox::Copy()
958 {
959 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
960
961 GtkEntry *entry = NULL;
962 #ifdef __WXGTK24__
963 if (!gtk_check_version(2,4,0))
964 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
965 else
966 #endif
967 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
968
969 gtk_editable_copy_clipboard(GTK_EDITABLE(entry));
970 }
971
972 void wxComboBox::Cut()
973 {
974 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
975
976 GtkEntry *entry = NULL;
977 #ifdef __WXGTK24__
978 if (!gtk_check_version(2,4,0))
979 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
980 else
981 #endif
982 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
983
984 gtk_editable_cut_clipboard(GTK_EDITABLE(entry));
985 }
986
987 void wxComboBox::Paste()
988 {
989 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
990
991 GtkEntry *entry = NULL;
992 #ifdef __WXGTK24__
993 if (!gtk_check_version(2,4,0))
994 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
995 else
996 #endif
997 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
998
999 gtk_editable_paste_clipboard(GTK_EDITABLE(entry));
1000 }
1001
1002 void wxComboBox::Undo()
1003 {
1004 // TODO
1005 }
1006
1007 void wxComboBox::Redo()
1008 {
1009 // TODO
1010 }
1011
1012 void wxComboBox::SelectAll()
1013 {
1014 SetSelection(0, GetLastPosition());
1015 }
1016
1017 bool wxComboBox::CanUndo() const
1018 {
1019 // TODO
1020 return false;
1021 }
1022
1023 bool wxComboBox::CanRedo() const
1024 {
1025 // TODO
1026 return false;
1027 }
1028
1029 bool wxComboBox::HasSelection() const
1030 {
1031 long from, to;
1032 GetSelection(&from, &to);
1033 return from != to;
1034 }
1035
1036 bool wxComboBox::CanCopy() const
1037 {
1038 // Can copy if there's a selection
1039 return HasSelection();
1040 }
1041
1042 bool wxComboBox::CanCut() const
1043 {
1044 return CanCopy() && IsEditable();
1045 }
1046
1047 bool wxComboBox::CanPaste() const
1048 {
1049 // TODO: check for text on the clipboard
1050 return IsEditable() ;
1051 }
1052
1053 bool wxComboBox::IsEditable() const
1054 {
1055 return !HasFlag(wxCB_READONLY);
1056 }
1057
1058
1059 void wxComboBox::SetInsertionPoint( long pos )
1060 {
1061 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
1062
1063 if ( pos == GetLastPosition() )
1064 pos = -1;
1065
1066 GtkEntry *entry = NULL;
1067 #ifdef __WXGTK24__
1068 if (!gtk_check_version(2,4,0))
1069 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
1070 else
1071 #endif
1072 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
1073
1074 gtk_entry_set_position( entry, (int)pos );
1075 }
1076
1077 long wxComboBox::GetInsertionPoint() const
1078 {
1079 GtkEntry *entry = NULL;
1080 #ifdef __WXGTK24__
1081 if (!gtk_check_version(2,4,0))
1082 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
1083 else
1084 #endif
1085 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
1086
1087 return (long) gtk_editable_get_position(GTK_EDITABLE(entry));
1088 }
1089
1090 wxTextPos wxComboBox::GetLastPosition() const
1091 {
1092 GtkEntry *entry = NULL;
1093 #ifdef __WXGTK24__
1094 if (!gtk_check_version(2,4,0))
1095 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
1096 else
1097 #endif
1098 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
1099
1100 int pos = entry->text_length;
1101 return (long) pos-1;
1102 }
1103
1104 void wxComboBox::Replace( long from, long to, const wxString& value )
1105 {
1106 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
1107
1108 GtkEntry *entry = NULL;
1109 #ifdef __WXGTK24__
1110 if (!gtk_check_version(2,4,0))
1111 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
1112 else
1113 #endif
1114 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
1115
1116 gtk_editable_delete_text( GTK_EDITABLE(entry), (gint)from, (gint)to );
1117 if (value.IsNull()) return;
1118 gint pos = (gint)to;
1119
1120 // FIXME-UTF8: wouldn't be needed if utf8_str() always returned a buffer
1121 #if wxUSE_UNICODE_UTF8
1122 const char *utf8 = value.utf8_str();
1123 #else
1124 wxCharBuffer buffer(value.utf8_str());
1125 const char *utf8 = buffer;
1126 #endif
1127 gtk_editable_insert_text(GTK_EDITABLE(entry), utf8, strlen(utf8), &pos);
1128 }
1129
1130 void wxComboBox::SetSelection( long from, long to )
1131 {
1132 GtkEntry *entry = NULL;
1133 #ifdef __WXGTK24__
1134 if (!gtk_check_version(2,4,0))
1135 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
1136 else
1137 #endif
1138 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
1139
1140 gtk_editable_select_region( GTK_EDITABLE(entry), (gint)from, (gint)to );
1141 }
1142
1143 void wxComboBox::GetSelection( long* from, long* to ) const
1144 {
1145 GtkEntry *entry = NULL;
1146 #ifdef __WXGTK24__
1147 if (!gtk_check_version(2,4,0))
1148 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
1149 else
1150 #endif
1151 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
1152
1153 if (IsEditable())
1154 {
1155 GtkEditable *editable = GTK_EDITABLE(entry);
1156 gint start, end;
1157 gtk_editable_get_selection_bounds(editable, & start, & end);
1158 *from = start;
1159 *to = end;
1160 }
1161 }
1162
1163 void wxComboBox::SetEditable( bool editable )
1164 {
1165 GtkEntry *entry = NULL;
1166 #ifdef __WXGTK24__
1167 if (!gtk_check_version(2,4,0))
1168 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
1169 else
1170 #endif
1171 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
1172
1173 gtk_entry_set_editable( GTK_ENTRY(entry), editable );
1174 }
1175
1176 void wxComboBox::OnChar( wxKeyEvent &event )
1177 {
1178 if ( event.GetKeyCode() == WXK_RETURN )
1179 {
1180 // GTK automatically selects an item if its in the list
1181 wxCommandEvent eventEnter(wxEVT_COMMAND_TEXT_ENTER, GetId());
1182 eventEnter.SetString( GetValue() );
1183 eventEnter.SetInt( GetSelection() );
1184 eventEnter.SetEventObject( this );
1185
1186 if (!GetEventHandler()->ProcessEvent( eventEnter ))
1187 {
1188 // This will invoke the dialog default action, such
1189 // as the clicking the default button.
1190
1191 wxWindow *top_frame = m_parent;
1192 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1193 top_frame = top_frame->GetParent();
1194
1195 if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1196 {
1197 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1198
1199 if (window->default_widget)
1200 gtk_widget_activate (window->default_widget);
1201 }
1202 }
1203
1204 // Catch GTK event so that GTK doesn't open the drop
1205 // down list upon RETURN.
1206 return;
1207 }
1208
1209 event.Skip();
1210 }
1211
1212 void wxComboBox::DisableEvents()
1213 {
1214 #ifdef __WXGTK24__
1215 if (!gtk_check_version(2,4,0))
1216 {
1217 g_signal_handlers_disconnect_by_func (GTK_BIN(m_widget)->child,
1218 (gpointer)gtkcombobox_text_changed_callback, this);
1219
1220 g_signal_handlers_disconnect_by_func (m_widget,
1221 (gpointer)gtkcombobox_changed_callback, this);
1222 }
1223 else
1224 #endif
1225 {
1226 g_signal_handlers_disconnect_by_func (GTK_COMBO(m_widget)->list,
1227 (gpointer) gtkcombo_combo_select_child_callback, this);
1228
1229 g_signal_handlers_disconnect_by_func (GTK_COMBO(m_widget)->entry,
1230 (gpointer) gtkcombo_text_changed_callback, this);
1231 }
1232 }
1233
1234 void wxComboBox::EnableEvents()
1235 {
1236 #ifdef __WXGTK24__
1237 if (!gtk_check_version(2,4,0))
1238 {
1239 g_signal_connect_after (GTK_BIN(m_widget)->child, "changed",
1240 G_CALLBACK (gtkcombobox_text_changed_callback), this);
1241
1242 g_signal_connect_after (m_widget, "changed",
1243 G_CALLBACK (gtkcombobox_changed_callback), this);
1244 }
1245 else
1246 #endif
1247 {
1248 g_signal_connect_after (GTK_COMBO(m_widget)->list, "select-child",
1249 G_CALLBACK (gtkcombo_combo_select_child_callback),
1250 this);
1251 g_signal_connect_after (GTK_COMBO(m_widget)->entry, "changed",
1252 G_CALLBACK (gtkcombo_text_changed_callback),
1253 this );
1254 }
1255 }
1256
1257 void wxComboBox::OnSize( wxSizeEvent &event )
1258 {
1259 #ifdef __WXGTK24__
1260 if (!gtk_check_version(2,4,0))
1261 {
1262 // Do nothing
1263 }
1264 else
1265 #endif
1266 {
1267 // NB: In some situations (e.g. on non-first page of a wizard, if the
1268 // size used is default size), GtkCombo widget is resized correctly,
1269 // but it's look is not updated, it's rendered as if it was much wider.
1270 // No other widgets are affected, so it looks like a bug in GTK+.
1271 // Manually requesting resize calculation (as gtk_pizza_set_size does)
1272 // fixes it.
1273 if (GTK_WIDGET_VISIBLE(m_widget))
1274 gtk_widget_queue_resize(m_widget);
1275 }
1276
1277 event.Skip();
1278 }
1279
1280 void wxComboBox::DoApplyWidgetStyle(GtkRcStyle *style)
1281 {
1282 #ifdef __WXGTK24__
1283 if (!gtk_check_version(2,4,0))
1284 {
1285 // Do nothing
1286 }
1287 else
1288 #endif
1289 {
1290 // gtk_widget_modify_style( GTK_COMBO(m_widget)->button, syle );
1291
1292 gtk_widget_modify_style( GTK_COMBO(m_widget)->entry, style );
1293 gtk_widget_modify_style( GTK_COMBO(m_widget)->list, style );
1294
1295 GtkList *list = GTK_LIST( GTK_COMBO(m_widget)->list );
1296 GList *child = list->children;
1297 while (child)
1298 {
1299 gtk_widget_modify_style( GTK_WIDGET(child->data), style );
1300
1301 GtkBin *bin = GTK_BIN(child->data);
1302 gtk_widget_modify_style( bin->child, style );
1303
1304 child = child->next;
1305 }
1306 }
1307 }
1308
1309 GtkWidget* wxComboBox::GetConnectWidget()
1310 {
1311 GtkEntry *entry = NULL;
1312 #ifdef __WXGTK24__
1313 if (!gtk_check_version(2,4,0))
1314 entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
1315 else
1316 #endif
1317 entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
1318
1319 return GTK_WIDGET( entry );
1320 }
1321
1322 GdkWindow *wxComboBox::GTKGetWindow(wxArrayGdkWindows& windows) const
1323 {
1324 #ifdef __WXGTK24__
1325 if (!gtk_check_version(2,4,0))
1326 {
1327 wxUnusedVar(windows);
1328
1329 return GTK_ENTRY(GTK_BIN(m_widget)->child)->text_area;
1330 }
1331 else
1332 #endif // GTK+ 2.4
1333 {
1334 windows.push_back(GTK_ENTRY(GTK_COMBO(m_widget)->entry)->text_area);
1335 windows.push_back(GTK_COMBO(m_widget)->button->window);
1336
1337 // indicate that we return multiple windows in the windows array
1338 return NULL;
1339 }
1340 }
1341
1342 wxSize wxComboBox::DoGetBestSize() const
1343 {
1344 wxSize ret( wxControl::DoGetBestSize() );
1345
1346 // we know better our horizontal extent: it depends on the longest string
1347 // in the combobox
1348 if ( m_widget )
1349 {
1350 int width;
1351 unsigned int count = GetCount();
1352 for ( unsigned int n = 0; n < count; n++ )
1353 {
1354 GetTextExtent(GetString(n), &width, NULL, NULL, NULL );
1355 if ( width > ret.x )
1356 ret.x = width;
1357 }
1358 }
1359
1360 // empty combobox should have some reasonable default size too
1361 if ( ret.x < 100 )
1362 ret.x = 100;
1363
1364 CacheBestSize(ret);
1365 return ret;
1366 }
1367
1368 // static
1369 wxVisualAttributes
1370 wxComboBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1371 {
1372 #ifdef __WXGTK24__
1373 if (!gtk_check_version(2,4,0))
1374 return GetDefaultAttributesFromGTKWidget(gtk_combo_box_entry_new, true);
1375 else
1376 #endif
1377 return GetDefaultAttributesFromGTKWidget(gtk_combo_new, true);
1378 }
1379
1380 // ----------------------------------------------------------------------------
1381 // standard event handling
1382 // ----------------------------------------------------------------------------
1383
1384 void wxComboBox::OnCut(wxCommandEvent& WXUNUSED(event))
1385 {
1386 Cut();
1387 }
1388
1389 void wxComboBox::OnCopy(wxCommandEvent& WXUNUSED(event))
1390 {
1391 Copy();
1392 }
1393
1394 void wxComboBox::OnPaste(wxCommandEvent& WXUNUSED(event))
1395 {
1396 Paste();
1397 }
1398
1399 void wxComboBox::OnUndo(wxCommandEvent& WXUNUSED(event))
1400 {
1401 Undo();
1402 }
1403
1404 void wxComboBox::OnRedo(wxCommandEvent& WXUNUSED(event))
1405 {
1406 Redo();
1407 }
1408
1409 void wxComboBox::OnDelete(wxCommandEvent& WXUNUSED(event))
1410 {
1411 long from, to;
1412 GetSelection(& from, & to);
1413 if (from != -1 && to != -1)
1414 Remove(from, to);
1415 }
1416
1417 void wxComboBox::OnSelectAll(wxCommandEvent& WXUNUSED(event))
1418 {
1419 SetSelection(-1, -1);
1420 }
1421
1422 void wxComboBox::OnUpdateCut(wxUpdateUIEvent& event)
1423 {
1424 event.Enable( CanCut() );
1425 }
1426
1427 void wxComboBox::OnUpdateCopy(wxUpdateUIEvent& event)
1428 {
1429 event.Enable( CanCopy() );
1430 }
1431
1432 void wxComboBox::OnUpdatePaste(wxUpdateUIEvent& event)
1433 {
1434 event.Enable( CanPaste() );
1435 }
1436
1437 void wxComboBox::OnUpdateUndo(wxUpdateUIEvent& event)
1438 {
1439 event.Enable( CanUndo() );
1440 }
1441
1442 void wxComboBox::OnUpdateRedo(wxUpdateUIEvent& event)
1443 {
1444 event.Enable( CanRedo() );
1445 }
1446
1447 void wxComboBox::OnUpdateDelete(wxUpdateUIEvent& event)
1448 {
1449 event.Enable(HasSelection() && IsEditable()) ;
1450 }
1451
1452 void wxComboBox::OnUpdateSelectAll(wxUpdateUIEvent& event)
1453 {
1454 event.Enable(GetLastPosition() > 0);
1455 }
1456
1457 #endif
wxWidgets (Impactor)