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


6045226d542c371bcf4613ed16a88619e12de808
[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
18 #ifndef WX_PRECOMP
19 #include "wx/dynarray.h"
20 #include "wx/intl.h"
21 #include "wx/log.h"
22 #include "wx/utils.h"
23 #include "wx/settings.h"
24 #include "wx/checklst.h"
25 #include "wx/arrstr.h"
26 #endif
27
28 #include "wx/gtk/private.h"
29 #include "wx/gtk/treeentry_gtk.h"
30
31 #if wxUSE_TOOLTIPS
32 #include "wx/tooltip.h"
33 #endif
34
35 #include <gtk/gtk.h>
36 #include <gdk/gdkkeysyms.h>
37
38 //-----------------------------------------------------------------------------
39 // data
40 //-----------------------------------------------------------------------------
41
42 extern bool g_blockEventsOnDrag;
43 extern bool g_blockEventsOnScroll;
44
45
46
47 //-----------------------------------------------------------------------------
48 // Macro to tell which row the strings are in (1 if native checklist, 0 if not)
49 //-----------------------------------------------------------------------------
50
51 #if wxUSE_CHECKLISTBOX
52 # define WXLISTBOX_DATACOLUMN_ARG(x) (x->m_hasCheckBoxes ? 1 : 0)
53 #else
54 # define WXLISTBOX_DATACOLUMN_ARG(x) (0)
55 #endif // wxUSE_CHECKLISTBOX
56
57 #define WXLISTBOX_DATACOLUMN WXLISTBOX_DATACOLUMN_ARG(this)
58
59 //-----------------------------------------------------------------------------
60 // "row-activated"
61 //-----------------------------------------------------------------------------
62
63 extern "C" {
64 static void
65 gtk_listbox_row_activated_callback(GtkTreeView * WXUNUSED(treeview),
66 GtkTreePath *path,
67 GtkTreeViewColumn * WXUNUSED(col),
68 wxListBox *listbox)
69 {
70 if (g_blockEventsOnDrag) return;
71 if (g_blockEventsOnScroll) return;
72
73 // This is triggered by either a double-click or a space press
74
75 int sel = gtk_tree_path_get_indices(path)[0];
76
77 wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, listbox->GetId() );
78 event.SetEventObject( listbox );
79
80 if (listbox->IsSelected(sel))
81 {
82 GtkTreeEntry* entry = listbox->GtkGetEntry(sel);
83
84 if (entry)
85 {
86 event.SetInt(sel);
87 event.SetString(wxConvUTF8.cMB2WX(gtk_tree_entry_get_label(entry)));
88
89 if ( listbox->HasClientObjectData() )
90 event.SetClientObject( (wxClientData*) gtk_tree_entry_get_userdata(entry) );
91 else if ( listbox->HasClientUntypedData() )
92 event.SetClientData( gtk_tree_entry_get_userdata(entry) );
93
94 g_object_unref (entry);
95 }
96 else
97 {
98 wxLogSysError(wxT("Internal error - could not get entry for double-click"));
99 event.SetInt(-1);
100 }
101 }
102 else
103 {
104 event.SetInt(-1);
105 }
106
107 listbox->HandleWindowEvent( event );
108 }
109 }
110
111 //-----------------------------------------------------------------------------
112 // "changed"
113 //-----------------------------------------------------------------------------
114
115 extern "C" {
116 static void
117 gtk_listitem_changed_callback(GtkTreeSelection * WXUNUSED(selection),
118 wxListBox *listbox )
119 {
120 if (g_blockEventsOnDrag) return;
121
122 wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, listbox->GetId() );
123 event.SetEventObject( listbox );
124
125 if (listbox->HasFlag(wxLB_MULTIPLE) || listbox->HasFlag(wxLB_EXTENDED))
126 {
127 wxArrayInt selections;
128 listbox->GetSelections( selections );
129
130 if (selections.GetCount() == 0)
131 {
132 // indicate that this is a deselection
133 event.SetExtraLong( 0 );
134 event.SetInt( -1 );
135
136 listbox->HandleWindowEvent( event );
137
138 return;
139 }
140 else
141 {
142 // indicate that this is a selection
143 event.SetExtraLong( 1 );
144 event.SetInt( selections[0] );
145
146 listbox->HandleWindowEvent( event );
147 }
148 }
149 else
150 {
151 int index = listbox->GetSelection();
152 if (index == wxNOT_FOUND)
153 {
154 // indicate that this is a deselection
155 event.SetExtraLong( 0 );
156 event.SetInt( -1 );
157
158 listbox->HandleWindowEvent( event );
159
160 return;
161 }
162 else
163 {
164 GtkTreeEntry* entry = listbox->GtkGetEntry( index );
165
166 // indicate that this is a selection
167 event.SetExtraLong( 1 );
168
169 event.SetInt( index );
170 event.SetString(wxConvUTF8.cMB2WX(gtk_tree_entry_get_label(entry)));
171
172 if ( listbox->HasClientObjectData() )
173 event.SetClientObject(
174 (wxClientData*) gtk_tree_entry_get_userdata(entry)
175 );
176 else if ( listbox->HasClientUntypedData() )
177 event.SetClientData( gtk_tree_entry_get_userdata(entry) );
178
179 listbox->HandleWindowEvent( event );
180
181 g_object_unref (entry);
182 }
183 }
184 }
185 }
186
187 //-----------------------------------------------------------------------------
188 // "key_press_event"
189 //-----------------------------------------------------------------------------
190
191 extern "C" {
192 static gint
193 gtk_listbox_key_press_callback( GtkWidget *WXUNUSED(widget),
194 GdkEventKey *gdk_event,
195 wxListBox *listbox )
196 {
197 if ((gdk_event->keyval == GDK_Return) ||
198 (gdk_event->keyval == GDK_ISO_Enter) ||
199 (gdk_event->keyval == GDK_KP_Enter))
200 {
201 int index = listbox->GetSelection();
202 if (index != wxNOT_FOUND)
203 {
204
205 wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, listbox->GetId() );
206 event.SetEventObject( listbox );
207
208 GtkTreeEntry* entry = listbox->GtkGetEntry( index );
209
210 // indicate that this is a selection
211 event.SetExtraLong( 1 );
212
213 event.SetInt( index );
214 event.SetString(wxConvUTF8.cMB2WX(gtk_tree_entry_get_label(entry)));
215
216 if ( listbox->HasClientObjectData() )
217 event.SetClientObject(
218 (wxClientData*) gtk_tree_entry_get_userdata(entry)
219 );
220 else if ( listbox->HasClientUntypedData() )
221 event.SetClientData( gtk_tree_entry_get_userdata(entry) );
222
223 /* bool ret = */ listbox->HandleWindowEvent( event );
224
225 g_object_unref (entry);
226
227 // wxMac and wxMSW always invoke default action
228 // if (!ret)
229 {
230 // DClick not handled -> invoke default action
231 wxWindow *tlw = wxGetTopLevelParent( listbox );
232 if (tlw)
233 {
234 GtkWindow *gtk_window = GTK_WINDOW( tlw->GetHandle() );
235 if (gtk_window)
236 gtk_window_activate_default( gtk_window );
237 }
238 }
239
240 // Always intercept, otherwise we'd get another dclick
241 // event from row_activated
242 return TRUE;
243 }
244 }
245
246 return FALSE;
247 }
248 }
249
250 //-----------------------------------------------------------------------------
251 // GtkTreeEntry destruction (to destroy client data)
252 //-----------------------------------------------------------------------------
253
254 extern "C" {
255 static void gtk_tree_entry_destroy_cb(GtkTreeEntry* entry,
256 wxListBox* listbox)
257 {
258 if (listbox->HasClientObjectData())
259 {
260 gpointer userdata = gtk_tree_entry_get_userdata(entry);
261 if (userdata)
262 delete (wxClientData *)userdata;
263 }
264 }
265 }
266
267 //-----------------------------------------------------------------------------
268 // Sorting callback (standard CmpNoCase return value)
269 //-----------------------------------------------------------------------------
270
271 extern "C" {
272 static gint gtk_listbox_sort_callback(GtkTreeModel * WXUNUSED(model),
273 GtkTreeIter *a,
274 GtkTreeIter *b,
275 wxListBox *listbox)
276 {
277 GtkTreeEntry* entry;
278 GtkTreeEntry* entry2;
279
280 gtk_tree_model_get(GTK_TREE_MODEL(listbox->m_liststore),
281 a,
282 WXLISTBOX_DATACOLUMN_ARG(listbox),
283 &entry, -1);
284 gtk_tree_model_get(GTK_TREE_MODEL(listbox->m_liststore),
285 b,
286 WXLISTBOX_DATACOLUMN_ARG(listbox),
287 &entry2, -1);
288 wxCHECK_MSG(entry, 0, wxT("Could not get entry"));
289 wxCHECK_MSG(entry2, 0, wxT("Could not get entry2"));
290
291 //We compare collate keys here instead of calling g_utf8_collate
292 //as it is rather slow (and even the docs reccommend this)
293 int ret = strcmp(gtk_tree_entry_get_collate_key(entry),
294 gtk_tree_entry_get_collate_key(entry2));
295
296 g_object_unref (entry);
297 g_object_unref (entry2);
298
299 return ret;
300 }
301 }
302
303 //-----------------------------------------------------------------------------
304 // Searching callback (TRUE == not equal, FALSE == equal)
305 //-----------------------------------------------------------------------------
306
307 extern "C" {
308 static gboolean gtk_listbox_searchequal_callback(GtkTreeModel * WXUNUSED(model),
309 gint WXUNUSED(column),
310 const gchar* key,
311 GtkTreeIter* iter,
312 wxListBox* listbox)
313 {
314 GtkTreeEntry* entry;
315
316 gtk_tree_model_get(GTK_TREE_MODEL(listbox->m_liststore),
317 iter,
318 WXLISTBOX_DATACOLUMN_ARG(listbox),
319 &entry, -1);
320 wxCHECK_MSG(entry, 0, wxT("Could not get entry"));
321 wxGtkString keycollatekey(g_utf8_collate_key(key, -1));
322
323 int ret = strcmp(keycollatekey,
324 gtk_tree_entry_get_collate_key(entry));
325
326 g_object_unref (entry);
327
328 return ret != 0;
329 }
330 }
331
332 //-----------------------------------------------------------------------------
333 // wxListBox
334 //-----------------------------------------------------------------------------
335
336 IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControlWithItems)
337
338 // ----------------------------------------------------------------------------
339 // construction
340 // ----------------------------------------------------------------------------
341
342 void wxListBox::Init()
343 {
344 m_treeview = (GtkTreeView*) NULL;
345 #if wxUSE_CHECKLISTBOX
346 m_hasCheckBoxes = false;
347 #endif // wxUSE_CHECKLISTBOX
348 }
349
350 bool wxListBox::Create( wxWindow *parent, wxWindowID id,
351 const wxPoint &pos, const wxSize &size,
352 const wxArrayString& choices,
353 long style, const wxValidator& validator,
354 const wxString &name )
355 {
356 wxCArrayString chs(choices);
357
358 return Create( parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
359 style, validator, name );
360 }
361
362 bool wxListBox::Create( wxWindow *parent, wxWindowID id,
363 const wxPoint &pos, const wxSize &size,
364 int n, const wxString choices[],
365 long style, const wxValidator& validator,
366 const wxString &name )
367 {
368 if (!PreCreation( parent, pos, size ) ||
369 !CreateBase( parent, id, pos, size, style, validator, name ))
370 {
371 wxFAIL_MSG( wxT("wxListBox creation failed") );
372 return false;
373 }
374
375 m_widget = gtk_scrolled_window_new( (GtkAdjustment*) NULL, (GtkAdjustment*) NULL );
376 if (style & wxLB_ALWAYS_SB)
377 {
378 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
379 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
380 }
381 else
382 {
383 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
384 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
385 }
386
387
388 GtkScrolledWindowSetBorder(m_widget, style);
389
390 m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) );
391
392 //wxListBox doesn't have a header :)
393 //NB: If enabled SetFirstItem doesn't work correctly
394 gtk_tree_view_set_headers_visible(m_treeview, FALSE);
395
396 #if wxUSE_CHECKLISTBOX
397 if(m_hasCheckBoxes)
398 ((wxCheckListBox*)this)->DoCreateCheckList();
399 #endif // wxUSE_CHECKLISTBOX
400
401 // Create the data column
402 gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "",
403 gtk_cell_renderer_text_new(),
404 "text",
405 WXLISTBOX_DATACOLUMN, NULL);
406
407 // Now create+set the model (GtkListStore) - first argument # of columns
408 #if wxUSE_CHECKLISTBOX
409 if(m_hasCheckBoxes)
410 m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN,
411 GTK_TYPE_TREE_ENTRY);
412 else
413 #endif
414 m_liststore = gtk_list_store_new(1, GTK_TYPE_TREE_ENTRY);
415
416 gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore));
417
418 g_object_unref (m_liststore); //free on treeview destruction
419
420 // Disable the pop-up textctrl that enables searching - note that
421 // the docs specify that even if this disabled (which we are doing)
422 // the user can still have it through the start-interactive-search
423 // key binding...either way we want to provide a searchequal callback
424 // NB: If this is enabled a doubleclick event (activate) gets sent
425 // on a successful search
426 gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN);
427 gtk_tree_view_set_search_equal_func(m_treeview,
428 (GtkTreeViewSearchEqualFunc) gtk_listbox_searchequal_callback,
429 this,
430 NULL);
431
432 gtk_tree_view_set_enable_search(m_treeview, FALSE);
433
434 GtkSelectionMode mode;
435 if (style & wxLB_MULTIPLE)
436 {
437 mode = GTK_SELECTION_MULTIPLE;
438 }
439 else if (style & wxLB_EXTENDED)
440 {
441 mode = GTK_SELECTION_EXTENDED;
442 }
443 else
444 {
445 // if style was 0 set single mode
446 m_windowStyle |= wxLB_SINGLE;
447 mode = GTK_SELECTION_SINGLE;
448 }
449
450 GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview );
451 gtk_tree_selection_set_mode( selection, mode );
452
453 // Handle sortable stuff
454 if(HasFlag(wxLB_SORT))
455 {
456 // Setup sorting in ascending (wx) order
457 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore),
458 WXLISTBOX_DATACOLUMN,
459 GTK_SORT_ASCENDING);
460
461 // Set the sort callback
462 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore),
463 WXLISTBOX_DATACOLUMN,
464 (GtkTreeIterCompareFunc) gtk_listbox_sort_callback,
465 this, //userdata
466 NULL //"destroy notifier"
467 );
468 }
469
470
471 gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) );
472
473 gtk_widget_show( GTK_WIDGET(m_treeview) );
474 m_focusWidget = GTK_WIDGET(m_treeview);
475
476 Append(n, choices); // insert initial items
477
478 // generate dclick events
479 g_signal_connect_after(m_treeview, "row-activated",
480 G_CALLBACK(gtk_listbox_row_activated_callback), this);
481
482 // for intercepting dclick generation by <ENTER>
483 g_signal_connect (m_treeview, "key_press_event",
484 G_CALLBACK (gtk_listbox_key_press_callback),
485 this);
486 m_parent->DoAddChild( this );
487
488 PostCreation(size);
489 SetInitialSize(size); // need this too because this is a wxControlWithItems
490
491 g_signal_connect_after (selection, "changed",
492 G_CALLBACK (gtk_listitem_changed_callback), this);
493
494 return true;
495 }
496
497 wxListBox::~wxListBox()
498 {
499 m_hasVMT = false;
500
501 Clear();
502 }
503
504 void wxListBox::GtkDisableEvents()
505 {
506 GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview );
507
508 g_signal_handlers_block_by_func(selection,
509 (gpointer) gtk_listitem_changed_callback, this);
510 }
511
512 void wxListBox::GtkEnableEvents()
513 {
514 GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview );
515
516 g_signal_handlers_unblock_by_func(selection,
517 (gpointer) gtk_listitem_changed_callback, this);
518
519 GtkUpdateOldSelection();
520 }
521
522 // ----------------------------------------------------------------------------
523 // adding items
524 // ----------------------------------------------------------------------------
525
526 int wxListBox::DoInsertItems(const wxArrayStringsAdapter& items,
527 unsigned int pos,
528 void **clientData,
529 wxClientDataType type)
530 {
531 wxCHECK_MSG( m_treeview != NULL, wxNOT_FOUND, wxT("invalid listbox") );
532
533 InvalidateBestSize();
534
535 GtkTreeIter* pIter = NULL; // append by default
536 GtkTreeIter iter;
537 if ( pos != GetCount() )
538 {
539 wxCHECK_MSG( GtkGetIteratorFor(pos, &iter), wxNOT_FOUND,
540 wxT("internal wxListBox error in insertion") );
541
542 pIter = &iter;
543 }
544
545 const unsigned int numItems = items.GetCount();
546 for ( unsigned int i = 0; i < numItems; ++i )
547 {
548 GtkTreeEntry* entry = gtk_tree_entry_new();
549 gtk_tree_entry_set_label(entry, wxGTK_CONV(items[i]));
550 gtk_tree_entry_set_destroy_func(entry,
551 (GtkTreeEntryDestroy)gtk_tree_entry_destroy_cb,
552 this);
553
554 GtkTreeIter itercur;
555 gtk_list_store_insert_before(m_liststore, &itercur, pIter);
556
557 GtkSetItem(itercur, entry);
558
559 g_object_unref (entry);
560
561 if (clientData)
562 AssignNewItemClientData(GtkGetIndexFor(itercur), clientData, i, type);
563 }
564
565 return pos + numItems - 1;
566 }
567
568 // ----------------------------------------------------------------------------
569 // deleting items
570 // ----------------------------------------------------------------------------
571
572 void wxListBox::DoClear()
573 {
574 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
575
576 InvalidateBestSize();
577
578 gtk_list_store_clear( m_liststore ); /* well, THAT was easy :) */
579 }
580
581 void wxListBox::DoDeleteOneItem(unsigned int n)
582 {
583 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
584
585 InvalidateBestSize();
586
587 GtkTreeIter iter;
588 wxCHECK_RET( GtkGetIteratorFor(n, &iter), wxT("wrong listbox index") );
589
590 // this returns false if iter is invalid (e.g. deleting item at end) but
591 // since we don't use iter, we ignore the return value
592 gtk_list_store_remove(m_liststore, &iter);
593 }
594
595 // ----------------------------------------------------------------------------
596 // helper functions for working with iterators
597 // ----------------------------------------------------------------------------
598
599 bool wxListBox::GtkGetIteratorFor(unsigned pos, GtkTreeIter *iter) const
600 {
601 if ( !gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(m_liststore),
602 iter, NULL, pos) )
603 {
604 wxLogDebug(wxT("gtk_tree_model_iter_nth_child(%u) failed"), pos);
605 return false;
606 }
607
608 return true;
609 }
610
611 int wxListBox::GtkGetIndexFor(GtkTreeIter& iter) const
612 {
613 GtkTreePath *path =
614 gtk_tree_model_get_path(GTK_TREE_MODEL(m_liststore), &iter);
615
616 gint* pIntPath = gtk_tree_path_get_indices(path);
617
618 wxCHECK_MSG( pIntPath, wxNOT_FOUND, _T("failed to get iterator path") );
619
620 int idx = pIntPath[0];
621
622 gtk_tree_path_free( path );
623
624 return idx;
625 }
626
627 // get GtkTreeEntry from position (note: you need to g_unref it if valid)
628 GtkTreeEntry *wxListBox::GtkGetEntry(unsigned n) const
629 {
630 GtkTreeIter iter;
631 if ( !GtkGetIteratorFor(n, &iter) )
632 return NULL;
633
634
635 GtkTreeEntry* entry = NULL;
636 gtk_tree_model_get(GTK_TREE_MODEL(m_liststore), &iter,
637 WXLISTBOX_DATACOLUMN, &entry, -1);
638
639 return entry;
640 }
641
642 void wxListBox::GtkSetItem(GtkTreeIter& iter, const GtkTreeEntry *entry)
643 {
644 #if wxUSE_CHECKLISTBOX
645 if ( m_hasCheckBoxes )
646 {
647 gtk_list_store_set(m_liststore, &iter,
648 0, FALSE, // FALSE == not toggled
649 1, entry,
650 -1);
651 }
652 else
653 #endif // wxUSE_CHECKLISTBOX
654 {
655 gtk_list_store_set(m_liststore, &iter, 0, entry, -1);
656 }
657 }
658
659 // ----------------------------------------------------------------------------
660 // client data
661 // ----------------------------------------------------------------------------
662
663 void* wxListBox::DoGetItemClientData(unsigned int n) const
664 {
665 wxCHECK_MSG( IsValid(n), NULL,
666 wxT("Invalid index passed to GetItemClientData") );
667
668 GtkTreeEntry* entry = GtkGetEntry(n);
669 wxCHECK_MSG(entry, NULL, wxT("could not get entry"));
670
671 void* userdata = gtk_tree_entry_get_userdata( entry );
672 g_object_unref (entry);
673 return userdata;
674 }
675
676 void wxListBox::DoSetItemClientData(unsigned int n, void* clientData)
677 {
678 wxCHECK_RET( IsValid(n),
679 wxT("Invalid index passed to SetItemClientData") );
680
681 GtkTreeEntry* entry = GtkGetEntry(n);
682 wxCHECK_RET(entry, wxT("could not get entry"));
683
684 gtk_tree_entry_set_userdata( entry, clientData );
685 g_object_unref (entry);
686 }
687
688 // ----------------------------------------------------------------------------
689 // string list access
690 // ----------------------------------------------------------------------------
691
692 void wxListBox::SetString(unsigned int n, const wxString& label)
693 {
694 wxCHECK_RET( IsValid(n), wxT("invalid index in wxListBox::SetString") );
695 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
696
697 GtkTreeEntry* entry = GtkGetEntry(n);
698 wxCHECK_RET( entry, wxT("wrong listbox index") );
699
700 // update the item itself
701 gtk_tree_entry_set_label(entry, wxGTK_CONV(label));
702
703 // and update the model which will refresh the tree too
704 GtkTreeIter iter;
705 wxCHECK_RET( GtkGetIteratorFor(n, &iter), _T("failed to get iterator") );
706
707 // FIXME: this resets the checked status of a wxCheckListBox item
708
709 GtkSetItem(iter, entry);
710 }
711
712 wxString wxListBox::GetString(unsigned int n) const
713 {
714 wxCHECK_MSG( m_treeview != NULL, wxEmptyString, wxT("invalid listbox") );
715
716 GtkTreeEntry* entry = GtkGetEntry(n);
717 wxCHECK_MSG( entry, wxEmptyString, wxT("wrong listbox index") );
718
719 wxString label = wxGTK_CONV_BACK( gtk_tree_entry_get_label(entry) );
720
721 g_object_unref (entry);
722 return label;
723 }
724
725 unsigned int wxListBox::GetCount() const
726 {
727 wxCHECK_MSG( m_treeview != NULL, 0, wxT("invalid listbox") );
728
729 return (unsigned int)gtk_tree_model_iter_n_children(GTK_TREE_MODEL(m_liststore), NULL);
730 }
731
732 int wxListBox::FindString( const wxString &item, bool bCase ) const
733 {
734 wxCHECK_MSG( m_treeview != NULL, wxNOT_FOUND, wxT("invalid listbox") );
735
736 //Sort of hackish - maybe there is a faster way
737 unsigned int nCount = wxListBox::GetCount();
738
739 for(unsigned int i = 0; i < nCount; ++i)
740 {
741 if( item.IsSameAs( wxListBox::GetString(i), bCase ) )
742 return (int)i;
743 }
744
745
746 // it's not an error if the string is not found -> no wxCHECK
747 return wxNOT_FOUND;
748 }
749
750 // ----------------------------------------------------------------------------
751 // selection
752 // ----------------------------------------------------------------------------
753
754 int wxListBox::GetSelection() const
755 {
756 wxCHECK_MSG( m_treeview != NULL, wxNOT_FOUND, wxT("invalid listbox"));
757 wxCHECK_MSG( HasFlag(wxLB_SINGLE), wxNOT_FOUND,
758 wxT("must be single selection listbox"));
759
760 GtkTreeIter iter;
761 GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
762
763 // only works on single-sel
764 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
765 return wxNOT_FOUND;
766
767 return GtkGetIndexFor(iter);
768 }
769
770 int wxListBox::GetSelections( wxArrayInt& aSelections ) const
771 {
772 wxCHECK_MSG( m_treeview != NULL, wxNOT_FOUND, wxT("invalid listbox") );
773
774 aSelections.Empty();
775
776 int i = 0;
777 GtkTreeIter iter;
778 GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
779
780 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(m_liststore), &iter))
781 { //gtk_tree_selection_get_selected_rows is GTK 2.2+ so iter instead
782 do
783 {
784 if (gtk_tree_selection_iter_is_selected(selection, &iter))
785 aSelections.Add(i);
786
787 i++;
788 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(m_liststore), &iter));
789 }
790
791 return aSelections.GetCount();
792 }
793
794 bool wxListBox::IsSelected( int n ) const
795 {
796 wxCHECK_MSG( m_treeview != NULL, false, wxT("invalid listbox") );
797
798 GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
799
800 GtkTreeIter iter;
801 wxCHECK_MSG( GtkGetIteratorFor(n, &iter), false, wxT("Invalid index") );
802
803 return gtk_tree_selection_iter_is_selected(selection, &iter);
804 }
805
806 void wxListBox::DoSetSelection( int n, bool select )
807 {
808 wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
809
810 GtkDisableEvents();
811
812 GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
813
814 // passing -1 to SetSelection() is documented to deselect all items
815 if ( n == wxNOT_FOUND )
816 {
817 gtk_tree_selection_unselect_all(selection);
818 GtkEnableEvents();
819 return;
820 }
821
822 wxCHECK_RET( IsValid(n), wxT("invalid index in wxListBox::SetSelection") );
823
824
825 GtkTreeIter iter;
826 wxCHECK_RET( GtkGetIteratorFor(n, &iter), wxT("Invalid index") );
827
828 if (select)
829 gtk_tree_selection_select_iter(selection, &iter);
830 else
831 gtk_tree_selection_unselect_iter(selection, &iter);
832
833 GtkTreePath* path = gtk_tree_model_get_path(
834 GTK_TREE_MODEL(m_liststore), &iter);
835
836 gtk_tree_view_scroll_to_cell(m_treeview, path, NULL, FALSE, 0.0f, 0.0f);
837
838 gtk_tree_path_free(path);
839
840 GtkEnableEvents();
841 }
842
843 void wxListBox::GtkUpdateOldSelection()
844 {
845 if (HasFlag(wxLB_MULTIPLE))
846 GetSelections( m_oldSelection );
847 }
848
849 void wxListBox::DoScrollToCell(int n, float alignY, float alignX)
850 {
851 wxCHECK_RET( m_treeview, wxT("invalid listbox") );
852 wxCHECK_RET( IsValid(n), wxT("invalid index"));
853
854 //RN: I have no idea why this line is needed...
855 if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (m_treeview))
856 return;
857
858 GtkTreeIter iter;
859 if ( !GtkGetIteratorFor(n, &iter) )
860 return;
861
862 GtkTreePath* path = gtk_tree_model_get_path(
863 GTK_TREE_MODEL(m_liststore), &iter);
864
865 // Scroll to the desired cell (0.0 == topleft alignment)
866 gtk_tree_view_scroll_to_cell(m_treeview, path, NULL,
867 TRUE, alignY, alignX);
868
869 gtk_tree_path_free(path);
870 }
871
872 void wxListBox::DoSetFirstItem(int n)
873 {
874 DoScrollToCell(n, 0, 0);
875 }
876
877 void wxListBox::EnsureVisible(int n)
878 {
879 DoScrollToCell(n, 0.5, 0);
880 }
881
882 // ----------------------------------------------------------------------------
883 // hittest
884 // ----------------------------------------------------------------------------
885
886 int wxListBox::DoListHitTest(const wxPoint& point) const
887 {
888 // gtk_tree_view_get_path_at_pos() also gets items that are not visible and
889 // we only want visible items we need to check for it manually here
890 if ( !GetClientRect().Contains(point) )
891 return wxNOT_FOUND;
892
893 // need to translate from master window since it is in client coords
894 gint binx, biny;
895 gdk_window_get_geometry(gtk_tree_view_get_bin_window(m_treeview),
896 &binx, &biny, NULL, NULL, NULL);
897
898 GtkTreePath* path;
899 if ( !gtk_tree_view_get_path_at_pos
900 (
901 m_treeview,
902 point.x - binx,
903 point.y - biny,
904 &path,
905 NULL, // [out] column (always 0 here)
906 NULL, // [out] x-coord relative to the cell (not interested)
907 NULL // [out] y-coord relative to the cell
908 ) )
909 {
910 return wxNOT_FOUND;
911 }
912
913 int index = gtk_tree_path_get_indices(path)[0];
914 gtk_tree_path_free(path);
915
916 return index;
917 }
918
919 // ----------------------------------------------------------------------------
920 // helpers
921 // ----------------------------------------------------------------------------
922
923 #if wxUSE_TOOLTIPS
924 void wxListBox::ApplyToolTip( GtkTooltips *tips, const gchar *tip )
925 {
926 // RN: Is this needed anymore?
927 gtk_tooltips_set_tip( tips, GTK_WIDGET( m_treeview ), tip, (gchar*) NULL );
928 }
929 #endif // wxUSE_TOOLTIPS
930
931 GtkWidget *wxListBox::GetConnectWidget()
932 {
933 // the correct widget for listbox events (such as mouse clicks for example)
934 // is m_treeview, not the parent scrolled window
935 return GTK_WIDGET(m_treeview);
936 }
937
938 GdkWindow *wxListBox::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
939 {
940 return gtk_tree_view_get_bin_window(m_treeview);
941 }
942
943 void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
944 {
945 if (m_hasBgCol && m_backgroundColour.Ok())
946 {
947 GdkWindow *window = gtk_tree_view_get_bin_window(m_treeview);
948 if (window)
949 {
950 m_backgroundColour.CalcPixel( gdk_drawable_get_colormap( window ) );
951 gdk_window_set_background( window, m_backgroundColour.GetColor() );
952 gdk_window_clear( window );
953 }
954 }
955
956 gtk_widget_modify_style( GTK_WIDGET(m_treeview), style );
957 }
958
959 wxSize wxListBox::DoGetBestSize() const
960 {
961 wxCHECK_MSG(m_treeview, wxDefaultSize, wxT("invalid tree view"));
962
963 // Start with a minimum size that's not too small
964 int cx, cy;
965 GetTextExtent( wxT("X"), &cx, &cy);
966 int lbWidth = 0;
967 int lbHeight = 10;
968
969 // Find the widest string.
970 const unsigned int count = GetCount();
971 if ( count )
972 {
973 int wLine;
974 for ( unsigned int i = 0; i < count; i++ )
975 {
976 GetTextExtent(GetString(i), &wLine, NULL);
977 if ( wLine > lbWidth )
978 lbWidth = wLine;
979 }
980 }
981
982 lbWidth += 3 * cx;
983
984 // And just a bit more for the checkbox if present and then some
985 // (these are rough guesses)
986 #if wxUSE_CHECKLISTBOX
987 if ( m_hasCheckBoxes )
988 {
989 lbWidth += 35;
990 cy = cy > 25 ? cy : 25; // rough height of checkbox
991 }
992 #endif
993
994 // Add room for the scrollbar
995 lbWidth += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
996
997 // Don't make the listbox too tall but don't make it too small neither
998 lbHeight = (cy+4) * wxMin(wxMax(count, 3), 10);
999
1000 wxSize best(lbWidth, lbHeight);
1001 CacheBestSize(best);
1002 return best;
1003 }
1004
1005 // static
1006 wxVisualAttributes
1007 wxListBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1008 {
1009 return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new, true);
1010 }
1011
1012 #endif // wxUSE_LISTBOX
wxWidgets (Impactor)