src/gtk/combobox.cpp

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