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