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