src/gtk1/listbox.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk1/listbox.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_LISTBOX
  14
  15 #include "wx/listbox.h"
  16
  17 #ifndef WX_PRECOMP
  18     #include "wx/dynarray.h"
  19     #include "wx/intl.h"
  20     #include "wx/utils.h"
  21     #include "wx/settings.h"
  22     #include "wx/checklst.h"
  23     #include "wx/arrstr.h"
  24 #endif
  25
  26 #include "wx/gtk1/private.h"
  27
  28 #if wxUSE_TOOLTIPS
  29     #include "wx/tooltip.h"
  30 #endif
  31
  32 #include <gdk/gdk.h>
  33 #include <gtk/gtk.h>
  34 #include <gdk/gdkkeysyms.h>
  35
  36 //-----------------------------------------------------------------------------
  37 // idle system
  38 //-----------------------------------------------------------------------------
  39
  40 extern void wxapp_install_idle_handler();
  41 extern bool g_isIdle;
  42
  43 //-----------------------------------------------------------------------------
  44 // data
  45 //-----------------------------------------------------------------------------
  46
  47 extern bool           g_blockEventsOnDrag;
  48 extern bool           g_blockEventsOnScroll;
  49 extern wxCursor       g_globalCursor;
  50 extern wxWindowGTK   *g_delayedFocus;
  51 extern wxWindowGTK   *g_focusWindow;
  52 extern wxWindowGTK   *g_focusWindowLast;
  53
  54 static bool       g_hasDoubleClicked = false;
  55
  56 //-----------------------------------------------------------------------------
  57 // idle callback for SetFirstItem
  58 //-----------------------------------------------------------------------------
  59
  60 struct wxlistbox_idle_struct
  61 {
  62     wxListBox   *m_listbox;
  63     int          m_item;
  64     gint         m_tag;
  65 };
  66
  67 extern "C" {
  68 static gint wxlistbox_idle_callback( gpointer gdata )
  69 {
  70     wxlistbox_idle_struct* data = (wxlistbox_idle_struct*) gdata;
  71     gdk_threads_enter();
  72
  73     gtk_idle_remove( data->m_tag );
  74
  75     // check that the items haven't been deleted from the listbox since we had
  76     // installed this callback
  77     wxListBox *lbox = data->m_listbox;
  78     if ( data->m_item < (int)lbox->GetCount() )
  79     {
  80         lbox->SetFirstItem( data->m_item );
  81     }
  82
  83     delete data;
  84
  85     gdk_threads_leave();
  86
  87     return TRUE;
  88 }
  89 }
  90
  91 //-----------------------------------------------------------------------------
  92 // "focus_in_event"
  93 //-----------------------------------------------------------------------------
  94
  95 extern "C" {
  96 static gint gtk_listitem_focus_in_callback( GtkWidget *widget,
  97                                           GdkEvent *WXUNUSED(event),
  98                                           wxWindow *win )
  99 {
 100     if (g_isIdle)
 101         wxapp_install_idle_handler();
 102
 103     g_focusWindowLast =
 104     g_focusWindow = win;
 105
 106     // does the window itself think that it has the focus?
 107     if ( !win->m_hasFocus )
 108     {
 109         // not yet, notify it
 110         win->m_hasFocus = true;
 111
 112         wxChildFocusEvent eventChildFocus(win);
 113         (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
 114
 115         wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
 116         eventFocus.SetEventObject(win);
 117
 118         (void)win->GetEventHandler()->ProcessEvent(eventFocus);
 119     }
 120
 121     return FALSE;
 122 }
 123 }
 124
 125 //-----------------------------------------------------------------------------
 126 // "focus_out_event"
 127 //-----------------------------------------------------------------------------
 128
 129 extern "C" {
 130 static gint gtk_listitem_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
 131 {
 132     if (g_isIdle)
 133         wxapp_install_idle_handler();
 134
 135     g_focusWindow = (wxWindowGTK *)NULL;
 136
 137     // don't send the window a kill focus event if it thinks that it doesn't
 138     // have focus already
 139     if ( win->m_hasFocus )
 140     {
 141         win->m_hasFocus = false;
 142
 143         wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
 144         event.SetEventObject( win );
 145
 146         // even if we did process the event in wx code, still let GTK itself
 147         // process it too as otherwise bad things happen, especially in GTK2
 148         // where the text control simply aborts the program if it doesn't get
 149         // the matching focus out event
 150         (void)win->GetEventHandler()->ProcessEvent( event );
 151     }
 152
 153     return FALSE;
 154 }
 155 }
 156
 157 //-----------------------------------------------------------------------------
 158 // "button_release_event"
 159 //-----------------------------------------------------------------------------
 160
 161 /* we would normally emit a wxEVT_COMMAND_LISTBOX_DOUBLECLICKED event once
 162    a GDK_2BUTTON_PRESS occurs, but this has the particular problem of the
 163    listbox keeping the focus until it receives a GDK_BUTTON_RELEASE event.
 164    this can lead to race conditions so that we emit the dclick event
 165    after the GDK_BUTTON_RELEASE event after the GDK_2BUTTON_PRESS event */
 166
 167 extern "C" {
 168 static gint
 169 gtk_listbox_button_release_callback( GtkWidget * WXUNUSED(widget),
 170                                      GdkEventButton * WXUNUSED(gdk_event),
 171                                      wxListBox *listbox )
 172 {
 173     if (g_isIdle) wxapp_install_idle_handler();
 174
 175     if (g_blockEventsOnDrag) return FALSE;
 176     if (g_blockEventsOnScroll) return FALSE;
 177
 178     if (!listbox->m_hasVMT) return FALSE;
 179
 180     if (!g_hasDoubleClicked) return FALSE;
 181
 182     wxCommandEvent event( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, listbox->GetId() );
 183     event.SetEventObject( listbox );
 184
 185     wxArrayInt aSelections;
 186     int n, count = listbox->GetSelections(aSelections);
 187     if ( count > 0 )
 188     {
 189         n = aSelections[0];
 190         if ( listbox->HasClientObjectData() )
 191             event.SetClientObject( listbox->GetClientObject(n) );
 192         else if ( listbox->HasClientUntypedData() )
 193             event.SetClientData( listbox->GetClientData(n) );
 194         event.SetString( listbox->GetString(n) );
 195     }
 196     else
 197     {
 198         n = -1;
 199     }
 200
 201     event.SetInt(n);
 202
 203     listbox->GetEventHandler()->ProcessEvent( event );
 204
 205     return FALSE;
 206 }
 207 }
 208
 209 //-----------------------------------------------------------------------------
 210 // "button_press_event"
 211 //-----------------------------------------------------------------------------
 212
 213 extern "C" {
 214 static gint
 215 gtk_listbox_button_press_callback( GtkWidget *widget,
 216                                    GdkEventButton *gdk_event,
 217                                    wxListBox *listbox )
 218 {
 219     if (g_isIdle) wxapp_install_idle_handler();
 220
 221     if (g_blockEventsOnDrag) return FALSE;
 222     if (g_blockEventsOnScroll) return FALSE;
 223
 224     if (!listbox->m_hasVMT) return FALSE;
 225
 226     int sel = listbox->GtkGetIndex( widget );
 227
 228 #if wxUSE_CHECKLISTBOX
 229     if ((listbox->m_hasCheckBoxes) && (gdk_event->x < 15) && (gdk_event->type != GDK_2BUTTON_PRESS))
 230     {
 231         wxCheckListBox *clb = (wxCheckListBox *)listbox;
 232
 233         clb->Check( sel, !clb->IsChecked(sel) );
 234
 235         wxCommandEvent event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() );
 236         event.SetEventObject( listbox );
 237         event.SetInt( sel );
 238         listbox->GetEventHandler()->ProcessEvent( event );
 239     }
 240 #endif // wxUSE_CHECKLISTBOX
 241
 242     if ((gdk_event->state == 0) &&
 243          (((listbox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0) ||
 244           ((listbox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)) )
 245     {
 246             listbox->m_blockEvent = true;
 247
 248             int i;
 249             for (i = 0; i < (int)listbox->GetCount(); i++)
 250                 if (i != sel)
 251                     gtk_list_unselect_item( GTK_LIST(listbox->m_list), i );
 252
 253             listbox->m_blockEvent = false;
 254
 255             return false;
 256     }
 257
 258     /* emit wxEVT_COMMAND_LISTBOX_DOUBLECLICKED later */
 259     g_hasDoubleClicked = (gdk_event->type == GDK_2BUTTON_PRESS);
 260
 261     return FALSE;
 262 }
 263 }
 264
 265 //-----------------------------------------------------------------------------
 266 // "key_press_event"
 267 //-----------------------------------------------------------------------------
 268
 269 extern "C" {
 270 static gint
 271 gtk_listbox_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxListBox *listbox )
 272 {
 273     if (g_isIdle)
 274         wxapp_install_idle_handler();
 275
 276     if (g_blockEventsOnDrag)
 277         return FALSE;
 278
 279     bool ret = false;
 280
 281     if ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab))
 282     {
 283         wxNavigationKeyEvent new_event;
 284         /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
 285         new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
 286         /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
 287         new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
 288         new_event.SetCurrentFocus( listbox );
 289         ret = listbox->GetEventHandler()->ProcessEvent( new_event );
 290     }
 291
 292     if ((gdk_event->keyval == GDK_Return) && (!ret))
 293     {
 294         // eat return in all modes
 295         ret = true;
 296     }
 297
 298 #if wxUSE_CHECKLISTBOX
 299     if ((gdk_event->keyval == ' ') && (listbox->m_hasCheckBoxes) && (!ret))
 300     {
 301         int sel = listbox->GtkGetIndex( widget );
 302
 303         wxCheckListBox *clb = (wxCheckListBox *)listbox;
 304
 305         clb->Check( sel, !clb->IsChecked(sel) );
 306
 307         wxCommandEvent new_event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() );
 308         new_event.SetEventObject( listbox );
 309         new_event.SetInt( sel );
 310         ret = listbox->GetEventHandler()->ProcessEvent( new_event );
 311     }
 312 #endif // wxUSE_CHECKLISTBOX
 313
 314     // Check or uncheck item with SPACE
 315     if ((gdk_event->keyval == ' ') && (!ret) &&
 316          (((listbox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0) ||
 317           ((listbox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)) )
 318     {
 319         int sel = listbox->GtkGetIndex( widget );
 320
 321         if (sel != -1)
 322         {
 323             ret = true;
 324
 325             if (listbox->IsSelected( sel ))
 326                 gtk_list_unselect_item( listbox->m_list, sel );
 327             else
 328                 gtk_list_select_item( listbox->m_list, sel );
 329
 330             wxCommandEvent new_event(wxEVT_COMMAND_LISTBOX_SELECTED, listbox->GetId() );
 331             new_event.SetEventObject( listbox );
 332             wxArrayInt aSelections;
 333             int n, count = listbox->GetSelections(aSelections);
 334             if ( count > 0 )
 335             {
 336                 n = aSelections[0];
 337                 if ( listbox->HasClientObjectData() )
 338                     new_event.SetClientObject( listbox->GetClientObject(n) );
 339                 else if ( listbox->HasClientUntypedData() )
 340                     new_event.SetClientData( listbox->GetClientData(n) );
 341                 new_event.SetString( listbox->GetString(n) );
 342             }
 343             else
 344             {
 345                 n = -1;
 346             }
 347             new_event.SetInt(n);
 348             listbox->GetEventHandler()->ProcessEvent( new_event );
 349         }
 350     }
 351
 352     if (ret)
 353     {
 354         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
 355         return TRUE;
 356     }
 357
 358     return FALSE;
 359 }
 360 }
 361
 362 //-----------------------------------------------------------------------------
 363 // "select" and "deselect"
 364 //-----------------------------------------------------------------------------
 365
 366 static void gtk_listitem_select_cb( GtkWidget *widget,
 367                                     wxListBox *listbox,
 368                                     bool is_selection )
 369 {
 370     if (g_isIdle) wxapp_install_idle_handler();
 371
 372     if (!listbox->m_hasVMT) return;
 373     if (g_blockEventsOnDrag) return;
 374
 375     if (listbox->m_blockEvent) return;
 376
 377     wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, listbox->GetId() );
 378     event.SetEventObject( listbox );
 379
 380     // indicate whether this is a selection or a deselection
 381     event.SetExtraLong( is_selection );
 382
 383     if ((listbox->GetWindowStyleFlag() & wxLB_SINGLE) != 0)
 384     {
 385         int sel = listbox->GtkGetIndex( widget );
 386
 387         if (listbox->m_prevSelection != sel)
 388             gtk_list_unselect_item( listbox->m_list, listbox->m_prevSelection );
 389
 390         listbox->m_prevSelection = sel;
 391     }
 392
 393     wxArrayInt aSelections;
 394     int n, count = listbox->GetSelections(aSelections);
 395     if ( count > 0 )
 396     {
 397         n = aSelections[0];
 398         if ( listbox->HasClientObjectData() )
 399             event.SetClientObject( listbox->GetClientObject(n) );
 400         else if ( listbox->HasClientUntypedData() )
 401             event.SetClientData( listbox->GetClientData(n) );
 402         event.SetString( listbox->GetString(n) );
 403     }
 404     else
 405     {
 406         n = -1;
 407     }
 408
 409     event.SetInt(n);
 410
 411 //    No longer required with new code in wxLB_SINGLE
 412 //    listbox->GetEventHandler()->AddPendingEvent( event );
 413     listbox->GetEventHandler()->ProcessEvent( event );
 414 }
 415
 416 extern "C" {
 417 static void gtk_listitem_select_callback( GtkWidget *widget, wxListBox *listbox )
 418 {
 419     gtk_listitem_select_cb( widget, listbox, TRUE );
 420 }
 421 }
 422
 423 extern "C" {
 424 static void gtk_listitem_deselect_callback( GtkWidget *widget, wxListBox *listbox )
 425 {
 426     gtk_listitem_select_cb( widget, listbox, FALSE );
 427 }
 428 }
 429
 430 //-----------------------------------------------------------------------------
 431 // wxListBox
 432 //-----------------------------------------------------------------------------
 433
 434 extern "C" {
 435 static gint
 436 gtk_listbox_realized_callback( GtkWidget *m_widget, wxListBox *win )
 437 {
 438     if (g_isIdle)
 439         wxapp_install_idle_handler();
 440
 441     GList *child = win->m_list->children;
 442     for (child = win->m_list->children; child != NULL; child = child->next)
 443         gtk_widget_show( GTK_WIDGET(child->data) );
 444
 445     return false;
 446 }
 447 }
 448
 449 //-----------------------------------------------------------------------------
 450 // wxListBox
 451 //-----------------------------------------------------------------------------
 452
 453 IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControlWithItems)
 454
 455 // ----------------------------------------------------------------------------
 456 // construction
 457 // ----------------------------------------------------------------------------
 458
 459 wxListBox::wxListBox()
 460 {
 461     m_list = (GtkList *) NULL;
 462 #if wxUSE_CHECKLISTBOX
 463     m_hasCheckBoxes = false;
 464 #endif // wxUSE_CHECKLISTBOX
 465 }
 466
 467 bool wxListBox::Create( wxWindow *parent, wxWindowID id,
 468                         const wxPoint &pos, const wxSize &size,
 469                         const wxArrayString& choices,
 470                         long style, const wxValidator& validator,
 471                         const wxString &name )
 472 {
 473     wxCArrayString chs(choices);
 474
 475     return Create( parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
 476                    style, validator, name );
 477 }
 478
 479 bool wxListBox::Create( wxWindow *parent, wxWindowID id,
 480                         const wxPoint &pos, const wxSize &size,
 481                         int n, const wxString choices[],
 482                         long style, const wxValidator& validator,
 483                         const wxString &name )
 484 {
 485     m_needParent = true;
 486     m_acceptsFocus = true;
 487     m_prevSelection = 0;  // or -1 ??
 488     m_blockEvent = false;
 489
 490     if (!PreCreation( parent, pos, size ) ||
 491         !CreateBase( parent, id, pos, size, style, validator, name ))
 492     {
 493         wxFAIL_MSG( wxT("wxListBox creation failed") );
 494         return false;
 495     }
 496
 497     m_widget = gtk_scrolled_window_new( (GtkAdjustment*) NULL, (GtkAdjustment*) NULL );
 498     if (style & wxLB_ALWAYS_SB)
 499     {
 500       gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
 501         GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
 502     }
 503     else
 504     {
 505       gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
 506         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
 507     }
 508
 509     m_list = GTK_LIST( gtk_list_new() );
 510
 511     GtkSelectionMode mode;
 512     if (style & wxLB_MULTIPLE)
 513     {
 514         mode = GTK_SELECTION_MULTIPLE;
 515     }
 516     else if (style & wxLB_EXTENDED)
 517     {
 518         mode = GTK_SELECTION_EXTENDED;
 519     }
 520     else
 521     {
 522         // if style was 0 set single mode
 523         m_windowStyle |= wxLB_SINGLE;
 524         mode = GTK_SELECTION_SINGLE;
 525     }
 526
 527     gtk_list_set_selection_mode( GTK_LIST(m_list), mode );
 528
 529     gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), GTK_WIDGET(m_list) );
 530
 531     /* make list scroll when moving the focus down using cursor keys */
 532     gtk_container_set_focus_vadjustment(
 533         GTK_CONTAINER(m_list),
 534         gtk_scrolled_window_get_vadjustment(
 535             GTK_SCROLLED_WINDOW(m_widget)));
 536
 537     gtk_widget_show( GTK_WIDGET(m_list) );
 538
 539     gtk_signal_connect( GTK_OBJECT(m_list), "realize",
 540                         GTK_SIGNAL_FUNC(gtk_listbox_realized_callback), (gpointer) this );
 541
 542     if ( style & wxLB_SORT )
 543     {
 544         // this will change Append() behaviour
 545         m_strings = new wxSortedArrayString;
 546     }
 547     else
 548     {
 549         m_strings = (wxSortedArrayString *)NULL;
 550     }
 551
 552     Append(n, choices);
 553
 554     m_parent->DoAddChild( this );
 555
 556     PostCreation(size);
 557     SetInitialSize(size); // need this too because this is a wxControlWithItems
 558
 559     return true;
 560 }
 561
 562 wxListBox::~wxListBox()
 563 {
 564     m_hasVMT = false;
 565
 566     Clear();
 567
 568     if (m_strings)
 569       delete m_strings;
 570 }
 571
 572 // ----------------------------------------------------------------------------
 573 // adding items
 574 // ----------------------------------------------------------------------------
 575
 576 int wxListBox::DoInsertItems(const wxArrayStringsAdapter& items,
 577                              unsigned int pos,
 578                              void **clientData,
 579                              wxClientDataType type)
 580 {
 581     wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") );
 582
 583     const unsigned count = GetCount();
 584     wxCHECK_MSG( pos <= count, wxNOT_FOUND,
 585                     wxT("invalid index in wxListBox::InsertItems") );
 586
 587     // code elsewhere supposes we have as many items in m_clientList as items
 588     // in the listbox
 589     wxASSERT_MSG( m_clientList.GetCount() == count,
 590                       wxT("bug in client data management") );
 591
 592     InvalidateBestSize();
 593
 594     const unsigned numItems = items.GetCount();
 595
 596     for ( unsigned int n = 0; n < numItems; ++n, ++pos )
 597     {
 598         const wxString& item = items[n];
 599
 600         const unsigned idx = m_strings ? m_strings->Add(item)
 601                                        : pos;
 602
 603         GtkAddItem(item, idx == GetCount() ? (unsigned) -1 : idx);
 604
 605         m_clientList.Insert(idx, NULL);
 606
 607         AssignNewItemClientData(idx, clientData, n, type);
 608     }
 609
 610     wxASSERT_MSG( m_clientList.GetCount() == GetCount(),
 611                       wxT("bug in client data management") );
 612
 613     return pos - 1;
 614 }
 615
 616 void wxListBox::GtkAddItem( const wxString &item, int pos )
 617 {
 618     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 619
 620     GtkWidget *list_item;
 621
 622     wxString label(item);
 623 #if wxUSE_CHECKLISTBOX
 624     if (m_hasCheckBoxes)
 625     {
 626         label.Prepend(wxCHECKLBOX_STRING);
 627     }
 628 #endif // wxUSE_CHECKLISTBOX
 629
 630     list_item = gtk_list_item_new_with_label( wxGTK_CONV( label ) );
 631
 632     GList *gitem_list = g_list_alloc ();
 633     gitem_list->data = list_item;
 634
 635     if (pos == -1)
 636         gtk_list_append_items( GTK_LIST (m_list), gitem_list );
 637     else
 638         gtk_list_insert_items( GTK_LIST (m_list), gitem_list, pos );
 639
 640     gtk_signal_connect_after( GTK_OBJECT(list_item), "select",
 641       GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
 642
 643     if (HasFlag(wxLB_MULTIPLE) || HasFlag(wxLB_EXTENDED))
 644         gtk_signal_connect_after( GTK_OBJECT(list_item), "deselect",
 645           GTK_SIGNAL_FUNC(gtk_listitem_deselect_callback), (gpointer)this );
 646
 647     gtk_signal_connect( GTK_OBJECT(list_item),
 648                         "button_press_event",
 649                         (GtkSignalFunc)gtk_listbox_button_press_callback,
 650                         (gpointer) this );
 651
 652     gtk_signal_connect_after( GTK_OBJECT(list_item),
 653                         "button_release_event",
 654                         (GtkSignalFunc)gtk_listbox_button_release_callback,
 655                         (gpointer) this );
 656
 657     gtk_signal_connect( GTK_OBJECT(list_item),
 658                            "key_press_event",
 659                            (GtkSignalFunc)gtk_listbox_key_press_callback,
 660                            (gpointer)this );
 661
 662
 663     gtk_signal_connect( GTK_OBJECT(list_item), "focus_in_event",
 664             GTK_SIGNAL_FUNC(gtk_listitem_focus_in_callback), (gpointer)this );
 665
 666     gtk_signal_connect( GTK_OBJECT(list_item), "focus_out_event",
 667             GTK_SIGNAL_FUNC(gtk_listitem_focus_out_callback), (gpointer)this );
 668
 669     ConnectWidget( list_item );
 670
 671     if (GTK_WIDGET_REALIZED(m_widget))
 672     {
 673         gtk_widget_show( list_item );
 674
 675         gtk_widget_realize( list_item );
 676         gtk_widget_realize( GTK_BIN(list_item)->child );
 677
 678 #if wxUSE_TOOLTIPS
 679         if (m_tooltip) m_tooltip->Apply( this );
 680 #endif
 681     }
 682
 683     // Apply current widget style to the new list_item
 684     GtkRcStyle *style = CreateWidgetStyle();
 685     if (style)
 686     {
 687         gtk_widget_modify_style( GTK_WIDGET( list_item ), style );
 688         GtkBin *bin = GTK_BIN( list_item );
 689         gtk_widget_modify_style( GTK_WIDGET( bin->child ), style );
 690         gtk_rc_style_unref( style );
 691     }
 692 }
 693
 694 // ----------------------------------------------------------------------------
 695 // deleting items
 696 // ----------------------------------------------------------------------------
 697
 698 void wxListBox::DoClear()
 699 {
 700     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 701
 702     gtk_list_clear_items( m_list, 0, (int)GetCount() );
 703
 704     if ( GTK_LIST(m_list)->last_focus_child != NULL  )
 705     {
 706         // This should be NULL, I think.
 707         GTK_LIST(m_list)->last_focus_child = NULL;
 708     }
 709
 710     m_clientList.Clear();
 711
 712     if ( m_strings )
 713         m_strings->Clear();
 714 }
 715
 716 void wxListBox::DoDeleteOneItem(unsigned int n)
 717 {
 718     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 719
 720     GList *child = g_list_nth( m_list->children, n );
 721
 722     wxCHECK_RET( child, wxT("wrong listbox index") );
 723
 724     GList *list = g_list_append( (GList*) NULL, child->data );
 725     gtk_list_remove_items( m_list, list );
 726     g_list_free( list );
 727
 728     wxList::compatibility_iterator node = m_clientList.Item( n );
 729     if ( node )
 730     {
 731         m_clientList.Erase( node );
 732     }
 733
 734     if ( m_strings )
 735         m_strings->RemoveAt(n);
 736 }
 737
 738 // ----------------------------------------------------------------------------
 739 // client data
 740 // ----------------------------------------------------------------------------
 741
 742 void wxListBox::DoSetItemClientData(unsigned int n, void* clientData)
 743 {
 744     wxCHECK_RET( m_widget != NULL, wxT("invalid listbox control") );
 745
 746     wxList::compatibility_iterator node = m_clientList.Item( n );
 747     wxCHECK_RET( node, wxT("invalid index in wxListBox::DoSetItemClientData") );
 748
 749     node->SetData( (wxObject*) clientData );
 750 }
 751
 752 void* wxListBox::DoGetItemClientData(unsigned int n) const
 753 {
 754     wxCHECK_MSG( m_widget != NULL, NULL, wxT("invalid listbox control") );
 755
 756     wxList::compatibility_iterator node = m_clientList.Item( n );
 757     wxCHECK_MSG( node, NULL, wxT("invalid index in wxListBox::DoGetItemClientData") );
 758
 759     return node->GetData();
 760 }
 761
 762 // ----------------------------------------------------------------------------
 763 // string list access
 764 // ----------------------------------------------------------------------------
 765
 766 wxString wxListBox::GetRealLabel(GList *item) const
 767 {
 768     GtkBin *bin = GTK_BIN( item->data );
 769     GtkLabel *label = GTK_LABEL( bin->child );
 770
 771     wxString str;
 772
 773     str = wxString( label->label );
 774
 775 #if wxUSE_CHECKLISTBOX
 776     // checklistboxes have "[±] " prepended to their lables, remove it
 777     //
 778     // NB: 4 below is the length of wxCHECKLBOX_STRING from wx/gtk1/checklst.h
 779     if ( m_hasCheckBoxes )
 780         str.erase(0, 4);
 781 #endif // wxUSE_CHECKLISTBOX
 782
 783     return str;
 784 }
 785
 786 void wxListBox::SetString(unsigned int n, const wxString &string)
 787 {
 788     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 789
 790     GList *child = g_list_nth( m_list->children, n );
 791     if (child)
 792     {
 793         GtkBin *bin = GTK_BIN( child->data );
 794         GtkLabel *label = GTK_LABEL( bin->child );
 795
 796         wxString str;
 797 #if wxUSE_CHECKLISTBOX
 798         if (m_hasCheckBoxes)
 799             str += wxCHECKLBOX_STRING;
 800 #endif // wxUSE_CHECKLISTBOX
 801         str += string;
 802
 803         gtk_label_set( label, wxGTK_CONV( str ) );
 804     }
 805     else
 806     {
 807         wxFAIL_MSG(wxT("wrong listbox index"));
 808     }
 809 }
 810
 811 wxString wxListBox::GetString(unsigned int n) const
 812 {
 813     wxCHECK_MSG( m_list != NULL, wxEmptyString, wxT("invalid listbox") );
 814
 815     GList *child = g_list_nth( m_list->children, n );
 816     if (child)
 817     {
 818         return GetRealLabel(child);
 819     }
 820
 821     wxFAIL_MSG(wxT("wrong listbox index"));
 822
 823     return wxEmptyString;
 824 }
 825
 826 unsigned int wxListBox::GetCount() const
 827 {
 828     wxCHECK_MSG( m_list != NULL, 0, wxT("invalid listbox") );
 829
 830     GList *children = m_list->children;
 831     return g_list_length(children);
 832 }
 833
 834 int wxListBox::FindString( const wxString &item, bool bCase ) const
 835 {
 836     wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") );
 837
 838     GList *child = m_list->children;
 839     int count = 0;
 840     while (child)
 841     {
 842         if ( item.IsSameAs( GetRealLabel(child), bCase ) )
 843             return count;
 844
 845         count++;
 846         child = child->next;
 847     }
 848
 849     // it's not an error if the string is not found -> no wxCHECK
 850
 851     return wxNOT_FOUND;
 852 }
 853
 854 // ----------------------------------------------------------------------------
 855 // selection
 856 // ----------------------------------------------------------------------------
 857
 858 int wxListBox::GetSelection() const
 859 {
 860     wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") );
 861
 862     GList *child = m_list->children;
 863     int count = 0;
 864     while (child)
 865     {
 866         if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED) return count;
 867         count++;
 868         child = child->next;
 869     }
 870     return wxNOT_FOUND;
 871 }
 872
 873 int wxListBox::GetSelections( wxArrayInt& aSelections ) const
 874 {
 875     wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") );
 876
 877     // get the number of selected items first
 878     GList *child = m_list->children;
 879     int count = 0;
 880     for (child = m_list->children; child != NULL; child = child->next)
 881     {
 882         if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED)
 883             count++;
 884     }
 885
 886     aSelections.Empty();
 887
 888     if (count > 0)
 889     {
 890         // now fill the list
 891         aSelections.Alloc(count); // optimization attempt
 892         int i = 0;
 893         for (child = m_list->children; child != NULL; child = child->next, i++)
 894         {
 895             if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED)
 896                  aSelections.Add(i);
 897         }
 898     }
 899
 900     return count;
 901 }
 902
 903 bool wxListBox::IsSelected( int n ) const
 904 {
 905     wxCHECK_MSG( m_list != NULL, false, wxT("invalid listbox") );
 906
 907     GList *target = g_list_nth( m_list->children, n );
 908
 909     wxCHECK_MSG( target, false, wxT("invalid listbox index") );
 910
 911     return (GTK_WIDGET(target->data)->state == GTK_STATE_SELECTED) ;
 912 }
 913
 914 void wxListBox::DoSetSelection( int n, bool select )
 915 {
 916     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 917
 918     m_blockEvent = true;
 919
 920     if (select)
 921     {
 922         if ((m_windowStyle & wxLB_SINGLE) != 0)
 923             gtk_list_unselect_item( m_list, m_prevSelection );
 924         gtk_list_select_item( m_list, n );
 925         m_prevSelection = n;
 926     }
 927     else
 928         gtk_list_unselect_item( m_list, n );
 929
 930     m_blockEvent = false;
 931 }
 932
 933 void wxListBox::DoSetFirstItem( int n )
 934 {
 935     wxCHECK_RET( m_list, wxT("invalid listbox") );
 936
 937     if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (m_list))
 938         return;
 939
 940     // terribly efficient
 941     const gchar *vadjustment_key = "gtk-vadjustment";
 942     guint vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
 943
 944     GtkAdjustment *adjustment =
 945        (GtkAdjustment*) gtk_object_get_data_by_id (GTK_OBJECT (m_list), vadjustment_key_id);
 946     wxCHECK_RET( adjustment, wxT("invalid listbox code") );
 947
 948     GList *target = g_list_nth( m_list->children, n );
 949     wxCHECK_RET( target, wxT("invalid listbox index") );
 950
 951     GtkWidget *item = GTK_WIDGET(target->data);
 952     wxCHECK_RET( item, wxT("invalid listbox code") );
 953
 954     if (item->allocation.y == -1)
 955     {
 956         wxlistbox_idle_struct* data = new wxlistbox_idle_struct;
 957         data->m_listbox = this;
 958         data->m_item = n;
 959         data->m_tag = gtk_idle_add_priority( 800, wxlistbox_idle_callback, (gpointer) data );
 960
 961         return;
 962     }
 963
 964     float y = item->allocation.y;
 965     if (y > adjustment->upper - adjustment->page_size)
 966         y = adjustment->upper - adjustment->page_size;
 967     gtk_adjustment_set_value( adjustment, y );
 968 }
 969
 970 // ----------------------------------------------------------------------------
 971 // helpers
 972 // ----------------------------------------------------------------------------
 973
 974 int wxListBox::GtkGetIndex( GtkWidget *item ) const
 975 {
 976     if (item)
 977     {
 978         GList *child = m_list->children;
 979         int count = 0;
 980         while (child)
 981         {
 982             if (GTK_WIDGET(child->data) == item) return count;
 983             count++;
 984             child = child->next;
 985         }
 986     }
 987     return -1;
 988 }
 989
 990 #if wxUSE_TOOLTIPS
 991 void wxListBox::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
 992 {
 993     GList *child = m_list->children;
 994     while (child)
 995     {
 996         gtk_tooltips_set_tip( tips, GTK_WIDGET( child->data ), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
 997         child = child->next;
 998     }
 999 }
1000 #endif // wxUSE_TOOLTIPS
1001
1002 GtkWidget *wxListBox::GetConnectWidget()
1003 {
1004     // return GTK_WIDGET(m_list);
1005     return m_widget;
1006 }
1007
1008 bool wxListBox::IsOwnGtkWindow( GdkWindow *window )
1009 {
1010     return true;
1011
1012 #if 0
1013     if (m_widget->window == window) return true;
1014
1015     if (GTK_WIDGET(m_list)->window == window) return true;
1016
1017     GList *child = m_list->children;
1018     while (child)
1019     {
1020         GtkWidget *bin = GTK_WIDGET( child->data );
1021         if (bin->window == window) return true;
1022         child = child->next;
1023     }
1024
1025     return false;
1026 #endif
1027 }
1028
1029 void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
1030 {
1031     if (m_hasBgCol && m_backgroundColour.Ok())
1032     {
1033         GdkWindow *window = GTK_WIDGET(m_list)->window;
1034         if ( window )
1035         {
1036             m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1037             gdk_window_set_background( window, m_backgroundColour.GetColor() );
1038             gdk_window_clear( window );
1039         }
1040     }
1041
1042     GList *child = m_list->children;
1043     while (child)
1044     {
1045         gtk_widget_modify_style( GTK_WIDGET(child->data), style );
1046
1047         GtkBin *bin = GTK_BIN( child->data );
1048         GtkWidget *label = GTK_WIDGET( bin->child );
1049         gtk_widget_modify_style( label, style );
1050
1051         child = child->next;
1052     }
1053 }
1054
1055 void wxListBox::OnInternalIdle()
1056 {
1057     wxCursor cursor = m_cursor;
1058     if (g_globalCursor.Ok()) cursor = g_globalCursor;
1059
1060     if (GTK_WIDGET(m_list)->window && cursor.Ok())
1061     {
1062         /* I now set the cursor the anew in every OnInternalIdle call
1063            as setting the cursor in a parent window also effects the
1064            windows above so that checking for the current cursor is
1065            not possible. */
1066
1067         gdk_window_set_cursor( GTK_WIDGET(m_list)->window, cursor.GetCursor() );
1068
1069         GList *child = m_list->children;
1070         while (child)
1071         {
1072             GtkBin *bin = GTK_BIN( child->data );
1073             GtkWidget *label = GTK_WIDGET( bin->child );
1074
1075             if (!label->window)
1076                 break;
1077             else
1078                 gdk_window_set_cursor( label->window, cursor.GetCursor() );
1079
1080             child = child->next;
1081         }
1082     }
1083
1084     if (g_delayedFocus == this)
1085     {
1086         if (GTK_WIDGET_REALIZED(m_widget))
1087         {
1088             gtk_widget_grab_focus( m_widget );
1089             g_delayedFocus = NULL;
1090         }
1091     }
1092
1093     if (wxUpdateUIEvent::CanUpdate(this))
1094         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1095 }
1096
1097 wxSize wxListBox::DoGetBestSize() const
1098 {
1099     int lbWidth = 100;  // some defaults
1100     int lbHeight = 110;
1101     int wLine;
1102
1103     // Find the widest line
1104     for(unsigned int i = 0; i < GetCount(); i++) {
1105         wxString str(GetString(i));
1106         GetTextExtent(str, &wLine, NULL);
1107         lbWidth = wxMax(lbWidth, wLine);
1108     }
1109
1110     // Add room for the scrollbar
1111     lbWidth += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1112
1113     // And just a bit more
1114     int cx, cy;
1115     GetTextExtent( wxT("X"), &cx, &cy);
1116     lbWidth += 3 * cx;
1117
1118     // don't make the listbox too tall (limit height to around 10 items) but don't
1119     // make it too small neither
1120     lbHeight = (cy+4) * wxMin(wxMax(GetCount(), 3), 10);
1121
1122     wxSize best(lbWidth, lbHeight);
1123     CacheBestSize(best);
1124     return best;
1125 }
1126
1127 void wxListBox::FixUpMouseEvent(GtkWidget *widget, wxCoord& x, wxCoord& y)
1128 {
1129     // the mouse event coords are relative to the listbox items, we need to
1130     // translate them to the normal client coords
1131     x += widget->allocation.x;
1132     y += widget->allocation.y;
1133 }
1134
1135
1136 // static
1137 wxVisualAttributes
1138 wxListBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1139 {
1140     return GetDefaultAttributesFromGTKWidget(gtk_list_new, true);
1141 }
1142
1143 #endif // wxUSE_LISTBOX