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