]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/listbox.cpp
Keep the key up/down event consistency without relying on toupper()
[wxWidgets.git] / src / gtk / listbox.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/listbox.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Modified By: Ryan Norton (GtkTreeView implementation)
6 // Id: $Id$
7 // Copyright: (c) 1998 Robert Roebling
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // For compilers that support precompilation, includes "wx.h".
12 #include "wx/wxprec.h"
13
14 #include "wx/defs.h"
15
16 #if wxUSE_LISTBOX
17
18 #include "wx/listbox.h"
19 #include "wx/dynarray.h"
20 #include "wx/arrstr.h"
21 #include "wx/utils.h"
22 #include "wx/intl.h"
23 #include "wx/checklst.h"
24 #include "wx/settings.h"
25 #include "wx/log.h"
26 #include "wx/gtk/private.h"
27 #include "wx/gtk/treeentry_gtk.h"
28
29 #if wxUSE_TOOLTIPS
30 #include "wx/tooltip.h"
31 #endif
32
33 #include <gdk/gdk.h>
34 #include <gtk/gtk.h>
35 #include <gdk/gdkkeysyms.h>
36
37 //-----------------------------------------------------------------------------
38 // data
39 //-----------------------------------------------------------------------------
40
41 extern bool g_blockEventsOnDrag;
42 extern bool g_blockEventsOnScroll;
43 extern wxCursor g_globalCursor;
44
45
46 //-----------------------------------------------------------------------------
47 // idle system
48 //-----------------------------------------------------------------------------
49
50 extern void wxapp_install_idle_handler();
51 extern bool g_isIdle;
52
53 //-----------------------------------------------------------------------------
54 // Macro to tell which row the strings are in (1 if native checklist, 0 if not)
55 //-----------------------------------------------------------------------------
56
57 #if wxUSE_CHECKLISTBOX && wxUSE_NATIVEGTKCHECKLIST
58 # define WXLISTBOX_DATACOLUMN_ARG(x) (x->m_hasCheckBoxes ? 1 : 0)
59 #else
60 # define WXLISTBOX_DATACOLUMN_ARG(x) (0)
61 #endif // wxUSE_CHECKLISTBOX && wxUSE_NATIVEGTKCHECKLIST
62
63 #define WXLISTBOX_DATACOLUMN WXLISTBOX_DATACOLUMN_ARG(this)
64
65 //-----------------------------------------------------------------------------
66 // "row-activated"
67 //-----------------------------------------------------------------------------
68
69 extern "C" {
70 static void
71 gtk_listbox_row_activated_callback(GtkTreeView *treeview,
72 GtkTreePath *path,
73 GtkTreeViewColumn *col,
74 wxListBox *listbox)
75 {
76 if (g_isIdle) wxapp_install_idle_handler();
77
78 if (g_blockEventsOnDrag) return;
79 if (g_blockEventsOnScroll) return;
80
81 if (!listbox->m_hasVMT) return;
82
83 //Notes:
84 //1) This is triggered by either a double-click or a space press
85 //2) We handle both here because
86 //2a) in the case of a space/keypress we can't really know
87 // which item was pressed on because we can't get coords
88 // from a keyevent
89 //2b) It seems more correct
90
91 int sel = gtk_tree_path_get_indices(path)[0];
92
93 if(!listbox->m_spacePressed)
94 {
95 //Assume it was double-click
96 wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, listbox->GetId() );
97 event.SetEventObject( listbox );
98
99 if(listbox->IsSelected(sel))
100 {
101 GtkTreeEntry* entry = listbox->GtkGetEntry(sel);
102
103 if(entry)
104 {
105 event.SetInt(sel);
106 event.SetString(wxConvUTF8.cMB2WX(gtk_tree_entry_get_label(entry)));
107
108 if ( listbox->HasClientObjectData() )
109 event.SetClientObject(
110 (wxClientData*) gtk_tree_entry_get_userdata(entry) );
111 else if ( listbox->HasClientUntypedData() )
112 event.SetClientData( gtk_tree_entry_get_userdata(entry) );
113 g_object_unref(G_OBJECT(entry));
114 }
115 else
116 {
117 wxLogSysError(wxT("Internal error - could not get entry for double-click"));
118 event.SetInt(-1);
119 }
120 }
121 else
122 event.SetInt(-1);
123
124 listbox->GetEventHandler()->ProcessEvent( event );
125 }
126 else
127 {
128 listbox->m_spacePressed = false; //don't block selection behaviour anymore
129
130 //Space was pressed - toggle the appropriate checkbox and the selection
131 #if wxUSE_CHECKLISTBOX //Do it for both native and non-native
132 if (listbox->m_hasCheckBoxes)
133 {
134 wxCheckListBox *clb = (wxCheckListBox *)listbox;
135
136 clb->Check( sel, !clb->IsChecked(sel) );
137
138 wxCommandEvent new_event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() );
139 new_event.SetEventObject( listbox );
140 new_event.SetInt( sel );
141 listbox->GetEventHandler()->ProcessEvent( new_event );
142 }
143 #endif // wxUSE_CHECKLISTBOX
144
145 if( (((listbox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0) ||
146 ((listbox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)) )
147 {
148 //toggle the selection + send event
149 if(listbox->IsSelected( sel ))
150 listbox->GtkSetSelection(sel, FALSE, FALSE);
151 else
152 listbox->GtkSetSelection(sel, TRUE, FALSE);
153 }
154 }
155 }
156 }
157
158 //-----------------------------------------------------------------------------
159 // "button_press_event"
160 //-----------------------------------------------------------------------------
161
162 extern "C" {
163 static gint
164 gtk_listbox_button_press_callback( GtkWidget *widget,
165 GdkEventButton *gdk_event,
166 wxListBox *listbox )
167 {
168 if (g_isIdle) wxapp_install_idle_handler();
169
170 if (g_blockEventsOnDrag) return FALSE;
171 if (g_blockEventsOnScroll) return FALSE;
172
173 if (!listbox->m_hasVMT) return FALSE;
174
175 //Just to be on the safe side - it should be unset in the activate callback
176 //but we don't want any obscure bugs if it doesn't get called somehow...
177 listbox->m_spacePressed = false;
178
179 #if wxUSE_CHECKLISTBOX && !wxUSE_NATIVEGTKCHECKLIST
180 if ((listbox->m_hasCheckBoxes) && (gdk_event->x < 15) && (gdk_event->type != GDK_2BUTTON_PRESS))
181 {
182 GtkTreePath* path;
183 gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),
184 (gint)gdk_event->x, (gint)gdk_event->y,
185 &path, NULL, NULL, NULL);
186 int sel = gtk_tree_path_get_indices(path)[0];
187 gtk_tree_path_free(path);
188
189 wxCheckListBox *clb = (wxCheckListBox *)listbox;
190
191 clb->Check( sel, !clb->IsChecked(sel) );
192
193 wxCommandEvent event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() );
194 event.SetEventObject( listbox );
195 event.SetInt( sel );
196 listbox->GetEventHandler()->ProcessEvent( event );
197 }
198 #endif // wxUSE_CHECKLISTBOX && !wxUSE_NATIVEGTKCHECKLIST
199
200 return FALSE;
201 }
202 }
203
204 //-----------------------------------------------------------------------------
205 // "key_press_event"
206 //-----------------------------------------------------------------------------
207
208 extern "C" {
209 static gint
210 gtk_listbox_key_press_callback( GtkWidget *widget,
211 GdkEventKey *gdk_event,
212 wxListBox *listbox )
213 {
214 if (g_isIdle) wxapp_install_idle_handler();
215
216 if (g_blockEventsOnDrag) return FALSE;
217
218
219 bool ret = FALSE;
220
221 if ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab))
222 {
223 wxNavigationKeyEvent new_event;
224 /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
225 new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
226 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
227 new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
228 new_event.SetCurrentFocus( listbox );
229 ret = listbox->GetEventHandler()->ProcessEvent( new_event );
230 }
231
232 if ((gdk_event->keyval == GDK_Return) && (!ret))
233 {
234 // eat return in all modes (RN:WHY?)
235 ret = TRUE;
236 }
237
238 // Check or uncheck item with SPACE
239 if (gdk_event->keyval == ' ')
240 {
241 //In the keyevent we don't know the index of the item
242 //and the activated event gets called anyway...
243 //
244 //Also, activating with the space causes the treeview to
245 //unselect all the items and then select the item in question
246 //wx's behaviour is to just toggle the item's selection state
247 //and leave the others alone
248 listbox->m_spacePressed = true;
249 }
250
251 if (ret)
252 {
253 g_signal_stop_emission_by_name (widget, "key_press_event");
254 return TRUE;
255 }
256
257 return FALSE;
258 }
259 }
260
261 //-----------------------------------------------------------------------------
262 // "select" and "deselect"
263 //-----------------------------------------------------------------------------
264
265 extern "C" {
266 static gboolean gtk_listitem_select_cb( GtkTreeSelection* selection,
267 GtkTreeModel* model,
268 GtkTreePath* path,
269 gboolean is_selected,
270 wxListBox *listbox )
271 {
272 if (g_isIdle) wxapp_install_idle_handler();
273
274 if (!listbox->m_hasVMT) return TRUE;
275 if (g_blockEventsOnDrag) return TRUE;
276
277 if (listbox->m_spacePressed) return FALSE; //see keyevent callback
278 if (listbox->m_blockEvent) return TRUE;
279
280 // NB: wxdocs explicitly say that this event only gets sent when
281 // something is actually selected, plus the controls example
282 // assumes so and passes -1 to the dogetclientdata funcs if not
283
284 // OK, so basically we need to do a bit of a run-around here as
285 // 1) is_selected says whether the item(s?) are CURRENTLY selected -
286 // i.e. if is_selected is FALSE then the item is going to be
287 // selected right now!
288 // 2) However, since it is not already selected and the user
289 // will expect it to be we need to manually select it and
290 // return FALSE telling GTK we handled the selection
291 if (is_selected) return TRUE;
292
293 int nIndex = gtk_tree_path_get_indices(path)[0];
294 GtkTreeEntry* entry = listbox->GtkGetEntry(nIndex);
295
296 if(entry)
297 {
298 //Now, as mentioned above, we manually select the row that is/was going
299 //to be selected anyway by GTK
300 listbox->m_blockEvent = TRUE; //if we don't block events we will lock the
301 //app due to recursion!!
302
303 GtkTreeSelection* selection =
304 gtk_tree_view_get_selection(listbox->m_treeview);
305 GtkTreeIter iter;
306 gtk_tree_model_get_iter(GTK_TREE_MODEL(listbox->m_liststore), &iter, path);
307 gtk_tree_selection_select_iter(selection, &iter);
308
309 listbox->m_blockEvent = FALSE;
310
311 //Finally, send the wx event
312 wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, listbox->GetId() );
313 event.SetEventObject( listbox );
314
315 // indicate whether this is a selection or a deselection
316 event.SetExtraLong( 1 );
317
318 event.SetInt(nIndex);
319 event.SetString(wxConvUTF8.cMB2WX(gtk_tree_entry_get_label(entry)));
320
321 if ( listbox->HasClientObjectData() )
322 event.SetClientObject(
323 (wxClientData*) gtk_tree_entry_get_userdata(entry)
324 );
325 else if ( listbox->HasClientUntypedData() )
326 event.SetClientData( gtk_tree_entry_get_userdata(entry) );
327
328 listbox->GetEventHandler()->ProcessEvent( event );
329
330 g_object_unref(G_OBJECT(entry));
331 return FALSE; //We handled it/did it manually
332 }
333
334 return TRUE; //allow selection to change
335 }
336 }
337
338 //-----------------------------------------------------------------------------
339 // GtkTreeEntry destruction (to destroy client data)
340 //-----------------------------------------------------------------------------
341
342 extern "C" {
343 static void gtk_tree_entry_destroy_cb(GtkTreeEntry* entry,
344 wxListBox* listbox)
345 {
346 if(listbox->HasClientObjectData())
347 {
348 gpointer userdata = gtk_tree_entry_get_userdata(entry);
349 if(userdata)
350 delete (wxClientData *)userdata;
351 }
352 }
353 }
354
355 //-----------------------------------------------------------------------------
356 // Sorting callback (standard CmpNoCase return value)
357 //-----------------------------------------------------------------------------
358
359 extern "C" {
360 static gint gtk_listbox_sort_callback(GtkTreeModel *model,
361 GtkTreeIter *a,
362 GtkTreeIter *b,
363 wxListBox *listbox)
364 {
365 GtkTreeEntry* entry;
366 GtkTreeEntry* entry2;
367
368 gtk_tree_model_get(GTK_TREE_MODEL(listbox->m_liststore),
369 a,
370 WXLISTBOX_DATACOLUMN_ARG(listbox),
371 &entry, -1);
372 gtk_tree_model_get(GTK_TREE_MODEL(listbox->m_liststore),
373 b,
374 WXLISTBOX_DATACOLUMN_ARG(listbox),
375 &entry2, -1);
376 wxCHECK_MSG(entry, 0, wxT("Could not get entry"));
377 wxCHECK_MSG(entry2, 0, wxT("Could not get entry2"));
378
379 //We compare collate keys here instead of calling g_utf8_collate
380 //as it is rather slow (and even the docs reccommend this)
381 int ret = strcasecmp(gtk_tree_entry_get_collate_key(entry),
382 gtk_tree_entry_get_collate_key(entry2));
383
384 g_object_unref(G_OBJECT(entry));
385 g_object_unref(G_OBJECT(entry2));
386
387 return ret;
388 }
389 }
390
391 //-----------------------------------------------------------------------------
392 // Searching callback (TRUE == not equal, FALSE == equal)
393 //-----------------------------------------------------------------------------
394
395 extern "C" {
396 static gboolean gtk_listbox_searchequal_callback(GtkTreeModel* model,
397 gint column,
398 const gchar* key,
399 GtkTreeIter* iter,
400 wxListBox* listbox)
401 {
402 GtkTreeEntry* entry;
403
404 gtk_tree_model_get(GTK_TREE_MODEL(listbox->m_liststore),
405 iter,
406 WXLISTBOX_DATACOLUMN_ARG(listbox),
407 &entry, -1);
408 wxCHECK_MSG(entry, 0, wxT("Could not get entry"));
409 gchar* keycollatekey = g_utf8_collate_key(key, -1);
410
411 int ret = strcasecmp(keycollatekey,
412 gtk_tree_entry_get_collate_key(entry));
413
414 g_free(keycollatekey);
415 g_object_unref(G_OBJECT(entry));
416
417 return ret != 0;
418 }
419 }
420
421 //-----------------------------------------------------------------------------
422 // wxListBox
423 //-----------------------------------------------------------------------------
424
425 IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
426
427 // ----------------------------------------------------------------------------
428 // construction
429 // ----------------------------------------------------------------------------
430
431 wxListBox::wxListBox()
432 {
433 m_treeview = (GtkTreeView*) NULL;
434 #if wxUSE_CHECKLISTBOX
435 m_hasCheckBoxes = FALSE;
436 #endif // wxUSE_CHECKLISTBOX
437 m_spacePressed = false;
438 }
439
440 bool wxListBox::Create( wxWindow *parent, wxWindowID id,
441 const wxPoint &pos, const wxSize &size,
442 const wxArrayString& choices,
443 long style, const wxValidator& validator,
444 const wxString &name )
445 {
446 wxCArrayString chs(choices);
447
448 return Create( parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
449 style, validator, name );
450 }
451
452 bool wxListBox::Create( wxWindow *parent, wxWindowID id,
453 const wxPoint &pos, const wxSize &size,
454 int n, const wxString choices[],
455 long style, const wxValidator& validator,
456 const wxString &name )
457 {
458 m_needParent = TRUE;
459 m_acceptsFocus = TRUE;
460 m_blockEvent = FALSE;
461
462 if (!PreCreation( parent, pos, size ) ||
463 !CreateBase( parent, id, pos, size, style, validator, name ))
464 {
465 wxFAIL_MSG( wxT("wxListBox creation failed") );
466 return FALSE;
467 }
468
469 m_widget = gtk_scrolled_window_new( (GtkAdjustment*) NULL, (GtkAdjustment*) NULL );
470 if (style & wxLB_ALWAYS_SB)
471 {
472 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
473 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
474 }
475 else
476 {
477 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
478 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
479 }
480
481 m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) );
482
483 //wxListBox doesn't have a header :)
484 //NB: If enabled SetFirstItem doesn't work correctly
485 gtk_tree_view_set_headers_visible(m_treeview, FALSE);
486
487 #if wxUSE_CHECKLISTBOX && wxUSE_NATIVEGTKCHECKLIST
488 if(m_hasCheckBoxes)
489 ((wxCheckListBox*)this)->DoCreateCheckList();
490 #endif // wxUSE_CHECKLISTBOX && wxUSE_NATIVEGTKCHECKLIST
491
492 // Create the data column
493 gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "",
494 gtk_cell_renderer_text_new(),
495 "text",
496 WXLISTBOX_DATACOLUMN, NULL);
497
498 // Now create+set the model (GtkListStore) - first argument # of columns
499 #if wxUSE_CHECKLISTBOX && wxUSE_NATIVEGTKCHECKLIST
500 if(m_hasCheckBoxes)
501 m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN,
502 GTK_TYPE_TREE_ENTRY);
503 else
504 #endif
505 m_liststore = gtk_list_store_new(1, GTK_TYPE_TREE_ENTRY);
506
507 gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore));
508
509 g_object_unref(G_OBJECT(m_liststore)); //free on treeview destruction
510
511 // Disable the pop-up textctrl that enables searching - note that
512 // the docs specify that even if this disabled (which we are doing)
513 // the user can still have it through the start-interactive-search
514 // key binding...either way we want to provide a searchequal callback
515 // NB: If this is enabled a doubleclick event (activate) gets sent
516 // on a successful search
517 gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN);
518 gtk_tree_view_set_search_equal_func(m_treeview,
519 (GtkTreeViewSearchEqualFunc) gtk_listbox_searchequal_callback,
520 this,
521 NULL);
522
523 gtk_tree_view_set_enable_search(m_treeview, FALSE);
524
525
526 GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview );
527 gtk_tree_selection_set_select_function(selection,
528 (GtkTreeSelectionFunc)gtk_listitem_select_cb,
529 this, NULL); //NULL == destroycb
530
531 GtkSelectionMode mode;
532 if (style & wxLB_MULTIPLE)
533 {
534 mode = GTK_SELECTION_MULTIPLE;
535 }
536 else if (style & wxLB_EXTENDED)
537 {
538 mode = GTK_SELECTION_EXTENDED;
539 }
540 else
541 {
542 // if style was 0 set single mode
543 m_windowStyle |= wxLB_SINGLE;
544 mode = GTK_SELECTION_SINGLE;
545 }
546
547 gtk_tree_selection_set_mode( selection, mode );
548
549 //Handle sortable stuff
550 if(style & wxLB_SORT)
551 {
552 //Setup sorting in ascending (wx) order
553 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore),
554 WXLISTBOX_DATACOLUMN,
555 GTK_SORT_ASCENDING);
556
557 //Set the sort callback
558 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore),
559 WXLISTBOX_DATACOLUMN,
560 (GtkTreeIterCompareFunc) gtk_listbox_sort_callback,
561 this, //userdata
562 NULL //"destroy notifier"
563 );
564 }
565
566
567 gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) );
568
569 gtk_widget_show( GTK_WIDGET(m_treeview) );
570
571 wxListBox::DoInsertItems(wxArrayString(n, choices), 0); // insert initial items
572
573 //treeview-specific events
574 g_signal_connect(m_treeview, "row-activated",
575 G_CALLBACK(gtk_listbox_row_activated_callback), this);
576
577 // other events
578 g_signal_connect (m_treeview, "button_press_event",
579 G_CALLBACK (gtk_listbox_button_press_callback),
580 this);
581 g_signal_connect (m_treeview, "key_press_event",
582 G_CALLBACK (gtk_listbox_key_press_callback),
583 this);
584
585 m_parent->DoAddChild( this );
586
587 PostCreation(size);
588 SetBestSize(size); // need this too because this is a wxControlWithItems
589
590 return TRUE;
591 }
592
593 wxListBox::~wxListBox()
594 {
595 m_hasVMT = FALSE;
596
597 Clear();
598 }
599
600 // ----------------------------------------------------------------------------
601 // adding items
602 // ----------------------------------------------------------------------------
603
604 void wxListBox::GtkInsertItems(const wxArrayString& items,
605 void** clientData, int pos)
606 {
607 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
608
609 InvalidateBestSize();
610
611 // Create and set column ids and GValues
612
613 size_t nNum = items.GetCount();
614 int nCurCount = wxListBox::GetCount();
615 wxASSERT_MSG(pos <= nCurCount, wxT("Invalid index passed to wxListBox"));
616
617 GtkTreeIter* pIter = NULL; // append by default
618 GtkTreeIter iter;
619 if (pos != nCurCount)
620 {
621 gboolean res = gtk_tree_model_iter_nth_child(
622 GTK_TREE_MODEL(m_liststore),
623 &iter, NULL, //NULL = parent = get first
624 pos );
625 if(!res)
626 {
627 wxLogSysError(wxT("internal wxListBox error in insertion"));
628 return;
629 }
630
631 pIter = &iter;
632 }
633
634 for (size_t i = 0; i < nNum; ++i)
635 {
636 wxString label = items[i];
637
638 #if wxUSE_CHECKLISTBOX && !wxUSE_NATIVEGTKCHECKLIST
639 if (m_hasCheckBoxes)
640 {
641 label.Prepend(wxCHECKLBOX_STRING);
642 }
643 #endif // wxUSE_CHECKLISTBOX
644
645
646 GtkTreeEntry* entry = gtk_tree_entry_new();
647 gtk_tree_entry_set_label(entry, wxConvUTF8.cWX2MB(label));
648 gtk_tree_entry_set_destroy_func(entry,
649 (GtkTreeEntryDestroy)gtk_tree_entry_destroy_cb,
650 this);
651
652 if (clientData)
653 gtk_tree_entry_set_userdata(entry, clientData[i]);
654
655 GtkTreeIter itercur;
656 gtk_list_store_insert_before(m_liststore, &itercur, pIter);
657
658 #if wxUSE_CHECKLISTBOX && wxUSE_NATIVEGTKCHECKLIST
659 if (m_hasCheckBoxes)
660 {
661 gtk_list_store_set(m_liststore, &itercur,
662 0, FALSE, //FALSE == not toggled
663 1, entry, -1);
664 }
665 else
666 #endif
667 gtk_list_store_set(m_liststore, &itercur,
668 0, entry, -1);
669
670 g_object_unref(G_OBJECT(entry)); //liststore always refs :)
671 }
672 }
673
674 void wxListBox::DoInsertItems(const wxArrayString& items, int pos)
675 {
676 GtkInsertItems(items, NULL, pos);
677 }
678
679 int wxListBox::DoAppend( const wxString& item )
680 {
681 // Call DoInsertItems
682 int nWhere = wxListBox::GetCount();
683 wxArrayString aItems;
684 aItems.Add(item);
685 wxListBox::DoInsertItems(aItems, nWhere);
686 return nWhere;
687 }
688
689 void wxListBox::DoSetItems( const wxArrayString& items,
690 void **clientData)
691 {
692 Clear();
693 GtkInsertItems(items, clientData, 0);
694 }
695
696 // ----------------------------------------------------------------------------
697 // deleting items
698 // ----------------------------------------------------------------------------
699
700 void wxListBox::Clear()
701 {
702 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
703
704 InvalidateBestSize();
705
706 gtk_list_store_clear( m_liststore ); /* well, THAT was easy :) */
707 }
708
709 void wxListBox::Delete( int n )
710 {
711 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
712
713 InvalidateBestSize();
714
715 GtkTreeIter iter;
716 gboolean res = gtk_tree_model_iter_nth_child(
717 GTK_TREE_MODEL(m_liststore),
718 &iter, NULL, //NULL = parent = get first
719 n
720 );
721
722 wxCHECK_RET( res, wxT("wrong listbox index") );
723
724 //this returns false if iter is invalid (i.e. deleting item
725 //at end) but since we don't use iter, well... :)
726 gtk_list_store_remove(m_liststore, &iter);
727 }
728
729 // ----------------------------------------------------------------------------
730 // get GtkTreeEntry from position (note: you need to g_unref it if valid)
731 // ----------------------------------------------------------------------------
732
733 struct _GtkTreeEntry* wxListBox::GtkGetEntry(int n) const
734 {
735 GtkTreeIter iter;
736 gboolean res = gtk_tree_model_iter_nth_child(
737 GTK_TREE_MODEL(m_liststore),
738 &iter, NULL, //NULL = parent = get first
739 n );
740
741 if (!res)
742 {
743 wxLogDebug(wxT("gtk_tree_model_iter_nth_child failed\n")
744 wxT("Passed in value was:[%i] List size:[%i]"),
745 n, wxListBox::GetCount() );
746 return NULL;
747 }
748
749
750 GtkTreeEntry* entry = NULL;
751 gtk_tree_model_get(GTK_TREE_MODEL(m_liststore), &iter,
752 WXLISTBOX_DATACOLUMN, &entry, -1);
753
754 return entry;
755 }
756
757 // ----------------------------------------------------------------------------
758 // client data
759 // ----------------------------------------------------------------------------
760
761 void* wxListBox::DoGetItemClientData( int n ) const
762 {
763 wxCHECK_MSG( n >= 0 && n < wxListBox::GetCount(), NULL,
764 wxT("Invalid index passed to GetItemClientData") );
765
766 GtkTreeEntry* entry = GtkGetEntry(n);
767 wxCHECK_MSG(entry, NULL, wxT("could not get entry"));
768
769 void* userdata = gtk_tree_entry_get_userdata( entry );
770 g_object_unref(G_OBJECT(entry));
771 return userdata;
772 }
773
774 wxClientData* wxListBox::DoGetItemClientObject( int n ) const
775 {
776 return (wxClientData*) wxListBox::DoGetItemClientData(n);
777 }
778
779 void wxListBox::DoSetItemClientData( int n, void* clientData )
780 {
781 wxCHECK_RET( n >= 0 && n < wxListBox::GetCount(),
782 wxT("Invalid index passed to SetItemClientData") );
783
784 GtkTreeEntry* entry = GtkGetEntry(n);
785 wxCHECK_RET(entry, wxT("could not get entry"));
786
787 gtk_tree_entry_set_userdata( entry, clientData );
788 g_object_unref(G_OBJECT(entry));
789 }
790
791 void wxListBox::DoSetItemClientObject( int n, wxClientData* clientData )
792 {
793 // wxItemContainer already deletes data for us
794 wxListBox::DoSetItemClientData(n, (void*) clientData);
795 }
796
797 // ----------------------------------------------------------------------------
798 // string list access
799 // ----------------------------------------------------------------------------
800
801 void wxListBox::SetString( int n, const wxString &string )
802 {
803 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
804
805 GtkTreeEntry* entry = GtkGetEntry(n);
806 wxCHECK_RET( entry, wxT("wrong listbox index") );
807
808 wxString label = string;
809
810 #if wxUSE_CHECKLISTBOX && !wxUSE_NATIVEGTKCHECKLIST
811 if (m_hasCheckBoxes)
812 label.Prepend(wxCHECKLBOX_STRING);
813 #endif // wxUSE_CHECKLISTBOX
814
815 // RN: This may look wierd but the problem is that the TreeView
816 // doesn't resort or update when changed above and there is no real
817 // notification function...
818 void* userdata = gtk_tree_entry_get_userdata(entry);
819 gtk_tree_entry_set_userdata(entry, NULL); //don't delete on destroy
820 g_object_unref(G_OBJECT(entry));
821
822 bool bWasSelected = wxListBox::IsSelected(n);
823 wxListBox::Delete(n);
824
825 wxArrayString aItems;
826 aItems.Add(label);
827 GtkInsertItems(aItems, &userdata, n);
828 if (bWasSelected)
829 wxListBox::GtkSetSelection(n, TRUE, TRUE);
830 }
831
832 wxString wxListBox::GetString( int n ) const
833 {
834 wxCHECK_MSG( m_treeview != NULL, wxEmptyString, wxT("invalid listbox") );
835
836 GtkTreeEntry* entry = GtkGetEntry(n);
837 wxCHECK_MSG( entry, wxEmptyString, wxT("wrong listbox index") );
838
839 wxString label = wxGTK_CONV_BACK( gtk_tree_entry_get_label(entry) );
840
841 #if wxUSE_CHECKLISTBOX && !wxUSE_NATIVEGTKCHECKLIST
842 // checklistboxes have "[±] " prepended to their lables, remove it
843 //
844 // NB: 4 below is the length of wxCHECKLBOX_STRING from wx/gtk/checklst.h
845 if ( m_hasCheckBoxes )
846 label.erase(0, 4);
847 #endif // wxUSE_CHECKLISTBOX
848
849 g_object_unref(G_OBJECT(entry));
850 return label;
851 }
852
853 int wxListBox::GetCount() const
854 {
855 wxCHECK_MSG( m_treeview != NULL, -1, wxT("invalid listbox") );
856
857 return gtk_tree_model_iter_n_children(GTK_TREE_MODEL(m_liststore), NULL);
858 }
859
860 int wxListBox::FindString( const wxString &item, bool bCase ) const
861 {
862 wxCHECK_MSG( m_treeview != NULL, wxNOT_FOUND, wxT("invalid listbox") );
863
864 //Sort of hackish - maybe there is a faster way
865 int nCount = wxListBox::GetCount();
866
867 for(int i = 0; i < nCount; ++i)
868 {
869 if( item.IsSameAs( wxListBox::GetString(i), bCase ) )
870 return i;
871 }
872
873
874 // it's not an error if the string is not found -> no wxCHECK
875 return wxNOT_FOUND;
876 }
877
878 // ----------------------------------------------------------------------------
879 // selection
880 // ----------------------------------------------------------------------------
881
882 int wxListBox::GetSelection() const
883 {
884 wxCHECK_MSG( m_treeview != NULL, -1, wxT("invalid listbox"));
885 wxCHECK_MSG( HasFlag(wxLB_SINGLE), -1,
886 wxT("must be single selection listbox"));
887
888 GtkTreeIter iter;
889 GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
890
891 // only works on single-sel
892 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
893 return -1;
894
895 GtkTreePath* path =
896 gtk_tree_model_get_path(GTK_TREE_MODEL(m_liststore), &iter);
897
898 int sel = gtk_tree_path_get_indices(path)[0];
899
900 gtk_tree_path_free(path);
901
902 return sel;
903 }
904
905 int wxListBox::GetSelections( wxArrayInt& aSelections ) const
906 {
907 wxCHECK_MSG( m_treeview != NULL, -1, wxT("invalid listbox") );
908
909 aSelections.Empty();
910
911 int i = 0;
912 GtkTreeIter iter;
913 GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
914
915 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(m_liststore), &iter))
916 { //gtk_tree_selection_get_selected_rows is GTK 2.2+ so iter instead
917 do
918 {
919 if (gtk_tree_selection_iter_is_selected(selection, &iter))
920 aSelections.Add(i);
921
922 i++;
923 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(m_liststore), &iter));
924 }
925
926 return aSelections.GetCount();
927 }
928
929 bool wxListBox::IsSelected( int n ) const
930 {
931 wxCHECK_MSG( m_treeview != NULL, FALSE, wxT("invalid listbox") );
932
933 GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
934
935 GtkTreeIter iter;
936 gboolean res = gtk_tree_model_iter_nth_child(
937 GTK_TREE_MODEL(m_liststore),
938 &iter, NULL, //NULL = parent = get first
939 n );
940
941 wxCHECK_MSG( res, FALSE, wxT("Invalid index") );
942
943 return gtk_tree_selection_iter_is_selected(selection, &iter);
944 }
945
946 void wxListBox::DoSetSelection( int n, bool select )
947 {
948 return GtkSetSelection(n, select, TRUE); //docs say no events here
949 }
950
951 void wxListBox::GtkSetSelection(int n, const bool select, const bool blockEvent)
952 {
953 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
954
955 GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
956
957 GtkTreeIter iter;
958 gboolean res = gtk_tree_model_iter_nth_child(
959 GTK_TREE_MODEL(m_liststore),
960 &iter, NULL, //NULL = parent = get first
961 n
962 );
963 wxCHECK_RET( res, wxT("Invalid index") );
964
965 m_blockEvent = blockEvent;
966
967 if (select)
968 gtk_tree_selection_select_iter(selection, &iter);
969 else
970 gtk_tree_selection_unselect_iter(selection, &iter);
971
972 m_blockEvent = FALSE;
973 }
974
975 void wxListBox::DoSetFirstItem( int n )
976 {
977 wxCHECK_RET( m_treeview, wxT("invalid listbox") );
978 wxCHECK_RET( n >= 0 && n < wxListBox::GetCount(), wxT("invalid index"));
979
980 //RN: I have no idea why this line is needed...
981 if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (m_treeview))
982 return;
983
984 // terribly efficient (RN:???)
985 // RN: Note that evidently the vadjustment property "vadjustment" from
986 // GtkTreeView is different from the "gtk-vadjustment"...
987 // (i.e. gtk_tree_view_get_vadjustment)
988 const gchar *vadjustment_key = "gtk-vadjustment";
989 guint vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
990
991 GtkAdjustment *adjustment =
992 (GtkAdjustment*) g_object_get_qdata(G_OBJECT (m_treeview), vadjustment_key_id);
993 wxCHECK_RET( adjustment, wxT("invalid listbox code") );
994
995 // Get the greater of the item heights from each column
996 gint cellheight = 0, cellheightcur;
997 GList* columnlist = gtk_tree_view_get_columns(m_treeview);
998 GList* curlist = columnlist;
999
1000 while(curlist)
1001 {
1002 gtk_tree_view_column_cell_get_size(
1003 GTK_TREE_VIEW_COLUMN(curlist->data),
1004 NULL, NULL, NULL, NULL,
1005 &cellheightcur);
1006
1007 cellheight = cellheightcur > cellheight ?
1008 cellheightcur : cellheight;
1009
1010 curlist = curlist->next;
1011 }
1012
1013 g_list_free(columnlist);
1014
1015 float y = (float) (cellheight * n);
1016 if (y > adjustment->upper - adjustment->page_size)
1017 y = adjustment->upper - adjustment->page_size;
1018 gtk_adjustment_set_value( adjustment, y );
1019 }
1020
1021
1022 // ----------------------------------------------------------------------------
1023 // helpers
1024 // ----------------------------------------------------------------------------
1025
1026 #if wxUSE_TOOLTIPS
1027 void wxListBox::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
1028 {
1029 // RN: Is this needed anymore?
1030 gtk_tooltips_set_tip( tips, GTK_WIDGET( m_treeview ), wxGTK_CONV(tip), (gchar*) NULL );
1031 }
1032 #endif // wxUSE_TOOLTIPS
1033
1034 GtkWidget *wxListBox::GetConnectWidget()
1035 {
1036 // return GTK_WIDGET(m_treeview);
1037 return m_widget;
1038 }
1039
1040 bool wxListBox::IsOwnGtkWindow( GdkWindow *window )
1041 {
1042 return (window == gtk_tree_view_get_bin_window(m_treeview));
1043 }
1044
1045 void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
1046 {
1047 if (m_hasBgCol && m_backgroundColour.Ok())
1048 {
1049 GdkWindow *window = gtk_tree_view_get_bin_window(m_treeview);
1050 if (window)
1051 {
1052 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1053 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1054 gdk_window_clear( window );
1055 }
1056 }
1057
1058 gtk_widget_modify_style( GTK_WIDGET(m_treeview), style );
1059 }
1060
1061 void wxListBox::OnInternalIdle()
1062 {
1063 //RN: Is this needed anymore?
1064 wxCursor cursor = m_cursor;
1065 if (g_globalCursor.Ok()) cursor = g_globalCursor;
1066
1067 if (GTK_WIDGET(m_treeview)->window && cursor.Ok())
1068 {
1069 /* I now set the cursor the anew in every OnInternalIdle call
1070 as setting the cursor in a parent window also effects the
1071 windows above so that checking for the current cursor is
1072 not possible. */
1073 GdkWindow *window = gtk_tree_view_get_bin_window(m_treeview);
1074 gdk_window_set_cursor( window, cursor.GetCursor() );
1075 }
1076
1077 if (wxUpdateUIEvent::CanUpdate(this))
1078 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1079 }
1080
1081 wxSize wxListBox::DoGetBestSize() const
1082 {
1083 wxCHECK_MSG(m_treeview, wxDefaultSize, wxT("invalid tree view"));
1084
1085 int lbWidth;
1086 int lbHeight;
1087
1088 // Start with a minimum size that's not too small
1089 int cx, cy;
1090 GetTextExtent( wxT("X"), &cx, &cy);
1091 lbWidth += 3 * cx;
1092 lbHeight += 10;
1093
1094 // Get the visible area of the tree view (limit to the 10th item
1095 // so that it isn't too big)
1096 int count = GetCount();
1097 if (count)
1098 {
1099 int wLine;
1100
1101 // Find the widest line
1102 for(int i = 0; i < count; i++) {
1103 wxString str(GetString(i));
1104 GetTextExtent(str, &wLine, NULL);
1105 lbWidth = wxMax(lbWidth, wLine);
1106 }
1107
1108 lbWidth += 3 * cx;
1109
1110 // And just a bit more for the checkbox if present and then some
1111 // (these are rough guesses)
1112 #if wxUSE_CHECKLISTBOX && wxUSE_NATIVEGTKCHECKLIST
1113 if ( m_hasCheckBoxes )
1114 {
1115 lbWidth += 35;
1116 cy = cy > 25 ? cy : 25; // rough height of checkbox
1117 }
1118 #endif
1119
1120 // don't make the listbox too tall (limit height to around 10 items) but don't
1121 // make it too small neither
1122 lbHeight = (cy+4) * wxMin(wxMax(count, 3), 10);
1123 }
1124
1125 // Add room for the scrollbar
1126 lbWidth += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1127
1128 wxSize best(lbWidth, lbHeight);
1129 CacheBestSize(best);
1130 return best;
1131 }
1132
1133 // static
1134 wxVisualAttributes
1135 wxListBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1136 {
1137 return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new, true);
1138 }
1139
1140 #endif // wxUSE_LISTBOX