]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/listbox.cpp
projects / wxWidgets.git / blob
? search:


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