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->HandleWindowEvent(eventChildFocus);
 114
 115         wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
 116         eventFocus.SetEventObject(win);
 117
 118         (void)win->HandleWindowEvent(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 = 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->HandleWindowEvent( 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->HandleWindowEvent( 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->HandleWindowEvent( 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->HandleWindowEvent( 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->HandleWindowEvent( 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->HandleWindowEvent( 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->HandleWindowEvent( 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 // ----------------------------------------------------------------------------
 456 // construction
 457 // ----------------------------------------------------------------------------
 458
 459 wxListBox::wxListBox()
 460 {
 461     m_list = 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( NULL, 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 = 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     delete m_strings;
 569 }
 570
 571 // ----------------------------------------------------------------------------
 572 // adding items
 573 // ----------------------------------------------------------------------------
 574
 575 int wxListBox::DoInsertItems(const wxArrayStringsAdapter& items,
 576                              unsigned int pos,
 577                              void **clientData,
 578                              wxClientDataType type)
 579 {
 580     wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") );
 581
 582     const unsigned count = GetCount();
 583     wxCHECK_MSG( pos <= count, wxNOT_FOUND,
 584                     wxT("invalid index in wxListBox::InsertItems") );
 585
 586     // code elsewhere supposes we have as many items in m_clientList as items
 587     // in the listbox
 588     wxASSERT_MSG( m_clientList.GetCount() == count,
 589                       wxT("bug in client data management") );
 590
 591     InvalidateBestSize();
 592
 593     const unsigned numItems = items.GetCount();
 594
 595     for ( unsigned int n = 0; n < numItems; ++n, ++pos )
 596     {
 597         const wxString& item = items[n];
 598
 599         const unsigned idx = m_strings ? m_strings->Add(item)
 600                                        : pos;
 601
 602         GtkAddItem(item, idx == GetCount() ? (unsigned) -1 : idx);
 603
 604         m_clientList.Insert(idx, NULL);
 605
 606         AssignNewItemClientData(idx, clientData, n, type);
 607     }
 608
 609     wxASSERT_MSG( m_clientList.GetCount() == GetCount(),
 610                       wxT("bug in client data management") );
 611
 612     return pos - 1;
 613 }
 614
 615 void wxListBox::GtkAddItem( const wxString &item, int pos )
 616 {
 617     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 618
 619     GtkWidget *list_item;
 620
 621     wxString label(item);
 622 #if wxUSE_CHECKLISTBOX
 623     if (m_hasCheckBoxes)
 624     {
 625         label.Prepend(wxCHECKLBOX_STRING);
 626     }
 627 #endif // wxUSE_CHECKLISTBOX
 628
 629     list_item = gtk_list_item_new_with_label( wxGTK_CONV( label ) );
 630
 631     GList *gitem_list = g_list_alloc ();
 632     gitem_list->data = list_item;
 633
 634     if (pos == -1)
 635         gtk_list_append_items( GTK_LIST (m_list), gitem_list );
 636     else
 637         gtk_list_insert_items( GTK_LIST (m_list), gitem_list, pos );
 638
 639     gtk_signal_connect_after( GTK_OBJECT(list_item), "select",
 640       GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
 641
 642     if (HasFlag(wxLB_MULTIPLE) || HasFlag(wxLB_EXTENDED))
 643         gtk_signal_connect_after( GTK_OBJECT(list_item), "deselect",
 644           GTK_SIGNAL_FUNC(gtk_listitem_deselect_callback), (gpointer)this );
 645
 646     gtk_signal_connect( GTK_OBJECT(list_item),
 647                         "button_press_event",
 648                         (GtkSignalFunc)gtk_listbox_button_press_callback,
 649                         (gpointer) this );
 650
 651     gtk_signal_connect_after( GTK_OBJECT(list_item),
 652                         "button_release_event",
 653                         (GtkSignalFunc)gtk_listbox_button_release_callback,
 654                         (gpointer) this );
 655
 656     gtk_signal_connect( GTK_OBJECT(list_item),
 657                            "key_press_event",
 658                            (GtkSignalFunc)gtk_listbox_key_press_callback,
 659                            (gpointer)this );
 660
 661
 662     gtk_signal_connect( GTK_OBJECT(list_item), "focus_in_event",
 663             GTK_SIGNAL_FUNC(gtk_listitem_focus_in_callback), (gpointer)this );
 664
 665     gtk_signal_connect( GTK_OBJECT(list_item), "focus_out_event",
 666             GTK_SIGNAL_FUNC(gtk_listitem_focus_out_callback), (gpointer)this );
 667
 668     ConnectWidget( list_item );
 669
 670     if (GTK_WIDGET_REALIZED(m_widget))
 671     {
 672         gtk_widget_show( list_item );
 673
 674         gtk_widget_realize( list_item );
 675         gtk_widget_realize( GTK_BIN(list_item)->child );
 676
 677 #if wxUSE_TOOLTIPS
 678         if (m_tooltip) m_tooltip->Apply( this );
 679 #endif
 680     }
 681
 682     // Apply current widget style to the new list_item
 683     GtkRcStyle *style = CreateWidgetStyle();
 684     if (style)
 685     {
 686         gtk_widget_modify_style( GTK_WIDGET( list_item ), style );
 687         GtkBin *bin = GTK_BIN( list_item );
 688         gtk_widget_modify_style( GTK_WIDGET( bin->child ), style );
 689         gtk_rc_style_unref( style );
 690     }
 691 }
 692
 693 // ----------------------------------------------------------------------------
 694 // deleting items
 695 // ----------------------------------------------------------------------------
 696
 697 void wxListBox::DoClear()
 698 {
 699     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 700
 701     gtk_list_clear_items( m_list, 0, (int)GetCount() );
 702
 703     if ( GTK_LIST(m_list)->last_focus_child != NULL  )
 704     {
 705         // This should be NULL, I think.
 706         GTK_LIST(m_list)->last_focus_child = NULL;
 707     }
 708
 709     m_clientList.Clear();
 710
 711     if ( m_strings )
 712         m_strings->Clear();
 713 }
 714
 715 void wxListBox::DoDeleteOneItem(unsigned int n)
 716 {
 717     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 718
 719     GList *child = g_list_nth( m_list->children, n );
 720
 721     wxCHECK_RET( child, wxT("wrong listbox index") );
 722
 723     GList *list = g_list_append( NULL, child->data );
 724     gtk_list_remove_items( m_list, list );
 725     g_list_free( list );
 726
 727     wxList::compatibility_iterator node = m_clientList.Item( n );
 728     if ( node )
 729     {
 730         m_clientList.Erase( node );
 731     }
 732
 733     if ( m_strings )
 734         m_strings->RemoveAt(n);
 735 }
 736
 737 // ----------------------------------------------------------------------------
 738 // client data
 739 // ----------------------------------------------------------------------------
 740
 741 void wxListBox::DoSetItemClientData(unsigned int n, void* clientData)
 742 {
 743     wxCHECK_RET( m_widget != NULL, wxT("invalid listbox control") );
 744
 745     wxList::compatibility_iterator node = m_clientList.Item( n );
 746     wxCHECK_RET( node, wxT("invalid index in wxListBox::DoSetItemClientData") );
 747
 748     node->SetData( (wxObject*) clientData );
 749 }
 750
 751 void* wxListBox::DoGetItemClientData(unsigned int n) const
 752 {
 753     wxCHECK_MSG( m_widget != NULL, NULL, wxT("invalid listbox control") );
 754
 755     wxList::compatibility_iterator node = m_clientList.Item( n );
 756     wxCHECK_MSG( node, NULL, wxT("invalid index in wxListBox::DoGetItemClientData") );
 757
 758     return node->GetData();
 759 }
 760
 761 // ----------------------------------------------------------------------------
 762 // string list access
 763 // ----------------------------------------------------------------------------
 764
 765 wxString wxListBox::GetRealLabel(GList *item) const
 766 {
 767     GtkBin *bin = GTK_BIN( item->data );
 768     GtkLabel *label = GTK_LABEL( bin->child );
 769
 770     wxString str;
 771
 772     str = wxString( label->label );
 773
 774 #if wxUSE_CHECKLISTBOX
 775     // checklistboxes have "[±] " prepended to their lables, remove it
 776     //
 777     // NB: 4 below is the length of wxCHECKLBOX_STRING from wx/gtk1/checklst.h
 778     if ( m_hasCheckBoxes )
 779         str.erase(0, 4);
 780 #endif // wxUSE_CHECKLISTBOX
 781
 782     return str;
 783 }
 784
 785 void wxListBox::SetString(unsigned int n, const wxString &string)
 786 {
 787     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 788
 789     GList *child = g_list_nth( m_list->children, n );
 790     if (child)
 791     {
 792         GtkBin *bin = GTK_BIN( child->data );
 793         GtkLabel *label = GTK_LABEL( bin->child );
 794
 795         wxString str;
 796 #if wxUSE_CHECKLISTBOX
 797         if (m_hasCheckBoxes)
 798             str += wxCHECKLBOX_STRING;
 799 #endif // wxUSE_CHECKLISTBOX
 800         str += string;
 801
 802         gtk_label_set( label, wxGTK_CONV( str ) );
 803     }
 804     else
 805     {
 806         wxFAIL_MSG(wxT("wrong listbox index"));
 807     }
 808 }
 809
 810 wxString wxListBox::GetString(unsigned int n) const
 811 {
 812     wxCHECK_MSG( m_list != NULL, wxEmptyString, wxT("invalid listbox") );
 813
 814     GList *child = g_list_nth( m_list->children, n );
 815     if (child)
 816     {
 817         return GetRealLabel(child);
 818     }
 819
 820     wxFAIL_MSG(wxT("wrong listbox index"));
 821
 822     return wxEmptyString;
 823 }
 824
 825 unsigned int wxListBox::GetCount() const
 826 {
 827     wxCHECK_MSG( m_list != NULL, 0, wxT("invalid listbox") );
 828
 829     GList *children = m_list->children;
 830     return g_list_length(children);
 831 }
 832
 833 int wxListBox::FindString( const wxString &item, bool bCase ) const
 834 {
 835     wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") );
 836
 837     GList *child = m_list->children;
 838     int count = 0;
 839     while (child)
 840     {
 841         if ( item.IsSameAs( GetRealLabel(child), bCase ) )
 842             return count;
 843
 844         count++;
 845         child = child->next;
 846     }
 847
 848     // it's not an error if the string is not found -> no wxCHECK
 849
 850     return wxNOT_FOUND;
 851 }
 852
 853 // ----------------------------------------------------------------------------
 854 // selection
 855 // ----------------------------------------------------------------------------
 856
 857 int wxListBox::GetSelection() const
 858 {
 859     wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") );
 860
 861     GList *child = m_list->children;
 862     int count = 0;
 863     while (child)
 864     {
 865         if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED) return count;
 866         count++;
 867         child = child->next;
 868     }
 869     return wxNOT_FOUND;
 870 }
 871
 872 int wxListBox::GetSelections( wxArrayInt& aSelections ) const
 873 {
 874     wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") );
 875
 876     // get the number of selected items first
 877     GList *child = m_list->children;
 878     int count = 0;
 879     for (child = m_list->children; child != NULL; child = child->next)
 880     {
 881         if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED)
 882             count++;
 883     }
 884
 885     aSelections.Empty();
 886
 887     if (count > 0)
 888     {
 889         // now fill the list
 890         aSelections.Alloc(count); // optimization attempt
 891         int i = 0;
 892         for (child = m_list->children; child != NULL; child = child->next, i++)
 893         {
 894             if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED)
 895                  aSelections.Add(i);
 896         }
 897     }
 898
 899     return count;
 900 }
 901
 902 bool wxListBox::IsSelected( int n ) const
 903 {
 904     wxCHECK_MSG( m_list != NULL, false, wxT("invalid listbox") );
 905
 906     GList *target = g_list_nth( m_list->children, n );
 907
 908     wxCHECK_MSG( target, false, wxT("invalid listbox index") );
 909
 910     return (GTK_WIDGET(target->data)->state == GTK_STATE_SELECTED) ;
 911 }
 912
 913 void wxListBox::DoSetSelection( int n, bool select )
 914 {
 915     wxCHECK_RET( m_list != NULL, wxT("invalid listbox") );
 916
 917     m_blockEvent = true;
 918
 919     if (select)
 920     {
 921         if ((m_windowStyle & wxLB_SINGLE) != 0)
 922             gtk_list_unselect_item( m_list, m_prevSelection );
 923         gtk_list_select_item( m_list, n );
 924         m_prevSelection = n;
 925     }
 926     else
 927         gtk_list_unselect_item( m_list, n );
 928
 929     m_blockEvent = false;
 930 }
 931
 932 void wxListBox::DoSetFirstItem( int n )
 933 {
 934     wxCHECK_RET( m_list, wxT("invalid listbox") );
 935
 936     if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (m_list))
 937         return;
 938
 939     // terribly efficient
 940     const gchar *vadjustment_key = "gtk-vadjustment";
 941     guint vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
 942
 943     GtkAdjustment *adjustment =
 944        (GtkAdjustment*) gtk_object_get_data_by_id (GTK_OBJECT (m_list), vadjustment_key_id);
 945     wxCHECK_RET( adjustment, wxT("invalid listbox code") );
 946
 947     GList *target = g_list_nth( m_list->children, n );
 948     wxCHECK_RET( target, wxT("invalid listbox index") );
 949
 950     GtkWidget *item = GTK_WIDGET(target->data);
 951     wxCHECK_RET( item, wxT("invalid listbox code") );
 952
 953     if (item->allocation.y == -1)
 954     {
 955         wxlistbox_idle_struct* data = new wxlistbox_idle_struct;
 956         data->m_listbox = this;
 957         data->m_item = n;
 958         data->m_tag = gtk_idle_add_priority( 800, wxlistbox_idle_callback, (gpointer) data );
 959
 960         return;
 961     }
 962
 963     float y = item->allocation.y;
 964     if (y > adjustment->upper - adjustment->page_size)
 965         y = adjustment->upper - adjustment->page_size;
 966     gtk_adjustment_set_value( adjustment, y );
 967 }
 968
 969 // ----------------------------------------------------------------------------
 970 // helpers
 971 // ----------------------------------------------------------------------------
 972
 973 int wxListBox::GtkGetIndex( GtkWidget *item ) const
 974 {
 975     if (item)
 976     {
 977         GList *child = m_list->children;
 978         int count = 0;
 979         while (child)
 980         {
 981             if (GTK_WIDGET(child->data) == item) return count;
 982             count++;
 983             child = child->next;
 984         }
 985     }
 986     return -1;
 987 }
 988
 989 #if wxUSE_TOOLTIPS
 990 void wxListBox::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
 991 {
 992     GList *child = m_list->children;
 993     while (child)
 994     {
 995         gtk_tooltips_set_tip( tips, GTK_WIDGET( child->data ), wxConvCurrent->cWX2MB(tip), NULL );
 996         child = child->next;
 997     }
 998 }
 999 #endif // wxUSE_TOOLTIPS
1000
1001 GtkWidget *wxListBox::GetConnectWidget()
1002 {
1003     // return GTK_WIDGET(m_list);
1004     return m_widget;
1005 }
1006
1007 bool wxListBox::IsOwnGtkWindow( GdkWindow *window )
1008 {
1009     return m_widget->window == window ||
1010                 GTK_WIDGET(m_list)->window == window;
1011 }
1012
1013 void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
1014 {
1015     if (m_hasBgCol && m_backgroundColour.Ok())
1016     {
1017         GdkWindow *window = GTK_WIDGET(m_list)->window;
1018         if ( window )
1019         {
1020             m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1021             gdk_window_set_background( window, m_backgroundColour.GetColor() );
1022             gdk_window_clear( window );
1023         }
1024     }
1025
1026     GList *child = m_list->children;
1027     while (child)
1028     {
1029         gtk_widget_modify_style( GTK_WIDGET(child->data), style );
1030
1031         GtkBin *bin = GTK_BIN( child->data );
1032         GtkWidget *label = GTK_WIDGET( bin->child );
1033         gtk_widget_modify_style( label, style );
1034
1035         child = child->next;
1036     }
1037 }
1038
1039 void wxListBox::OnInternalIdle()
1040 {
1041     wxCursor cursor = m_cursor;
1042     if (g_globalCursor.Ok()) cursor = g_globalCursor;
1043
1044     if (GTK_WIDGET(m_list)->window && cursor.Ok())
1045     {
1046         /* I now set the cursor the anew in every OnInternalIdle call
1047            as setting the cursor in a parent window also effects the
1048            windows above so that checking for the current cursor is
1049            not possible. */
1050
1051         gdk_window_set_cursor( GTK_WIDGET(m_list)->window, cursor.GetCursor() );
1052
1053         GList *child = m_list->children;
1054         while (child)
1055         {
1056             GtkBin *bin = GTK_BIN( child->data );
1057             GtkWidget *label = GTK_WIDGET( bin->child );
1058
1059             if (!label->window)
1060                 break;
1061             else
1062                 gdk_window_set_cursor( label->window, cursor.GetCursor() );
1063
1064             child = child->next;
1065         }
1066     }
1067
1068     if (g_delayedFocus == this)
1069     {
1070         if (GTK_WIDGET_REALIZED(m_widget))
1071         {
1072             gtk_widget_grab_focus( m_widget );
1073             g_delayedFocus = NULL;
1074         }
1075     }
1076
1077     if (wxUpdateUIEvent::CanUpdate(this))
1078         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1079 }
1080
1081 wxSize wxListBox::DoGetBestSize() const
1082 {
1083     int lbWidth = 100;  // some defaults
1084     int lbHeight = 110;
1085     int wLine;
1086
1087     // Find the widest line
1088     for(unsigned int i = 0; i < GetCount(); i++) {
1089         wxString str(GetString(i));
1090         GetTextExtent(str, &wLine, NULL);
1091         lbWidth = wxMax(lbWidth, wLine);
1092     }
1093
1094     // Add room for the scrollbar
1095     lbWidth += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1096
1097     // And just a bit more
1098     int cx, cy;
1099     GetTextExtent( wxT("X"), &cx, &cy);
1100     lbWidth += 3 * cx;
1101
1102     // don't make the listbox too tall (limit height to around 10 items) but don't
1103     // make it too small neither
1104     lbHeight = (cy+4) * wxMin(wxMax(GetCount(), 3), 10);
1105
1106     wxSize best(lbWidth, lbHeight);
1107     CacheBestSize(best);
1108     return best;
1109 }
1110
1111 void wxListBox::FixUpMouseEvent(GtkWidget *widget, wxCoord& x, wxCoord& y)
1112 {
1113     // the mouse event coords are relative to the listbox items, we need to
1114     // translate them to the normal client coords
1115     x += widget->allocation.x;
1116     y += widget->allocation.y;
1117 }
1118
1119
1120 // static
1121 wxVisualAttributes
1122 wxListBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1123 {
1124     return GetDefaultAttributesFromGTKWidget(gtk_list_new, true);
1125 }
1126
1127 #endif // wxUSE_LISTBOX