projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
support for GTK3
[wxWidgets.git] / src / gtk / dataview.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/dataview.cpp
3 // Purpose: wxDataViewCtrl GTK+2 implementation
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #if wxUSE_DATAVIEWCTRL
14
15 #include "wx/dataview.h"
16
17 #ifndef wxUSE_GENERICDATAVIEWCTRL
18
19 #ifndef WX_PRECOMP
20 #include "wx/log.h"
21 #include "wx/dcclient.h"
22 #include "wx/sizer.h"
23 #include "wx/settings.h"
24 #include "wx/crt.h"
25 #endif
26
27 #include "wx/stockitem.h"
28 #include "wx/popupwin.h"
29 #include "wx/listimpl.cpp"
30
31 #include "wx/gtk/dc.h"
32 #ifndef __WXGTK3__
33 #include "wx/gtk/dcclient.h"
34 #endif
35
36 #include <gtk/gtk.h>
37 #include "wx/gtk/private.h"
38 #include "wx/gtk/private/event.h"
39 #include "wx/gtk/private/gdkconv.h"
40 #include "wx/gtk/private/gtk2-compat.h"
41 #include "wx/gtk/private/list.h"
42 using namespace wxGTKImpl;
43
44 class wxGtkDataViewModelNotifier;
45
46 #ifdef __WXGTK3__
47 #define wxConstGdkRect const GdkRectangle
48 #else
49 #define wxConstGdkRect GdkRectangle
50 #endif
51
52 //-----------------------------------------------------------------------------
53 //-----------------------------------------------------------------------------
54
55 static wxDataViewCtrlInternal *gs_internal = NULL;
56
57 class wxGtkTreeModelNode;
58
59 extern "C" {
60 typedef struct _GtkWxTreeModel GtkWxTreeModel;
61 }
62
63 // ----------------------------------------------------------------------------
64 // wxGtkTreePath: self-destroying GtkTreePath
65 // ----------------------------------------------------------------------------
66
67 // Usually this object is initialized with the associated GtkTreePath
68 // immediately when it's constructed but it can also be changed later either by
69 // using Assign() or by getting the pointer to the internally stored pointer
70 // value using ByRef(). The latter should be avoided but is very convenient
71 // when using GTK functions with GtkTreePath output parameters.
72 class wxGtkTreePath
73 {
74 public:
75 // Ctor takes ownership of the given path and will free it if non-NULL.
76 wxGtkTreePath(GtkTreePath *path = NULL) : m_path(path) { }
77
78 // Creates a tree path for the given string path.
79 wxGtkTreePath(const gchar *strpath)
80 : m_path(gtk_tree_path_new_from_string(strpath))
81 {
82 }
83
84 // Set the stored pointer if not done by ctor.
85 void Assign(GtkTreePath *path)
86 {
87 wxASSERT_MSG( !m_path, "shouldn't be already initialized" );
88
89 m_path = path;
90 }
91
92 // Return the pointer to the internally stored pointer. This should only be
93 // used to initialize the object by passing it to some GTK function.
94 GtkTreePath **ByRef()
95 {
96 wxASSERT_MSG( !m_path, "shouldn't be already initialized" );
97
98 return &m_path;
99 }
100
101
102 operator GtkTreePath *() const { return m_path; }
103
104 ~wxGtkTreePath() { if ( m_path ) gtk_tree_path_free(m_path); }
105
106 private:
107 GtkTreePath *m_path;
108
109 wxDECLARE_NO_COPY_CLASS(wxGtkTreePath);
110 };
111
112 // ----------------------------------------------------------------------------
113 // wxGtkTreePathList: self-destroying list of GtkTreePath objects.
114 // ----------------------------------------------------------------------------
115
116 class wxGtkTreePathList : public wxGtkList
117 {
118 public:
119 // Ctor takes ownership of the list.
120 explicit wxGtkTreePathList(GList* list)
121 : wxGtkList(list)
122 {
123 }
124
125 ~wxGtkTreePathList()
126 {
127 // Delete the list contents, wxGtkList will delete the list itself.
128 g_list_foreach(m_list, (GFunc)gtk_tree_path_free, NULL);
129 }
130 };
131
132 // ----------------------------------------------------------------------------
133 // wxGtkTreeSelectionLock: prevent selection from changing during the
134 // lifetime of this object
135 // ----------------------------------------------------------------------------
136
137 // Implementation note: it could be expected that setting the selection
138 // function in this class ctor and resetting it back to the old value in its
139 // dtor would work. However currently gtk_tree_selection_get_select_function()
140 // can't be passed NULL (see https://bugzilla.gnome.org/show_bug.cgi?id=626276)
141 // so we can't do this. Instead, we always use the selection function (which
142 // imposes extra overhead, albeit minimal one, on all selection operations) and
143 // just set/reset the flag telling it whether it should allow or forbid the
144 // selection.
145 //
146 // Also notice that currently only a single object of this class may exist at
147 // any given moment. It's just simpler like this and we don't need anything
148 // more for now.
149
150 extern "C" {
151 static
152 gboolean wxdataview_selection_func(GtkTreeSelection * WXUNUSED(selection),
153 GtkTreeModel * WXUNUSED(model),
154 GtkTreePath * WXUNUSED(path),
155 gboolean WXUNUSED(path_currently_selected),
156 gpointer data)
157 {
158 return data == NULL;
159 }
160 }
161
162 class wxGtkTreeSelectionLock
163 {
164 public:
165 wxGtkTreeSelectionLock(GtkTreeSelection *selection)
166 : m_selection(selection)
167 {
168 wxASSERT_MSG( !ms_instance, "this class is not reentrant currently" );
169
170 ms_instance = this;
171
172 CheckCurrentSelectionFunc(NULL);
173
174 // Pass some non-NULL pointer as "data" for the callback, it doesn't
175 // matter what it is as long as it's non-NULL.
176 gtk_tree_selection_set_select_function(selection,
177 wxdataview_selection_func,
178 this,
179 NULL);
180 }
181
182 ~wxGtkTreeSelectionLock()
183 {
184 CheckCurrentSelectionFunc(wxdataview_selection_func);
185
186 gtk_tree_selection_set_select_function(m_selection,
187 wxdataview_selection_func,
188 NULL,
189 NULL);
190
191 ms_instance = NULL;
192 }
193
194 private:
195 void CheckCurrentSelectionFunc(GtkTreeSelectionFunc func)
196 {
197 // We can only use gtk_tree_selection_get_select_function() with 2.14+
198 // so check for its availability both during compile- and run-time.
199 #if GTK_CHECK_VERSION(2, 14, 0)
200 #ifndef __WXGTK3__
201 if ( gtk_check_version(2, 14, 0) != NULL )
202 return;
203 #endif
204
205 // If this assert is triggered, it means the code elsewhere has called
206 // gtk_tree_selection_set_select_function() but currently doing this
207 // breaks this class so the code here needs to be changed.
208 wxASSERT_MSG
209 (
210 gtk_tree_selection_get_select_function(m_selection) == func,
211 "selection function has changed unexpectedly, review this code!"
212 );
213 #endif // GTK+ 2.14+
214
215 wxUnusedVar(func);
216 }
217
218 static wxGtkTreeSelectionLock *ms_instance;
219
220 GtkTreeSelection * const m_selection;
221
222 wxDECLARE_NO_COPY_CLASS(wxGtkTreeSelectionLock);
223 };
224
225 wxGtkTreeSelectionLock *wxGtkTreeSelectionLock::ms_instance = NULL;
226
227 //-----------------------------------------------------------------------------
228 // wxDataViewCtrlInternal
229 //-----------------------------------------------------------------------------
230
231 WX_DECLARE_LIST(wxDataViewItem, ItemList);
232 WX_DEFINE_LIST(ItemList)
233
234 class wxDataViewCtrlInternal
235 {
236 public:
237 wxDataViewCtrlInternal( wxDataViewCtrl *owner, wxDataViewModel *wx_model );
238 ~wxDataViewCtrlInternal();
239
240 // model iface
241 GtkTreeModelFlags get_flags();
242 gboolean get_iter( GtkTreeIter *iter, GtkTreePath *path );
243 GtkTreePath *get_path( GtkTreeIter *iter);
244 gboolean iter_next( GtkTreeIter *iter );
245 gboolean iter_children( GtkTreeIter *iter, GtkTreeIter *parent);
246 gboolean iter_has_child( GtkTreeIter *iter );
247 gint iter_n_children( GtkTreeIter *iter );
248 gboolean iter_nth_child( GtkTreeIter *iter, GtkTreeIter *parent, gint n );
249 gboolean iter_parent( GtkTreeIter *iter, GtkTreeIter *child );
250
251 // dnd iface
252
253 bool EnableDragSource( const wxDataFormat &format );
254 bool EnableDropTarget( const wxDataFormat &format );
255
256 gboolean row_draggable( GtkTreeDragSource *drag_source, GtkTreePath *path );
257 gboolean drag_data_delete( GtkTreeDragSource *drag_source, GtkTreePath* path );
258 gboolean drag_data_get( GtkTreeDragSource *drag_source, GtkTreePath *path,
259 GtkSelectionData *selection_data );
260 gboolean drag_data_received( GtkTreeDragDest *drag_dest, GtkTreePath *dest,
261 GtkSelectionData *selection_data );
262 gboolean row_drop_possible( GtkTreeDragDest *drag_dest, GtkTreePath *dest_path,
263 GtkSelectionData *selection_data );
264
265 // notifactions from wxDataViewModel
266 bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
267 bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
268 bool ItemChanged( const wxDataViewItem &item );
269 bool ValueChanged( const wxDataViewItem &item, unsigned int model_column );
270 bool Cleared();
271 bool BeforeReset();
272 bool AfterReset();
273 void Resort();
274
275 // sorting interface
276 void SetSortOrder( GtkSortType sort_order ) { m_sort_order = sort_order; }
277 GtkSortType GetSortOrder() const { return m_sort_order; }
278
279 void SetSortColumn( int column ) { m_sort_column = column; }
280 int GetSortColumn() const { return m_sort_column; }
281
282 void SetDataViewSortColumn( wxDataViewColumn *column ) { m_dataview_sort_column = column; }
283 wxDataViewColumn *GetDataViewSortColumn() { return m_dataview_sort_column; }
284
285 bool IsSorted() const { return m_sort_column >= 0; }
286
287 // Should we be sorted either because we have a configured sort column or
288 // because we have a default sort order?
289 bool ShouldBeSorted() const
290 {
291 return IsSorted() || GetDataViewModel()->HasDefaultCompare();
292 }
293
294
295 // accessors
296 wxDataViewModel* GetDataViewModel() { return m_wx_model; }
297 const wxDataViewModel* GetDataViewModel() const { return m_wx_model; }
298 wxDataViewCtrl* GetOwner() { return m_owner; }
299 GtkWxTreeModel* GetGtkModel() { return m_gtk_model; }
300
301 // item can be deleted already in the model
302 int GetIndexOf( const wxDataViewItem &parent, const wxDataViewItem &item );
303
304 void OnInternalIdle();
305
306 protected:
307 void InitTree();
308 void ScheduleRefresh();
309
310 wxGtkTreeModelNode *FindNode( const wxDataViewItem &item );
311 wxGtkTreeModelNode *FindNode( GtkTreeIter *iter );
312 wxGtkTreeModelNode *FindParentNode( const wxDataViewItem &item );
313 wxGtkTreeModelNode *FindParentNode( GtkTreeIter *iter );
314 void BuildBranch( wxGtkTreeModelNode *branch );
315
316 private:
317 wxGtkTreeModelNode *m_root;
318 wxDataViewModel *m_wx_model;
319 GtkWxTreeModel *m_gtk_model;
320 wxDataViewCtrl *m_owner;
321 GtkSortType m_sort_order;
322 wxDataViewColumn *m_dataview_sort_column;
323 int m_sort_column;
324
325 GtkTargetEntry m_dragSourceTargetEntry;
326 wxCharBuffer m_dragSourceTargetEntryTarget;
327 wxDataObject *m_dragDataObject;
328
329 GtkTargetEntry m_dropTargetTargetEntry;
330 wxCharBuffer m_dropTargetTargetEntryTarget;
331 wxDataObject *m_dropDataObject;
332
333 wxGtkDataViewModelNotifier *m_notifier;
334
335 bool m_dirty;
336 };
337
338
339 //-----------------------------------------------------------------------------
340 // wxGtkTreeModelNode
341 //-----------------------------------------------------------------------------
342
343 static
344 int LINKAGEMODE wxGtkTreeModelChildCmp( void** id1, void** id2 )
345 {
346 int ret = gs_internal->GetDataViewModel()->Compare( wxDataViewItem(*id1), wxDataViewItem(*id2),
347 gs_internal->GetSortColumn(), (gs_internal->GetSortOrder() == GTK_SORT_ASCENDING) );
348
349 return ret;
350 }
351
352 WX_DEFINE_ARRAY_PTR( wxGtkTreeModelNode*, wxGtkTreeModelNodes );
353 WX_DEFINE_ARRAY_PTR( void*, wxGtkTreeModelChildren );
354
355 class wxGtkTreeModelNode
356 {
357 public:
358 wxGtkTreeModelNode( wxGtkTreeModelNode* parent, const wxDataViewItem &item,
359 wxDataViewCtrlInternal *internal )
360 {
361 m_parent = parent;
362 m_item = item;
363 m_internal = internal;
364 }
365
366 ~wxGtkTreeModelNode()
367 {
368 size_t count = m_nodes.GetCount();
369 size_t i;
370 for (i = 0; i < count; i++)
371 {
372 wxGtkTreeModelNode *child = m_nodes.Item( i );
373 delete child;
374 }
375 }
376
377 void AddNode( wxGtkTreeModelNode* child )
378 {
379 m_nodes.Add( child );
380
381 void *id = child->GetItem().GetID();
382
383 m_children.Add( id );
384
385 if (m_internal->ShouldBeSorted())
386 {
387 gs_internal = m_internal;
388 m_children.Sort( &wxGtkTreeModelChildCmp );
389 }
390 }
391
392 void InsertNode( wxGtkTreeModelNode* child, unsigned pos )
393 {
394 if (m_internal->ShouldBeSorted())
395 {
396 AddNode(child);
397 return;
398 }
399
400 void *id = child->GetItem().GetID();
401
402 // Insert into m_nodes so that the order of nodes in m_nodes is the
403 // same as the order of their corresponding IDs in m_children:
404 const unsigned int count = m_nodes.GetCount();
405 bool inserted = false;
406 for (unsigned i = 0; i < count; i++)
407 {
408 wxGtkTreeModelNode *node = m_nodes[i];
409 int posInChildren = m_children.Index(node->GetItem().GetID());
410 if ( (unsigned)posInChildren >= pos )
411 {
412 m_nodes.Insert(child, i);
413 inserted = true;
414 break;
415 }
416 }
417 if ( !inserted )
418 m_nodes.Add(child);
419
420 m_children.Insert( id, pos );
421 }
422
423 void AddLeaf( void* id )
424 {
425 InsertLeaf(id, m_children.size());
426 }
427
428 void InsertLeaf( void* id, unsigned pos )
429 {
430 m_children.Insert( id, pos );
431
432 if (m_internal->ShouldBeSorted())
433 {
434 gs_internal = m_internal;
435 m_children.Sort( &wxGtkTreeModelChildCmp );
436 }
437 }
438
439 void DeleteChild( void* id )
440 {
441 m_children.Remove( id );
442
443 unsigned int count = m_nodes.GetCount();
444 unsigned int pos;
445 for (pos = 0; pos < count; pos++)
446 {
447 wxGtkTreeModelNode *node = m_nodes.Item( pos );
448 if (node->GetItem().GetID() == id)
449 {
450 m_nodes.RemoveAt( pos );
451 delete node;
452 break;
453 }
454 }
455 }
456
457 // returns position of child node for given item in children list or wxNOT_FOUND
458 int FindChildByItem(const wxDataViewItem& item) const
459 {
460 const void* itemId = item.GetID();
461 const wxGtkTreeModelChildren& nodes = m_children;
462 const int len = nodes.size();
463 for ( int i = 0; i < len; i++ )
464 {
465 if ( nodes[i] == itemId )
466 return i;
467 }
468 return wxNOT_FOUND;
469 }
470
471 wxGtkTreeModelNode* GetParent()
472 { return m_parent; }
473 wxGtkTreeModelNodes &GetNodes()
474 { return m_nodes; }
475 wxGtkTreeModelChildren &GetChildren()
476 { return m_children; }
477
478 unsigned int GetChildCount() const { return m_children.GetCount(); }
479 unsigned int GetNodesCount() const { return m_nodes.GetCount(); }
480
481 wxDataViewItem &GetItem() { return m_item; }
482 wxDataViewCtrlInternal *GetInternal() { return m_internal; }
483
484 void Resort();
485
486 private:
487 wxGtkTreeModelNode *m_parent;
488 wxGtkTreeModelNodes m_nodes;
489 wxGtkTreeModelChildren m_children;
490 wxDataViewItem m_item;
491 wxDataViewCtrlInternal *m_internal;
492 };
493
494
495 //-----------------------------------------------------------------------------
496 // data
497 //-----------------------------------------------------------------------------
498
499 extern bool g_blockEventsOnDrag;
500
501 //-----------------------------------------------------------------------------
502 // define new GTK+ class wxGtkTreeModel
503 //-----------------------------------------------------------------------------
504
505 extern "C" {
506
507 #define GTK_TYPE_WX_TREE_MODEL (gtk_wx_tree_model_get_type ())
508 #define GTK_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModel))
509 #define GTK_IS_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_TREE_MODEL))
510 #define GTK_IS_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_TREE_MODEL))
511
512 GType gtk_wx_tree_model_get_type (void);
513
514 struct _GtkWxTreeModel
515 {
516 GObject parent;
517
518 /*< private >*/
519 gint stamp;
520 wxDataViewCtrlInternal *internal;
521 };
522
523 static GtkWxTreeModel *wxgtk_tree_model_new (void);
524 static void wxgtk_tree_model_init (GTypeInstance* instance, void*);
525
526 static void wxgtk_tree_model_tree_model_init (void* g_iface, void*);
527 static void wxgtk_tree_model_sortable_init (void* g_iface, void*);
528 static void wxgtk_tree_model_drag_source_init(void* g_iface, void*);
529 static void wxgtk_tree_model_drag_dest_init (void* g_iface, void*);
530
531 static GtkTreeModelFlags wxgtk_tree_model_get_flags (GtkTreeModel *tree_model);
532 static gint wxgtk_tree_model_get_n_columns (GtkTreeModel *tree_model);
533 static GType wxgtk_tree_model_get_column_type (GtkTreeModel *tree_model,
534 gint index);
535 static gboolean wxgtk_tree_model_get_iter (GtkTreeModel *tree_model,
536 GtkTreeIter *iter,
537 GtkTreePath *path);
538 static GtkTreePath *wxgtk_tree_model_get_path (GtkTreeModel *tree_model,
539 GtkTreeIter *iter);
540 static void wxgtk_tree_model_get_value (GtkTreeModel *tree_model,
541 GtkTreeIter *iter,
542 gint column,
543 GValue *value);
544 static gboolean wxgtk_tree_model_iter_next (GtkTreeModel *tree_model,
545 GtkTreeIter *iter);
546 static gboolean wxgtk_tree_model_iter_children (GtkTreeModel *tree_model,
547 GtkTreeIter *iter,
548 GtkTreeIter *parent);
549 static gboolean wxgtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
550 GtkTreeIter *iter);
551 static gint wxgtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
552 GtkTreeIter *iter);
553 static gboolean wxgtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
554 GtkTreeIter *iter,
555 GtkTreeIter *parent,
556 gint n);
557 static gboolean wxgtk_tree_model_iter_parent (GtkTreeModel *tree_model,
558 GtkTreeIter *iter,
559 GtkTreeIter *child);
560
561 /* sortable */
562 static gboolean wxgtk_tree_model_get_sort_column_id (GtkTreeSortable *sortable,
563 gint *sort_column_id,
564 GtkSortType *order);
565 static void wxgtk_tree_model_set_sort_column_id (GtkTreeSortable *sortable,
566 gint sort_column_id,
567 GtkSortType order);
568 static void wxgtk_tree_model_set_sort_func (GtkTreeSortable *sortable,
569 gint sort_column_id,
570 GtkTreeIterCompareFunc func,
571 gpointer data,
572 GDestroyNotify destroy);
573 static void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable *sortable,
574 GtkTreeIterCompareFunc func,
575 gpointer data,
576 GDestroyNotify destroy);
577 static gboolean wxgtk_tree_model_has_default_sort_func (GtkTreeSortable *sortable);
578
579 /* drag'n'drop */
580 static gboolean wxgtk_tree_model_row_draggable (GtkTreeDragSource *drag_source,
581 GtkTreePath *path);
582 static gboolean wxgtk_tree_model_drag_data_delete (GtkTreeDragSource *drag_source,
583 GtkTreePath *path);
584 static gboolean wxgtk_tree_model_drag_data_get (GtkTreeDragSource *drag_source,
585 GtkTreePath *path,
586 GtkSelectionData *selection_data);
587 static gboolean wxgtk_tree_model_drag_data_received (GtkTreeDragDest *drag_dest,
588 GtkTreePath *dest,
589 GtkSelectionData *selection_data);
590 static gboolean wxgtk_tree_model_row_drop_possible (GtkTreeDragDest *drag_dest,
591 GtkTreePath *dest_path,
592 GtkSelectionData *selection_data);
593
594 GType
595 gtk_wx_tree_model_get_type (void)
596 {
597 static GType tree_model_type = 0;
598
599 if (!tree_model_type)
600 {
601 const GTypeInfo tree_model_info =
602 {
603 sizeof (GObjectClass),
604 NULL, /* base_init */
605 NULL, /* base_finalize */
606 NULL,
607 NULL, /* class_finalize */
608 NULL, /* class_data */
609 sizeof (GtkWxTreeModel),
610 0,
611 wxgtk_tree_model_init,
612 };
613
614 static const GInterfaceInfo tree_model_iface_info =
615 {
616 wxgtk_tree_model_tree_model_init,
617 NULL,
618 NULL
619 };
620
621 static const GInterfaceInfo sortable_iface_info =
622 {
623 wxgtk_tree_model_sortable_init,
624 NULL,
625 NULL
626 };
627
628 static const GInterfaceInfo drag_source_iface_info =
629 {
630 wxgtk_tree_model_drag_source_init,
631 NULL,
632 NULL
633 };
634
635 static const GInterfaceInfo drag_dest_iface_info =
636 {
637 wxgtk_tree_model_drag_dest_init,
638 NULL,
639 NULL
640 };
641
642 tree_model_type = g_type_register_static (G_TYPE_OBJECT, "GtkWxTreeModel",
643 &tree_model_info, (GTypeFlags)0 );
644
645 g_type_add_interface_static (tree_model_type,
646 GTK_TYPE_TREE_MODEL,
647 &tree_model_iface_info);
648 g_type_add_interface_static (tree_model_type,
649 GTK_TYPE_TREE_SORTABLE,
650 &sortable_iface_info);
651 g_type_add_interface_static (tree_model_type,
652 GTK_TYPE_TREE_DRAG_DEST,
653 &drag_dest_iface_info);
654 g_type_add_interface_static (tree_model_type,
655 GTK_TYPE_TREE_DRAG_SOURCE,
656 &drag_source_iface_info);
657 }
658
659 return tree_model_type;
660 }
661
662 static GtkWxTreeModel *
663 wxgtk_tree_model_new(void)
664 {
665 GtkWxTreeModel *retval = (GtkWxTreeModel *) g_object_new (GTK_TYPE_WX_TREE_MODEL, NULL);
666 return retval;
667 }
668
669 static void
670 wxgtk_tree_model_tree_model_init(void* g_iface, void*)
671 {
672 GtkTreeModelIface* iface = static_cast<GtkTreeModelIface*>(g_iface);
673 iface->get_flags = wxgtk_tree_model_get_flags;
674 iface->get_n_columns = wxgtk_tree_model_get_n_columns;
675 iface->get_column_type = wxgtk_tree_model_get_column_type;
676 iface->get_iter = wxgtk_tree_model_get_iter;
677 iface->get_path = wxgtk_tree_model_get_path;
678 iface->get_value = wxgtk_tree_model_get_value;
679 iface->iter_next = wxgtk_tree_model_iter_next;
680 iface->iter_children = wxgtk_tree_model_iter_children;
681 iface->iter_has_child = wxgtk_tree_model_iter_has_child;
682 iface->iter_n_children = wxgtk_tree_model_iter_n_children;
683 iface->iter_nth_child = wxgtk_tree_model_iter_nth_child;
684 iface->iter_parent = wxgtk_tree_model_iter_parent;
685 }
686
687 static void
688 wxgtk_tree_model_sortable_init(void* g_iface, void*)
689 {
690 GtkTreeSortableIface* iface = static_cast<GtkTreeSortableIface*>(g_iface);
691 iface->get_sort_column_id = wxgtk_tree_model_get_sort_column_id;
692 iface->set_sort_column_id = wxgtk_tree_model_set_sort_column_id;
693 iface->set_sort_func = wxgtk_tree_model_set_sort_func;
694 iface->set_default_sort_func = wxgtk_tree_model_set_default_sort_func;
695 iface->has_default_sort_func = wxgtk_tree_model_has_default_sort_func;
696 }
697
698 static void
699 wxgtk_tree_model_drag_source_init(void* g_iface, void*)
700 {
701 GtkTreeDragSourceIface* iface = static_cast<GtkTreeDragSourceIface*>(g_iface);
702 iface->row_draggable = wxgtk_tree_model_row_draggable;
703 iface->drag_data_delete = wxgtk_tree_model_drag_data_delete;
704 iface->drag_data_get = wxgtk_tree_model_drag_data_get;
705 }
706
707 static void
708 wxgtk_tree_model_drag_dest_init(void* g_iface, void*)
709 {
710 GtkTreeDragDestIface* iface = static_cast<GtkTreeDragDestIface*>(g_iface);
711 iface->drag_data_received = wxgtk_tree_model_drag_data_received;
712 iface->row_drop_possible = wxgtk_tree_model_row_drop_possible;
713 }
714
715 static void
716 wxgtk_tree_model_init(GTypeInstance* instance, void*)
717 {
718 GtkWxTreeModel* tree_model = GTK_WX_TREE_MODEL(instance);
719 tree_model->internal = NULL;
720 tree_model->stamp = g_random_int();
721 }
722
723 } // extern "C"
724
725 //-----------------------------------------------------------------------------
726 // implement callbacks from wxGtkTreeModel class by letting
727 // them call the methods of wxWidgets' wxDataViewModel
728 //-----------------------------------------------------------------------------
729
730 static GtkTreeModelFlags
731 wxgtk_tree_model_get_flags (GtkTreeModel *tree_model)
732 {
733 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
734 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), (GtkTreeModelFlags)0 );
735
736 return wxtree_model->internal->get_flags();
737 }
738
739 static gint
740 wxgtk_tree_model_get_n_columns (GtkTreeModel *tree_model)
741 {
742 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
743 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), 0);
744
745 return wxtree_model->internal->GetDataViewModel()->GetColumnCount();
746 }
747
748 static GType
749 wxgtk_tree_model_get_column_type (GtkTreeModel *tree_model,
750 gint index)
751 {
752 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
753 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), G_TYPE_INVALID);
754
755 GType gtype = G_TYPE_INVALID;
756
757 wxString wxtype = wxtree_model->internal->GetDataViewModel()->GetColumnType( (unsigned int) index );
758
759 if (wxtype == wxT("string"))
760 gtype = G_TYPE_STRING;
761 else
762 {
763 gtype = G_TYPE_POINTER;
764 // wxFAIL_MSG( wxT("non-string columns not supported for searching yet") );
765 }
766
767 return gtype;
768 }
769
770 static gboolean
771 wxgtk_tree_model_get_iter (GtkTreeModel *tree_model,
772 GtkTreeIter *iter,
773 GtkTreePath *path)
774 {
775 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
776 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
777 g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
778
779 return wxtree_model->internal->get_iter( iter, path );
780 }
781
782 static GtkTreePath *
783 wxgtk_tree_model_get_path (GtkTreeModel *tree_model,
784 GtkTreeIter *iter)
785 {
786 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
787 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), NULL);
788 g_return_val_if_fail (iter->stamp == GTK_WX_TREE_MODEL (wxtree_model)->stamp, NULL);
789
790 return wxtree_model->internal->get_path( iter );
791 }
792
793 static void
794 wxgtk_tree_model_get_value (GtkTreeModel *tree_model,
795 GtkTreeIter *iter,
796 gint column,
797 GValue *value)
798 {
799 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
800 g_return_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model) );
801
802 wxDataViewModel *model = wxtree_model->internal->GetDataViewModel();
803 wxString mtype = model->GetColumnType( (unsigned int) column );
804 if (mtype == wxT("string"))
805 {
806 wxVariant variant;
807 g_value_init( value, G_TYPE_STRING );
808 wxDataViewItem item( (void*) iter->user_data );
809 model->GetValue( variant, item, (unsigned int) column );
810
811 g_value_set_string( value, variant.GetString().utf8_str() );
812 }
813 else
814 {
815 wxFAIL_MSG( wxT("non-string columns not supported yet") );
816 }
817 }
818
819 static gboolean
820 wxgtk_tree_model_iter_next (GtkTreeModel *tree_model,
821 GtkTreeIter *iter)
822 {
823 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
824
825 // This happens when clearing the view by calling .._set_model( NULL );
826 if (iter->stamp == 0) return FALSE;
827
828 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
829 g_return_val_if_fail (wxtree_model->stamp == iter->stamp, FALSE);
830
831 return wxtree_model->internal->iter_next( iter );
832 }
833
834 static gboolean
835 wxgtk_tree_model_iter_children (GtkTreeModel *tree_model,
836 GtkTreeIter *iter,
837 GtkTreeIter *parent)
838 {
839 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
840 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
841 if (parent)
842 {
843 g_return_val_if_fail (wxtree_model->stamp == parent->stamp, FALSE);
844 }
845
846 return wxtree_model->internal->iter_children( iter, parent );
847 }
848
849 static gboolean
850 wxgtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
851 GtkTreeIter *iter)
852 {
853 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
854 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
855 g_return_val_if_fail (wxtree_model->stamp == iter->stamp, FALSE);
856
857 return wxtree_model->internal->iter_has_child( iter );
858 }
859
860 static gint
861 wxgtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
862 GtkTreeIter *iter)
863 {
864 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
865 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), 0);
866 g_return_val_if_fail ( !iter || wxtree_model->stamp == iter->stamp, 0);
867
868 return wxtree_model->internal->iter_n_children( iter );
869 }
870
871 static gboolean
872 wxgtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
873 GtkTreeIter *iter,
874 GtkTreeIter *parent,
875 gint n)
876 {
877 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
878 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
879
880 return wxtree_model->internal->iter_nth_child( iter, parent, n );
881 }
882
883 static gboolean
884 wxgtk_tree_model_iter_parent (GtkTreeModel *tree_model,
885 GtkTreeIter *iter,
886 GtkTreeIter *child)
887 {
888 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
889 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
890 g_return_val_if_fail (wxtree_model->stamp == child->stamp, FALSE);
891
892 return wxtree_model->internal->iter_parent( iter, child );
893 }
894
895 /* drag'n'drop iface */
896 static gboolean
897 wxgtk_tree_model_row_draggable (GtkTreeDragSource *drag_source,
898 GtkTreePath *path)
899 {
900 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_source;
901 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
902
903 return wxtree_model->internal->row_draggable( drag_source, path );
904 }
905
906 static gboolean
907 wxgtk_tree_model_drag_data_delete (GtkTreeDragSource *drag_source,
908 GtkTreePath *path)
909 {
910 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_source;
911 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
912
913 return wxtree_model->internal->drag_data_delete( drag_source, path );
914 }
915
916 static gboolean
917 wxgtk_tree_model_drag_data_get (GtkTreeDragSource *drag_source,
918 GtkTreePath *path,
919 GtkSelectionData *selection_data)
920 {
921 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_source;
922 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
923
924 #if 0
925 wxPrintf( "drag_get_data\n");
926
927 wxGtkString atom_selection(gdk_atom_name(selection_data->selection));
928 wxPrintf( "selection %s\n", wxString::FromAscii(atom_selection) );
929
930 wxGtkString atom_target(gdk_atom_name(selection_data->target));
931 wxPrintf( "target %s\n", wxString::FromAscii(atom_target) );
932
933 wxGtkString atom_type(gdk_atom_name(selection_data->type));
934 wxPrintf( "type %s\n", wxString::FromAscii(atom_type) );
935
936 wxPrintf( "format %d\n", selection_data->format );
937 #endif
938
939 return wxtree_model->internal->drag_data_get( drag_source, path, selection_data );
940 }
941
942 static gboolean
943 wxgtk_tree_model_drag_data_received (GtkTreeDragDest *drag_dest,
944 GtkTreePath *dest,
945 GtkSelectionData *selection_data)
946 {
947 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_dest;
948 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
949
950 return wxtree_model->internal->drag_data_received( drag_dest, dest, selection_data );
951 }
952
953 static gboolean
954 wxgtk_tree_model_row_drop_possible (GtkTreeDragDest *drag_dest,
955 GtkTreePath *dest_path,
956 GtkSelectionData *selection_data)
957 {
958 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_dest;
959 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
960
961 return wxtree_model->internal->row_drop_possible( drag_dest, dest_path, selection_data );
962 }
963
964 /* sortable iface */
965 static gboolean
966 wxgtk_tree_model_get_sort_column_id (GtkTreeSortable *sortable,
967 gint *sort_column_id,
968 GtkSortType *order)
969 {
970 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) sortable;
971
972 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable), FALSE);
973
974 if (!wxtree_model->internal->IsSorted())
975 {
976 if (sort_column_id)
977 *sort_column_id = -1;
978
979 return TRUE;
980 }
981
982
983 if (sort_column_id)
984 *sort_column_id = wxtree_model->internal->GetSortColumn();
985
986 if (order)
987 *order = wxtree_model->internal->GetSortOrder();
988
989 return TRUE;
990 }
991
992 wxDataViewColumn *gs_lastLeftClickHeader = NULL;
993
994 static void
995 wxgtk_tree_model_set_sort_column_id (GtkTreeSortable *sortable,
996 gint sort_column_id,
997 GtkSortType order)
998 {
999 GtkWxTreeModel *tree_model = (GtkWxTreeModel *) sortable;
1000 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
1001
1002 tree_model->internal->SetDataViewSortColumn( gs_lastLeftClickHeader );
1003
1004 if ((sort_column_id != (gint) tree_model->internal->GetSortColumn()) ||
1005 (order != tree_model->internal->GetSortOrder()))
1006 {
1007 tree_model->internal->SetSortColumn( sort_column_id );
1008 tree_model->internal->SetSortOrder( order );
1009
1010 gtk_tree_sortable_sort_column_changed (sortable);
1011
1012 tree_model->internal->GetDataViewModel()->Resort();
1013 }
1014
1015 if (gs_lastLeftClickHeader)
1016 {
1017 wxDataViewCtrl *dv = tree_model->internal->GetOwner();
1018 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, dv->GetId() );
1019 event.SetDataViewColumn( gs_lastLeftClickHeader );
1020 event.SetModel( dv->GetModel() );
1021 dv->HandleWindowEvent( event );
1022 }
1023
1024 gs_lastLeftClickHeader = NULL;
1025 }
1026
1027 static void
1028 wxgtk_tree_model_set_sort_func (GtkTreeSortable *sortable,
1029 gint WXUNUSED(sort_column_id),
1030 GtkTreeIterCompareFunc func,
1031 gpointer WXUNUSED(data),
1032 GDestroyNotify WXUNUSED(destroy))
1033 {
1034 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
1035 g_return_if_fail (func != NULL);
1036 }
1037
1038 static void
1039 wxgtk_tree_model_set_default_sort_func (GtkTreeSortable *sortable,
1040 GtkTreeIterCompareFunc func,
1041 gpointer WXUNUSED(data),
1042 GDestroyNotify WXUNUSED(destroy))
1043 {
1044 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
1045 g_return_if_fail (func != NULL);
1046
1047 //wxPrintf( "wxgtk_tree_model_set_default_sort_func\n" );
1048 // TODO: remove this code
1049 }
1050
1051 static gboolean
1052 wxgtk_tree_model_has_default_sort_func (GtkTreeSortable *sortable)
1053 {
1054 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable), FALSE );
1055
1056 return FALSE;
1057 }
1058
1059 //-----------------------------------------------------------------------------
1060 // define new GTK+ class GtkWxRendererText
1061 //-----------------------------------------------------------------------------
1062
1063 extern "C" {
1064
1065 #define GTK_TYPE_WX_CELL_RENDERER_TEXT (gtk_wx_cell_renderer_text_get_type ())
1066 #define GTK_WX_CELL_RENDERER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererText))
1067 #define GTK_IS_WX_CELL_RENDERER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT))
1068 #define GTK_IS_WX_CELL_RENDERER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT))
1069
1070 GType gtk_wx_cell_renderer_text_get_type (void);
1071
1072 typedef struct _GtkWxCellRendererText GtkWxCellRendererText;
1073
1074 struct _GtkWxCellRendererText
1075 {
1076 GtkCellRendererText parent;
1077
1078 wxDataViewRenderer *wx_renderer;
1079 };
1080
1081 static GtkWxCellRendererText *gtk_wx_cell_renderer_text_new (void);
1082 static void gtk_wx_cell_renderer_text_init (
1083 GTypeInstance* instance, void*);
1084 static void gtk_wx_cell_renderer_text_class_init(
1085 void* klass, void*);
1086 static GtkCellEditable *gtk_wx_cell_renderer_text_start_editing(
1087 GtkCellRenderer *cell,
1088 GdkEvent *event,
1089 GtkWidget *widget,
1090 const gchar *path,
1091 wxConstGdkRect *background_area,
1092 wxConstGdkRect *cell_area,
1093 GtkCellRendererState flags );
1094
1095
1096 static GObjectClass *text_cell_parent_class = NULL;
1097
1098 } // extern "C"
1099
1100 GType
1101 gtk_wx_cell_renderer_text_get_type (void)
1102 {
1103 static GType cell_wx_type = 0;
1104
1105 if (!cell_wx_type)
1106 {
1107 const GTypeInfo cell_wx_info =
1108 {
1109 sizeof (GtkCellRendererTextClass),
1110 NULL, /* base_init */
1111 NULL, /* base_finalize */
1112 gtk_wx_cell_renderer_text_class_init,
1113 NULL, /* class_finalize */
1114 NULL, /* class_data */
1115 sizeof (GtkWxCellRendererText),
1116 0, /* n_preallocs */
1117 gtk_wx_cell_renderer_text_init,
1118 };
1119
1120 cell_wx_type = g_type_register_static( GTK_TYPE_CELL_RENDERER_TEXT,
1121 "GtkWxCellRendererText", &cell_wx_info, (GTypeFlags)0 );
1122 }
1123
1124 return cell_wx_type;
1125 }
1126
1127 static void
1128 gtk_wx_cell_renderer_text_init(GTypeInstance* instance, void*)
1129 {
1130 GtkWxCellRendererText* cell = GTK_WX_CELL_RENDERER_TEXT(instance);
1131 cell->wx_renderer = NULL;
1132 }
1133
1134 static void
1135 gtk_wx_cell_renderer_text_class_init(void* klass, void*)
1136 {
1137 GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
1138
1139 text_cell_parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
1140
1141 cell_class->start_editing = gtk_wx_cell_renderer_text_start_editing;
1142 }
1143
1144 GtkWxCellRendererText*
1145 gtk_wx_cell_renderer_text_new (void)
1146 {
1147 return (GtkWxCellRendererText*) g_object_new (GTK_TYPE_WX_CELL_RENDERER_TEXT, NULL);
1148 }
1149
1150 static GtkCellEditable *gtk_wx_cell_renderer_text_start_editing(
1151 GtkCellRenderer *gtk_renderer,
1152 GdkEvent *gdk_event,
1153 GtkWidget *widget,
1154 const gchar *path,
1155 wxConstGdkRect *background_area,
1156 wxConstGdkRect *cell_area,
1157 GtkCellRendererState flags )
1158 {
1159 GtkWxCellRendererText *wxgtk_renderer = (GtkWxCellRendererText *) gtk_renderer;
1160 wxDataViewRenderer *wx_renderer = wxgtk_renderer->wx_renderer;
1161 wxDataViewColumn *column = wx_renderer->GetOwner();
1162
1163 wxDataViewItem
1164 item(column->GetOwner()->GTKPathToItem(wxGtkTreePath(path)));
1165
1166 wxDataViewCtrl *dv = column->GetOwner();
1167 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING, dv->GetId() );
1168 event.SetDataViewColumn( column );
1169 event.SetModel( dv->GetModel() );
1170 event.SetColumn( column->GetModelColumn() );
1171 event.SetItem( item );
1172 dv->HandleWindowEvent( event );
1173
1174 if (event.IsAllowed())
1175 return GTK_CELL_RENDERER_CLASS(text_cell_parent_class)->
1176 start_editing( gtk_renderer, gdk_event, widget, path, background_area, cell_area, flags );
1177 else
1178 return NULL;
1179 }
1180
1181 //-----------------------------------------------------------------------------
1182 // define new GTK+ class GtkWxCellRenderer
1183 //-----------------------------------------------------------------------------
1184
1185 extern "C" {
1186
1187 #define GTK_TYPE_WX_CELL_RENDERER (gtk_wx_cell_renderer_get_type ())
1188 #define GTK_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRenderer))
1189 #define GTK_IS_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER))
1190 #define GTK_IS_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER))
1191
1192 GType gtk_wx_cell_renderer_get_type (void);
1193
1194 typedef struct _GtkWxCellRenderer GtkWxCellRenderer;
1195
1196 struct _GtkWxCellRenderer
1197 {
1198 GtkCellRenderer parent;
1199
1200 /*< private >*/
1201 wxDataViewCustomRenderer *cell;
1202 };
1203
1204 static GtkCellRenderer *gtk_wx_cell_renderer_new (void);
1205 static void gtk_wx_cell_renderer_init (
1206 GTypeInstance* instance, void*);
1207 static void gtk_wx_cell_renderer_class_init(
1208 void* klass, void*);
1209 static void gtk_wx_cell_renderer_get_size (
1210 GtkCellRenderer *cell,
1211 GtkWidget *widget,
1212 wxConstGdkRect *rectangle,
1213 gint *x_offset,
1214 gint *y_offset,
1215 gint *width,
1216 gint *height );
1217 static void gtk_wx_cell_renderer_render (
1218 GtkCellRenderer *cell,
1219 #ifdef __WXGTK3__
1220 cairo_t* cr,
1221 #else
1222 GdkWindow *window,
1223 #endif
1224 GtkWidget *widget,
1225 wxConstGdkRect *background_area,
1226 wxConstGdkRect *cell_area,
1227 #ifndef __WXGTK3__
1228 GdkRectangle *expose_area,
1229 #endif
1230 GtkCellRendererState flags );
1231 static gboolean gtk_wx_cell_renderer_activate(
1232 GtkCellRenderer *cell,
1233 GdkEvent *event,
1234 GtkWidget *widget,
1235 const gchar *path,
1236 wxConstGdkRect *background_area,
1237 wxConstGdkRect *cell_area,
1238 GtkCellRendererState flags );
1239 static GtkCellEditable *gtk_wx_cell_renderer_start_editing(
1240 GtkCellRenderer *cell,
1241 GdkEvent *event,
1242 GtkWidget *widget,
1243 const gchar *path,
1244 wxConstGdkRect *background_area,
1245 wxConstGdkRect *cell_area,
1246 GtkCellRendererState flags );
1247
1248 } // extern "C"
1249
1250 GType
1251 gtk_wx_cell_renderer_get_type (void)
1252 {
1253 static GType cell_wx_type = 0;
1254
1255 if (!cell_wx_type)
1256 {
1257 const GTypeInfo cell_wx_info =
1258 {
1259 sizeof (GtkCellRendererClass),
1260 NULL, /* base_init */
1261 NULL, /* base_finalize */
1262 gtk_wx_cell_renderer_class_init,
1263 NULL, /* class_finalize */
1264 NULL, /* class_data */
1265 sizeof (GtkWxCellRenderer),
1266 0, /* n_preallocs */
1267 gtk_wx_cell_renderer_init,
1268 };
1269
1270 cell_wx_type = g_type_register_static( GTK_TYPE_CELL_RENDERER,
1271 "GtkWxCellRenderer", &cell_wx_info, (GTypeFlags)0 );
1272 }
1273
1274 return cell_wx_type;
1275 }
1276
1277 static void
1278 gtk_wx_cell_renderer_init(GTypeInstance* instance, void*)
1279 {
1280 GtkWxCellRenderer* cell = GTK_WX_CELL_RENDERER(instance);
1281 cell->cell = NULL;
1282 }
1283
1284 static void
1285 gtk_wx_cell_renderer_class_init(void* klass, void*)
1286 {
1287 GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
1288
1289 cell_class->get_size = gtk_wx_cell_renderer_get_size;
1290 cell_class->render = gtk_wx_cell_renderer_render;
1291 cell_class->activate = gtk_wx_cell_renderer_activate;
1292 cell_class->start_editing = gtk_wx_cell_renderer_start_editing;
1293 }
1294
1295 GtkCellRenderer*
1296 gtk_wx_cell_renderer_new (void)
1297 {
1298 return (GtkCellRenderer*) g_object_new (GTK_TYPE_WX_CELL_RENDERER, NULL);
1299 }
1300
1301 static GtkCellEditable *gtk_wx_cell_renderer_start_editing(
1302 GtkCellRenderer *renderer,
1303 GdkEvent *WXUNUSED(event),
1304 GtkWidget *widget,
1305 const gchar *path,
1306 wxConstGdkRect *WXUNUSED(background_area),
1307 wxConstGdkRect *cell_area,
1308 GtkCellRendererState WXUNUSED(flags) )
1309 {
1310 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1311 wxDataViewCustomRenderer *cell = wxrenderer->cell;
1312
1313 // Renderer doesn't support in-place editing
1314 if (!cell->HasEditorCtrl())
1315 return NULL;
1316
1317 // An in-place editing control is still around
1318 if (cell->GetEditorCtrl())
1319 return NULL;
1320
1321 GdkRectangle rect;
1322 gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
1323 &rect.x,
1324 &rect.y,
1325 &rect.width,
1326 &rect.height);
1327
1328 rect.x += cell_area->x;
1329 rect.y += cell_area->y;
1330 // rect.width -= renderer->xpad * 2;
1331 // rect.height -= renderer->ypad * 2;
1332
1333 // wxRect renderrect(wxRectFromGDKRect(&rect));
1334 wxRect renderrect(wxRectFromGDKRect(cell_area));
1335
1336 wxDataViewItem
1337 item(cell->GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(path)));
1338
1339 cell->StartEditing( item, renderrect );
1340
1341 return NULL;
1342 }
1343
1344 static void
1345 gtk_wx_cell_renderer_get_size (GtkCellRenderer *renderer,
1346 GtkWidget *WXUNUSED(widget),
1347 wxConstGdkRect *cell_area,
1348 gint *x_offset,
1349 gint *y_offset,
1350 gint *width,
1351 gint *height)
1352 {
1353 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1354 wxDataViewCustomRenderer *cell = wxrenderer->cell;
1355
1356 wxSize size = cell->GetSize();
1357
1358 wxDataViewCtrl * const ctrl = cell->GetOwner()->GetOwner();
1359
1360 // Uniform row height, if specified, overrides the value returned by the
1361 // renderer.
1362 if ( !ctrl->HasFlag(wxDV_VARIABLE_LINE_HEIGHT) )
1363 {
1364 const int uniformHeight = ctrl->GTKGetUniformRowHeight();
1365 if ( uniformHeight > 0 )
1366 size.y = uniformHeight;
1367 }
1368
1369 int xpad, ypad;
1370 gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
1371 int calc_width = xpad * 2 + size.x;
1372 int calc_height = ypad * 2 + size.y;
1373
1374 if (x_offset)
1375 *x_offset = 0;
1376 if (y_offset)
1377 *y_offset = 0;
1378
1379 if (cell_area && size.x > 0 && size.y > 0)
1380 {
1381 float xalign, yalign;
1382 gtk_cell_renderer_get_alignment(renderer, &xalign, &yalign);
1383 if (x_offset)
1384 {
1385 *x_offset = int(xalign * (cell_area->width - calc_width - 2 * xpad));
1386 *x_offset = MAX(*x_offset, 0) + xpad;
1387 }
1388 if (y_offset)
1389 {
1390 *y_offset = int(yalign * (cell_area->height - calc_height - 2 * ypad));
1391 *y_offset = MAX(*y_offset, 0) + ypad;
1392 }
1393 }
1394
1395 if (width)
1396 *width = calc_width;
1397
1398 if (height)
1399 *height = calc_height;
1400 }
1401
1402 struct wxDataViewCustomRenderer::GTKRenderParams
1403 {
1404 #ifdef __WXGTK3__
1405 cairo_t* cr;
1406 #else
1407 GdkWindow* window;
1408 GdkRectangle* expose_area;
1409 #endif
1410 GtkWidget* widget;
1411 wxConstGdkRect* background_area;
1412 int flags;
1413 };
1414
1415 static void
1416 gtk_wx_cell_renderer_render (GtkCellRenderer *renderer,
1417 #ifdef __WXGTK3__
1418 cairo_t* cr,
1419 #else
1420 GdkWindow *window,
1421 #endif
1422 GtkWidget *widget,
1423 wxConstGdkRect *background_area,
1424 wxConstGdkRect *cell_area,
1425 #ifndef __WXGTK3__
1426 GdkRectangle *expose_area,
1427 #endif
1428 GtkCellRendererState flags)
1429
1430 {
1431 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1432 wxDataViewCustomRenderer *cell = wxrenderer->cell;
1433
1434 wxDataViewCustomRenderer::GTKRenderParams renderParams;
1435 #ifdef __WXGTK3__
1436 renderParams.cr = cr;
1437 #else
1438 renderParams.window = window;
1439 renderParams.expose_area = expose_area;
1440 #endif
1441 renderParams.widget = widget;
1442 renderParams.background_area = background_area;
1443 renderParams.flags = flags;
1444 cell->GTKSetRenderParams(&renderParams);
1445
1446 wxRect rect(wxRectFromGDKRect(cell_area));
1447 int xpad, ypad;
1448 gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
1449 rect = rect.Deflate(xpad, ypad);
1450
1451 wxDC* dc = cell->GetDC();
1452 #ifdef __WXGTK3__
1453 wxGraphicsContext* context = dc->GetGraphicsContext();
1454 void* nativeContext = NULL;
1455 if (context)
1456 nativeContext = context->GetNativeContext();
1457 if (cr != nativeContext)
1458 {
1459 cairo_reference(cr);
1460 dc->SetGraphicsContext(wxGraphicsContext::CreateFromNative(cr));
1461 }
1462 #else
1463 wxWindowDCImpl *impl = (wxWindowDCImpl *) dc->GetImpl();
1464
1465 // Reinitialize wxWindowDC's GDK window if drawing occurs into a different
1466 // window such as a DnD drop window.
1467 if (window != impl->m_gdkwindow)
1468 {
1469 impl->Destroy();
1470 impl->m_gdkwindow = window;
1471 impl->SetUpDC();
1472 }
1473 #endif
1474
1475 int state = 0;
1476 if (flags & GTK_CELL_RENDERER_SELECTED)
1477 state |= wxDATAVIEW_CELL_SELECTED;
1478 if (flags & GTK_CELL_RENDERER_PRELIT)
1479 state |= wxDATAVIEW_CELL_PRELIT;
1480 if (flags & GTK_CELL_RENDERER_INSENSITIVE)
1481 state |= wxDATAVIEW_CELL_INSENSITIVE;
1482 if (flags & GTK_CELL_RENDERER_INSENSITIVE)
1483 state |= wxDATAVIEW_CELL_INSENSITIVE;
1484 if (flags & GTK_CELL_RENDERER_FOCUSED)
1485 state |= wxDATAVIEW_CELL_FOCUSED;
1486 cell->WXCallRender( rect, dc, state );
1487
1488 cell->GTKSetRenderParams(NULL);
1489 #ifdef __WXGTK3__
1490 dc->SetGraphicsContext(NULL);
1491 #endif
1492 }
1493
1494 static gboolean
1495 gtk_wx_cell_renderer_activate(
1496 GtkCellRenderer *renderer,
1497 GdkEvent *event,
1498 GtkWidget *widget,
1499 const gchar *path,
1500 wxConstGdkRect *WXUNUSED(background_area),
1501 wxConstGdkRect *cell_area,
1502 GtkCellRendererState WXUNUSED(flags) )
1503 {
1504 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1505 wxDataViewCustomRenderer *cell = wxrenderer->cell;
1506
1507 GdkRectangle rect;
1508 gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
1509 &rect.x,
1510 &rect.y,
1511 &rect.width,
1512 &rect.height);
1513
1514 rect.x += cell_area->x;
1515 rect.y += cell_area->y;
1516 int xpad, ypad;
1517 gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
1518 rect.width -= xpad * 2;
1519 rect.height -= ypad * 2;
1520
1521 wxRect renderrect(wxRectFromGDKRect(&rect));
1522
1523 wxDataViewCtrl * const ctrl = cell->GetOwner()->GetOwner();
1524 wxDataViewModel *model = ctrl->GetModel();
1525
1526 wxDataViewItem item(ctrl->GTKPathToItem(wxGtkTreePath(path)));
1527
1528 unsigned int model_col = cell->GetOwner()->GetModelColumn();
1529
1530 if ( !event )
1531 {
1532 // activated by <ENTER>
1533 return cell->ActivateCell(renderrect, model, item, model_col, NULL);
1534 }
1535 else if ( event->type == GDK_BUTTON_PRESS )
1536 {
1537 GdkEventButton *button_event = (GdkEventButton*)event;
1538 if ( button_event->button == 1 )
1539 {
1540 wxMouseEvent mouse_event(wxEVT_LEFT_DOWN);
1541 InitMouseEvent(ctrl, mouse_event, button_event);
1542
1543 mouse_event.m_x -= renderrect.x;
1544 mouse_event.m_y -= renderrect.y;
1545
1546 return cell->ActivateCell(renderrect, model, item, model_col, &mouse_event);
1547 }
1548 }
1549
1550 wxLogDebug("unexpected event type in gtk_wx_cell_renderer_activate()");
1551 return false;
1552 }
1553
1554 // ---------------------------------------------------------
1555 // wxGtkDataViewModelNotifier
1556 // ---------------------------------------------------------
1557
1558 class wxGtkDataViewModelNotifier: public wxDataViewModelNotifier
1559 {
1560 public:
1561 wxGtkDataViewModelNotifier( wxDataViewModel *wx_model, wxDataViewCtrlInternal *internal );
1562 ~wxGtkDataViewModelNotifier();
1563
1564 virtual bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
1565 virtual bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
1566 virtual bool ItemChanged( const wxDataViewItem &item );
1567 virtual bool ValueChanged( const wxDataViewItem &item, unsigned int model_column );
1568 virtual bool Cleared();
1569 virtual void Resort();
1570 virtual bool BeforeReset();
1571 virtual bool AfterReset();
1572
1573 void UpdateLastCount();
1574
1575 private:
1576 wxDataViewModel *m_wx_model;
1577 wxDataViewCtrlInternal *m_internal;
1578 };
1579
1580 // ---------------------------------------------------------
1581 // wxGtkDataViewListModelNotifier
1582 // ---------------------------------------------------------
1583
1584 wxGtkDataViewModelNotifier::wxGtkDataViewModelNotifier(
1585 wxDataViewModel *wx_model, wxDataViewCtrlInternal *internal )
1586 {
1587 m_wx_model = wx_model;
1588 m_internal = internal;
1589 }
1590
1591 wxGtkDataViewModelNotifier::~wxGtkDataViewModelNotifier()
1592 {
1593 m_wx_model = NULL;
1594 m_internal = NULL;
1595 }
1596
1597 bool wxGtkDataViewModelNotifier::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
1598 {
1599 m_internal->ItemAdded( parent, item );
1600 GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1601
1602 GtkTreeIter iter;
1603 iter.stamp = wxgtk_model->stamp;
1604 iter.user_data = item.GetID();
1605
1606 wxGtkTreePath path(wxgtk_tree_model_get_path(
1607 GTK_TREE_MODEL(wxgtk_model), &iter ));
1608 gtk_tree_model_row_inserted(
1609 GTK_TREE_MODEL(wxgtk_model), path, &iter);
1610
1611 return true;
1612 }
1613
1614 bool wxGtkDataViewModelNotifier::ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
1615 {
1616 GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1617 #if 0
1618 // using _get_path for a deleted item cannot be
1619 // a good idea
1620 GtkTreeIter iter;
1621 iter.stamp = wxgtk_model->stamp;
1622 iter.user_data = (gpointer) item.GetID();
1623 wxGtkTreePath path(wxgtk_tree_model_get_path(
1624 GTK_TREE_MODEL(wxgtk_model), &iter ));
1625 #else
1626 // so get the path from the parent
1627 GtkTreeIter parentIter;
1628 parentIter.stamp = wxgtk_model->stamp;
1629 parentIter.user_data = (gpointer) parent.GetID();
1630 wxGtkTreePath parentPath(wxgtk_tree_model_get_path(
1631 GTK_TREE_MODEL(wxgtk_model), &parentIter ));
1632
1633 // and add the final index ourselves
1634 wxGtkTreePath path(gtk_tree_path_copy(parentPath));
1635 int index = m_internal->GetIndexOf( parent, item );
1636 gtk_tree_path_append_index( path, index );
1637 #endif
1638
1639 gtk_tree_model_row_deleted(
1640 GTK_TREE_MODEL(wxgtk_model), path );
1641
1642 m_internal->ItemDeleted( parent, item );
1643
1644 // Did we remove the last child, causing 'parent' to become a leaf?
1645 if ( !m_wx_model->IsContainer(parent) )
1646 {
1647 gtk_tree_model_row_has_child_toggled
1648 (
1649 GTK_TREE_MODEL(wxgtk_model),
1650 parentPath,
1651 &parentIter
1652 );
1653 }
1654
1655 return true;
1656 }
1657
1658 void wxGtkDataViewModelNotifier::Resort()
1659 {
1660 m_internal->Resort();
1661 }
1662
1663 bool wxGtkDataViewModelNotifier::ItemChanged( const wxDataViewItem &item )
1664 {
1665 GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1666
1667 GtkTreeIter iter;
1668 iter.stamp = wxgtk_model->stamp;
1669 iter.user_data = (gpointer) item.GetID();
1670
1671 wxGtkTreePath path(wxgtk_tree_model_get_path(
1672 GTK_TREE_MODEL(wxgtk_model), &iter ));
1673 gtk_tree_model_row_changed(
1674 GTK_TREE_MODEL(wxgtk_model), path, &iter );
1675
1676 m_internal->ItemChanged( item );
1677
1678 return true;
1679 }
1680
1681 bool wxGtkDataViewModelNotifier::ValueChanged( const wxDataViewItem &item, unsigned int model_column )
1682 {
1683 GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1684 wxDataViewCtrl *ctrl = m_internal->GetOwner();
1685
1686 // This adds GTK+'s missing MVC logic for ValueChanged
1687 unsigned int index;
1688 for (index = 0; index < ctrl->GetColumnCount(); index++)
1689 {
1690 wxDataViewColumn *column = ctrl->GetColumn( index );
1691 if (column->GetModelColumn() == model_column)
1692 {
1693 GtkTreeView *widget = GTK_TREE_VIEW(ctrl->GtkGetTreeView());
1694 GtkTreeViewColumn *gcolumn = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
1695
1696 // Don't attempt to refresh not yet realized tree, it is useless
1697 // and results in GTK errors.
1698 if ( gtk_widget_get_realized(ctrl->GtkGetTreeView()) )
1699 {
1700 // Get cell area
1701 GtkTreeIter iter;
1702 iter.stamp = wxgtk_model->stamp;
1703 iter.user_data = (gpointer) item.GetID();
1704 wxGtkTreePath path(wxgtk_tree_model_get_path(
1705 GTK_TREE_MODEL(wxgtk_model), &iter ));
1706 GdkRectangle cell_area;
1707 gtk_tree_view_get_cell_area( widget, path, gcolumn, &cell_area );
1708
1709 GtkAdjustment* hadjust = gtk_tree_view_get_hadjustment( widget );
1710 double d = gtk_adjustment_get_value( hadjust );
1711 int xdiff = (int) d;
1712
1713 GtkAllocation a;
1714 gtk_widget_get_allocation(GTK_WIDGET(gtk_tree_view_column_get_button(gcolumn)), &a);
1715 int ydiff = a.height;
1716 // Redraw
1717 gtk_widget_queue_draw_area( GTK_WIDGET(widget),
1718 cell_area.x - xdiff, ydiff + cell_area.y, cell_area.width, cell_area.height );
1719 }
1720
1721 m_internal->ValueChanged( item, model_column );
1722
1723 return true;
1724 }
1725 }
1726
1727 return false;
1728 }
1729
1730 bool wxGtkDataViewModelNotifier::BeforeReset()
1731 {
1732 GtkWidget *treeview = m_internal->GetOwner()->GtkGetTreeView();
1733 gtk_tree_view_set_model( GTK_TREE_VIEW(treeview), NULL );
1734
1735 return true;
1736 }
1737
1738 bool wxGtkDataViewModelNotifier::AfterReset()
1739 {
1740 GtkWidget *treeview = m_internal->GetOwner()->GtkGetTreeView();
1741 GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1742
1743 m_internal->Cleared();
1744
1745 gtk_tree_view_set_model( GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(wxgtk_model) );
1746
1747 return true;
1748 }
1749
1750 bool wxGtkDataViewModelNotifier::Cleared()
1751 {
1752 GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1753
1754 // There is no call to tell the model that everything
1755 // has been deleted so call row_deleted() for every
1756 // child of root...
1757
1758 int count = m_internal->iter_n_children( NULL ); // number of children of root
1759
1760 GtkTreePath *path = gtk_tree_path_new_first(); // points to root
1761
1762 int i;
1763 for (i = 0; i < count; i++)
1764 gtk_tree_model_row_deleted( GTK_TREE_MODEL(wxgtk_model), path );
1765
1766 gtk_tree_path_free( path );
1767
1768 m_internal->Cleared();
1769
1770 return true;
1771 }
1772
1773 // ---------------------------------------------------------
1774 // wxDataViewRenderer
1775 // ---------------------------------------------------------
1776
1777 static gpointer s_user_data = NULL;
1778
1779 static void
1780 wxgtk_cell_editable_editing_done( GtkCellEditable *WXUNUSED(editable),
1781 wxDataViewRenderer *wxrenderer )
1782 {
1783 wxDataViewColumn *column = wxrenderer->GetOwner();
1784 wxDataViewCtrl *dv = column->GetOwner();
1785 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, dv->GetId() );
1786 event.SetDataViewColumn( column );
1787 event.SetModel( dv->GetModel() );
1788 wxDataViewItem item( s_user_data );
1789 event.SetItem( item );
1790 dv->HandleWindowEvent( event );
1791 }
1792
1793 static void
1794 wxgtk_renderer_editing_started( GtkCellRenderer *WXUNUSED(cell), GtkCellEditable *editable,
1795 gchar *path, wxDataViewRenderer *wxrenderer )
1796 {
1797 if (!editable)
1798 return;
1799
1800 wxDataViewColumn *column = wxrenderer->GetOwner();
1801 wxDataViewCtrl *dv = column->GetOwner();
1802 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, dv->GetId() );
1803 event.SetDataViewColumn( column );
1804 event.SetModel( dv->GetModel() );
1805 wxDataViewItem item(dv->GTKPathToItem(wxGtkTreePath(path)));
1806 event.SetItem( item );
1807 dv->HandleWindowEvent( event );
1808
1809 if (GTK_IS_CELL_EDITABLE(editable))
1810 {
1811 s_user_data = item.GetID();
1812
1813 g_signal_connect (GTK_CELL_EDITABLE (editable), "editing_done",
1814 G_CALLBACK (wxgtk_cell_editable_editing_done),
1815 (gpointer) wxrenderer );
1816
1817 }
1818 }
1819
1820
1821 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
1822
1823 wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode,
1824 int align ) :
1825 wxDataViewRendererBase( varianttype, mode, align )
1826 {
1827 m_renderer = NULL;
1828 m_mode = mode;
1829
1830 // we haven't changed them yet
1831 m_usingDefaultAttrs = true;
1832
1833 // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
1834 // after the m_renderer pointer has been initialized
1835 }
1836
1837 void wxDataViewRenderer::GtkPackIntoColumn(GtkTreeViewColumn *column)
1838 {
1839 gtk_tree_view_column_pack_end( column, m_renderer, TRUE /* expand */);
1840 }
1841
1842 void wxDataViewRenderer::GtkInitHandlers()
1843 {
1844 #ifndef __WXGTK3__
1845 if (!gtk_check_version(2,6,0))
1846 #endif
1847 {
1848 g_signal_connect (GTK_CELL_RENDERER(m_renderer), "editing_started",
1849 G_CALLBACK (wxgtk_renderer_editing_started),
1850 this);
1851 }
1852 }
1853
1854 void wxDataViewRenderer::SetMode( wxDataViewCellMode mode )
1855 {
1856 GtkCellRendererMode gtkMode;
1857 switch (mode)
1858 {
1859 case wxDATAVIEW_CELL_INERT:
1860 gtkMode = GTK_CELL_RENDERER_MODE_INERT;
1861 break;
1862
1863 case wxDATAVIEW_CELL_ACTIVATABLE:
1864 gtkMode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
1865 break;
1866
1867 case wxDATAVIEW_CELL_EDITABLE:
1868 gtkMode = GTK_CELL_RENDERER_MODE_EDITABLE;
1869 break;
1870
1871 default:
1872 wxFAIL_MSG( "unknown wxDataViewCellMode value" );
1873 return;
1874 }
1875
1876 m_mode = mode;
1877
1878 // This value is most often ignored in GtkTreeView
1879 GValue gvalue = { 0, };
1880 g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
1881 g_value_set_enum( &gvalue, gtkMode );
1882 g_object_set_property( G_OBJECT(m_renderer), "mode", &gvalue );
1883 g_value_unset( &gvalue );
1884 }
1885
1886 wxDataViewCellMode wxDataViewRenderer::GetMode() const
1887 {
1888 wxDataViewCellMode ret;
1889
1890 GValue gvalue;
1891 g_object_get( G_OBJECT(m_renderer), "mode", &gvalue, NULL);
1892
1893 switch (g_value_get_enum(&gvalue))
1894 {
1895 default:
1896 wxFAIL_MSG( "unknown GtkCellRendererMode value" );
1897 // fall through (we have to return something)
1898
1899 case GTK_CELL_RENDERER_MODE_INERT:
1900 ret = wxDATAVIEW_CELL_INERT;
1901 break;
1902
1903 case GTK_CELL_RENDERER_MODE_ACTIVATABLE:
1904 ret = wxDATAVIEW_CELL_ACTIVATABLE;
1905 break;
1906
1907 case GTK_CELL_RENDERER_MODE_EDITABLE:
1908 ret = wxDATAVIEW_CELL_EDITABLE;
1909 break;
1910 }
1911
1912 g_value_unset( &gvalue );
1913
1914 return ret;
1915 }
1916
1917 void wxDataViewRenderer::GtkApplyAlignment(GtkCellRenderer *renderer)
1918 {
1919 int align = m_alignment;
1920
1921 // query alignment from column ?
1922 if (align == -1)
1923 {
1924 // None there yet
1925 if (GetOwner() == NULL)
1926 return;
1927
1928 align = GetOwner()->GetAlignment();
1929 align |= wxALIGN_CENTRE_VERTICAL;
1930 }
1931
1932 // horizontal alignment:
1933
1934 gfloat xalign = 0.0;
1935 if (align & wxALIGN_RIGHT)
1936 xalign = 1.0;
1937 else if (align & wxALIGN_CENTER_HORIZONTAL)
1938 xalign = 0.5;
1939
1940 GValue gvalue = { 0, };
1941 g_value_init( &gvalue, G_TYPE_FLOAT );
1942 g_value_set_float( &gvalue, xalign );
1943 g_object_set_property( G_OBJECT(renderer), "xalign", &gvalue );
1944 g_value_unset( &gvalue );
1945
1946 // vertical alignment:
1947
1948 gfloat yalign = 0.0;
1949 if (align & wxALIGN_BOTTOM)
1950 yalign = 1.0;
1951 else if (align & wxALIGN_CENTER_VERTICAL)
1952 yalign = 0.5;
1953
1954 GValue gvalue2 = { 0, };
1955 g_value_init( &gvalue2, G_TYPE_FLOAT );
1956 g_value_set_float( &gvalue2, yalign );
1957 g_object_set_property( G_OBJECT(renderer), "yalign", &gvalue2 );
1958 g_value_unset( &gvalue2 );
1959 }
1960
1961 void wxDataViewRenderer::SetAlignment( int align )
1962 {
1963 m_alignment = align;
1964 GtkUpdateAlignment();
1965 }
1966
1967 int wxDataViewRenderer::GetAlignment() const
1968 {
1969 return m_alignment;
1970 }
1971
1972 void wxDataViewRenderer::EnableEllipsize(wxEllipsizeMode mode)
1973 {
1974 #ifdef __WXGTK26__
1975 #ifndef __WXGTK3__
1976 if ( gtk_check_version(2, 6, 0) != NULL )
1977 return;
1978 #endif
1979
1980 GtkCellRendererText * const rend = GtkGetTextRenderer();
1981 if ( !rend )
1982 return;
1983
1984 // we use the same values in wxEllipsizeMode as PangoEllipsizeMode so we
1985 // can just cast between them
1986 GValue gvalue = { 0, };
1987 g_value_init( &gvalue, PANGO_TYPE_ELLIPSIZE_MODE );
1988 g_value_set_enum( &gvalue, static_cast<PangoEllipsizeMode>(mode) );
1989 g_object_set_property( G_OBJECT(rend), "ellipsize", &gvalue );
1990 g_value_unset( &gvalue );
1991 #else // GTK < 2.6
1992 wxUnusedVar(mode);
1993 #endif // GTK 2.6/before
1994 }
1995
1996 wxEllipsizeMode wxDataViewRenderer::GetEllipsizeMode() const
1997 {
1998 #ifdef __WXGTK26__
1999 #ifndef __WXGTK3__
2000 if ( gtk_check_version(2, 6, 0) != NULL )
2001 return wxELLIPSIZE_NONE;
2002 #endif
2003
2004 GtkCellRendererText * const rend = GtkGetTextRenderer();
2005 if ( !rend )
2006 return wxELLIPSIZE_NONE;
2007
2008 GValue gvalue = { 0, };
2009 g_value_init( &gvalue, PANGO_TYPE_ELLIPSIZE_MODE );
2010 g_object_get_property( G_OBJECT(rend), "ellipsize", &gvalue );
2011 wxEllipsizeMode
2012 mode = static_cast<wxEllipsizeMode>(g_value_get_enum( &gvalue ));
2013 g_value_unset( &gvalue );
2014
2015 return mode;
2016 #else // GTK < 2.6
2017 return wxELLIPSIZE_NONE;
2018 #endif // GTK 2.6/before
2019 }
2020
2021 void
2022 wxDataViewRenderer::GtkOnTextEdited(const char *itempath, const wxString& str)
2023 {
2024 wxVariant value(str);
2025 if (!Validate( value ))
2026 return;
2027
2028 wxDataViewItem
2029 item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath)));
2030
2031 GtkOnCellChanged(value, item, GetOwner()->GetModelColumn());
2032 }
2033
2034 void
2035 wxDataViewRenderer::GtkOnCellChanged(const wxVariant& value,
2036 const wxDataViewItem& item,
2037 unsigned col)
2038 {
2039 wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2040 model->ChangeValue( value, item, col );
2041 }
2042
2043 // ---------------------------------------------------------
2044 // wxDataViewTextRenderer
2045 // ---------------------------------------------------------
2046
2047 extern "C"
2048 {
2049
2050 static void wxGtkTextRendererEditedCallback( GtkCellRendererText *WXUNUSED(renderer),
2051 gchar *arg1, gchar *arg2, gpointer user_data )
2052 {
2053 wxDataViewRenderer *cell = (wxDataViewRenderer*) user_data;
2054
2055 cell->GtkOnTextEdited(arg1, wxGTK_CONV_BACK_FONT(
2056 arg2, cell->GetOwner()->GetOwner()->GetFont()));
2057 }
2058
2059 }
2060
2061 namespace
2062 {
2063
2064 // helper function used by wxDataViewTextRenderer and
2065 // wxDataViewCustomRenderer::RenderText(): it applies the attributes to the
2066 // given text renderer and returns true if anything was done
2067 bool GtkApplyAttr(GtkCellRendererText *renderer, const wxDataViewItemAttr& attr)
2068 {
2069 bool usingDefaultAttrs = true;
2070 if (attr.HasColour())
2071 {
2072 const GdkColor * const gcol = attr.GetColour().GetColor();
2073
2074 GValue gvalue = { 0, };
2075 g_value_init( &gvalue, GDK_TYPE_COLOR );
2076 g_value_set_boxed( &gvalue, gcol );
2077 g_object_set_property( G_OBJECT(renderer), "foreground_gdk", &gvalue );
2078 g_value_unset( &gvalue );
2079
2080 usingDefaultAttrs = false;
2081 }
2082 else
2083 {
2084 GValue gvalue = { 0, };
2085 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2086 g_value_set_boolean( &gvalue, FALSE );
2087 g_object_set_property( G_OBJECT(renderer), "foreground-set", &gvalue );
2088 g_value_unset( &gvalue );
2089 }
2090
2091 if (attr.GetItalic())
2092 {
2093 GValue gvalue = { 0, };
2094 g_value_init( &gvalue, PANGO_TYPE_STYLE );
2095 g_value_set_enum( &gvalue, PANGO_STYLE_ITALIC );
2096 g_object_set_property( G_OBJECT(renderer), "style", &gvalue );
2097 g_value_unset( &gvalue );
2098
2099 usingDefaultAttrs = false;
2100 }
2101 else
2102 {
2103 GValue gvalue = { 0, };
2104 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2105 g_value_set_boolean( &gvalue, FALSE );
2106 g_object_set_property( G_OBJECT(renderer), "style-set", &gvalue );
2107 g_value_unset( &gvalue );
2108 }
2109
2110
2111 if (attr.GetBold())
2112 {
2113 GValue gvalue = { 0, };
2114 g_value_init( &gvalue, PANGO_TYPE_WEIGHT );
2115 g_value_set_enum( &gvalue, PANGO_WEIGHT_BOLD );
2116 g_object_set_property( G_OBJECT(renderer), "weight", &gvalue );
2117 g_value_unset( &gvalue );
2118
2119 usingDefaultAttrs = false;
2120 }
2121 else
2122 {
2123 GValue gvalue = { 0, };
2124 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2125 g_value_set_boolean( &gvalue, FALSE );
2126 g_object_set_property( G_OBJECT(renderer), "weight-set", &gvalue );
2127 g_value_unset( &gvalue );
2128 }
2129
2130 #if 0
2131 if (attr.HasBackgroundColour())
2132 {
2133 wxColour colour = attr.GetBackgroundColour();
2134 const GdkColor * const gcol = colour.GetColor();
2135
2136 GValue gvalue = { 0, };
2137 g_value_init( &gvalue, GDK_TYPE_COLOR );
2138 g_value_set_boxed( &gvalue, gcol );
2139 g_object_set_property( G_OBJECT(renderer), "cell-background_gdk", &gvalue );
2140 g_value_unset( &gvalue );
2141 }
2142 else
2143 {
2144 GValue gvalue = { 0, };
2145 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2146 g_value_set_boolean( &gvalue, FALSE );
2147 g_object_set_property( G_OBJECT(renderer), "cell-background-set", &gvalue );
2148 g_value_unset( &gvalue );
2149 }
2150 #endif
2151
2152 return !usingDefaultAttrs;
2153 }
2154
2155 } // anonymous namespace
2156
2157 IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewRenderer)
2158
2159 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, wxDataViewCellMode mode,
2160 int align ) :
2161 wxDataViewRenderer( varianttype, mode, align )
2162 {
2163 GtkWxCellRendererText *text_renderer = gtk_wx_cell_renderer_text_new();
2164 text_renderer->wx_renderer = this;
2165 m_renderer = (GtkCellRenderer*) text_renderer;
2166
2167 if (mode & wxDATAVIEW_CELL_EDITABLE)
2168 {
2169 GValue gvalue = { 0, };
2170 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2171 g_value_set_boolean( &gvalue, true );
2172 g_object_set_property( G_OBJECT(m_renderer), "editable", &gvalue );
2173 g_value_unset( &gvalue );
2174
2175 g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
2176
2177 GtkInitHandlers();
2178 }
2179
2180 SetMode(mode);
2181 SetAlignment(align);
2182 }
2183
2184 bool wxDataViewTextRenderer::SetTextValue(const wxString& str)
2185 {
2186 GValue gvalue = { 0, };
2187 g_value_init( &gvalue, G_TYPE_STRING );
2188 g_value_set_string( &gvalue, wxGTK_CONV_FONT( str, GetOwner()->GetOwner()->GetFont() ) );
2189 g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2190 g_value_unset( &gvalue );
2191
2192 return true;
2193 }
2194
2195 bool wxDataViewTextRenderer::GetTextValue(wxString& str) const
2196 {
2197 GValue gvalue = { 0, };
2198 g_value_init( &gvalue, G_TYPE_STRING );
2199 g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
2200 str = wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue ), const_cast<wxDataViewTextRenderer*>(this)->GetOwner()->GetOwner()->GetFont() );
2201 g_value_unset( &gvalue );
2202
2203 return true;
2204 }
2205
2206 void wxDataViewTextRenderer::SetAlignment( int align )
2207 {
2208 wxDataViewRenderer::SetAlignment(align);
2209
2210 #ifndef __WXGTK3__
2211 if (gtk_check_version(2,10,0))
2212 return;
2213 #endif
2214
2215 // horizontal alignment:
2216 PangoAlignment pangoAlign = PANGO_ALIGN_LEFT;
2217 if (align & wxALIGN_RIGHT)
2218 pangoAlign = PANGO_ALIGN_RIGHT;
2219 else if (align & wxALIGN_CENTER_HORIZONTAL)
2220 pangoAlign = PANGO_ALIGN_CENTER;
2221
2222 GValue gvalue = { 0, };
2223 g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
2224 g_value_set_enum( &gvalue, pangoAlign );
2225 g_object_set_property( G_OBJECT(m_renderer), "alignment", &gvalue );
2226 g_value_unset( &gvalue );
2227 }
2228
2229 bool wxDataViewTextRenderer::GtkSetAttr(const wxDataViewItemAttr& attr)
2230 {
2231 return GtkApplyAttr(GtkGetTextRenderer(), attr);
2232 }
2233
2234 GtkCellRendererText *wxDataViewTextRenderer::GtkGetTextRenderer() const
2235 {
2236 return GTK_CELL_RENDERER_TEXT(m_renderer);
2237 }
2238
2239 // ---------------------------------------------------------
2240 // wxDataViewBitmapRenderer
2241 // ---------------------------------------------------------
2242
2243 namespace
2244 {
2245
2246 // set "pixbuf" property on the given renderer
2247 void SetPixbufProp(GtkCellRenderer *renderer, GdkPixbuf *pixbuf)
2248 {
2249 GValue gvalue = { 0, };
2250 g_value_init( &gvalue, G_TYPE_OBJECT );
2251 g_value_set_object( &gvalue, pixbuf );
2252 g_object_set_property( G_OBJECT(renderer), "pixbuf", &gvalue );
2253 g_value_unset( &gvalue );
2254 }
2255
2256 } // anonymous namespace
2257
2258 IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewRenderer)
2259
2260 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, wxDataViewCellMode mode,
2261 int align ) :
2262 wxDataViewRenderer( varianttype, mode, align )
2263 {
2264 m_renderer = gtk_cell_renderer_pixbuf_new();
2265
2266 SetMode(mode);
2267 SetAlignment(align);
2268 }
2269
2270 bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
2271 {
2272 if (value.GetType() == wxT("wxBitmap"))
2273 {
2274 wxBitmap bitmap;
2275 bitmap << value;
2276
2277 // GetPixbuf() may create a Pixbuf representation in the wxBitmap
2278 // object (and it will stay there and remain owned by wxBitmap)
2279 SetPixbufProp(m_renderer, bitmap.GetPixbuf());
2280 }
2281 else if (value.GetType() == wxT("wxIcon"))
2282 {
2283 wxIcon icon;
2284 icon << value;
2285
2286 SetPixbufProp(m_renderer, icon.GetPixbuf());
2287 }
2288 else
2289 {
2290 return false;
2291 }
2292
2293 return true;
2294 }
2295
2296 bool wxDataViewBitmapRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
2297 {
2298 return false;
2299 }
2300
2301 // ---------------------------------------------------------
2302 // wxDataViewToggleRenderer
2303 // ---------------------------------------------------------
2304
2305 extern "C" {
2306 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
2307 gchar *path, gpointer user_data );
2308 }
2309
2310 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
2311 gchar *path, gpointer user_data )
2312 {
2313 wxDataViewToggleRenderer *cell = (wxDataViewToggleRenderer*) user_data;
2314
2315 // get old value
2316 GValue gvalue = { 0, };
2317 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2318 g_object_get_property( G_OBJECT(renderer), "active", &gvalue );
2319 // invert it
2320 wxVariant value = !g_value_get_boolean( &gvalue );
2321 g_value_unset( &gvalue );
2322
2323 if (!cell->Validate( value ))
2324 return;
2325
2326 wxDataViewCtrl * const ctrl = cell->GetOwner()->GetOwner();
2327 wxDataViewModel *model = ctrl->GetModel();
2328
2329 wxDataViewItem item(ctrl->GTKPathToItem(wxGtkTreePath(path)));
2330
2331 unsigned int model_col = cell->GetOwner()->GetModelColumn();
2332
2333 model->ChangeValue( value, item, model_col );
2334 }
2335
2336 IMPLEMENT_CLASS(wxDataViewToggleRenderer, wxDataViewRenderer)
2337
2338 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
2339 wxDataViewCellMode mode, int align ) :
2340 wxDataViewRenderer( varianttype, mode, align )
2341 {
2342 m_renderer = (GtkCellRenderer*) gtk_cell_renderer_toggle_new();
2343
2344 if (mode & wxDATAVIEW_CELL_ACTIVATABLE)
2345 {
2346 g_signal_connect_after( m_renderer, "toggled",
2347 G_CALLBACK(wxGtkToggleRendererToggledCallback), this );
2348 }
2349 else
2350 {
2351 GValue gvalue = { 0, };
2352 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2353 g_value_set_boolean( &gvalue, false );
2354 g_object_set_property( G_OBJECT(m_renderer), "activatable", &gvalue );
2355 g_value_unset( &gvalue );
2356 }
2357
2358 SetMode(mode);
2359 SetAlignment(align);
2360 }
2361
2362 bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
2363 {
2364 bool tmp = value;
2365
2366 GValue gvalue = { 0, };
2367 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2368 g_value_set_boolean( &gvalue, tmp );
2369 g_object_set_property( G_OBJECT(m_renderer), "active", &gvalue );
2370 g_value_unset( &gvalue );
2371
2372 return true;
2373 }
2374
2375 bool wxDataViewToggleRenderer::GetValue( wxVariant &value ) const
2376 {
2377 GValue gvalue = { 0, };
2378 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2379 g_object_get_property( G_OBJECT(m_renderer), "active", &gvalue );
2380 value = g_value_get_boolean( &gvalue ) != 0;
2381 g_value_unset( &gvalue );
2382
2383 return true;
2384 }
2385
2386 // ---------------------------------------------------------
2387 // wxDataViewCustomRenderer
2388 // ---------------------------------------------------------
2389
2390 #ifndef __WXGTK3__
2391 class wxDataViewCtrlDCImpl: public wxWindowDCImpl
2392 {
2393 public:
2394 wxDataViewCtrlDCImpl( wxDC *owner, wxDataViewCtrl *window ) :
2395 wxWindowDCImpl( owner )
2396 {
2397 GtkWidget *widget = window->m_treeview;
2398 // Set later
2399 m_gdkwindow = NULL;
2400
2401 m_window = window;
2402
2403 m_context = window->GTKGetPangoDefaultContext();
2404 m_layout = pango_layout_new( m_context );
2405 m_fontdesc = pango_font_description_copy(gtk_widget_get_style(widget)->font_desc);
2406
2407 m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
2408
2409 // Set m_gdkwindow later
2410 // SetUpDC();
2411 }
2412 };
2413
2414 class wxDataViewCtrlDC: public wxWindowDC
2415 {
2416 public:
2417 wxDataViewCtrlDC( wxDataViewCtrl *window ) :
2418 wxWindowDC( new wxDataViewCtrlDCImpl( this, window ) )
2419 { }
2420 };
2421 #endif
2422
2423 // ---------------------------------------------------------
2424 // wxDataViewCustomRenderer
2425 // ---------------------------------------------------------
2426
2427 IMPLEMENT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
2428
2429 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
2430 wxDataViewCellMode mode,
2431 int align,
2432 bool no_init )
2433 : wxDataViewCustomRendererBase( varianttype, mode, align )
2434 {
2435 m_dc = NULL;
2436 m_text_renderer = NULL;
2437 m_renderParams = NULL;
2438
2439 if (no_init)
2440 m_renderer = NULL;
2441 else
2442 Init(mode, align);
2443 }
2444
2445 void wxDataViewCustomRenderer::GtkInitTextRenderer()
2446 {
2447 m_text_renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
2448 g_object_ref_sink(m_text_renderer);
2449
2450 GtkApplyAlignment(GTK_CELL_RENDERER(m_text_renderer));
2451 }
2452
2453 GtkCellRendererText *wxDataViewCustomRenderer::GtkGetTextRenderer() const
2454 {
2455 if ( !m_text_renderer )
2456 {
2457 // we create it on demand so need to do it even from a const function
2458 const_cast<wxDataViewCustomRenderer *>(this)->GtkInitTextRenderer();
2459 }
2460
2461 return m_text_renderer;
2462 }
2463
2464 void wxDataViewCustomRenderer::RenderText( const wxString &text,
2465 int xoffset,
2466 wxRect cell,
2467 wxDC *WXUNUSED(dc),
2468 int WXUNUSED(state) )
2469 {
2470
2471 GtkCellRendererText * const textRenderer = GtkGetTextRenderer();
2472
2473 GValue gvalue = { 0, };
2474 g_value_init( &gvalue, G_TYPE_STRING );
2475 g_value_set_string( &gvalue, wxGTK_CONV_FONT( text, GetOwner()->GetOwner()->GetFont() ) );
2476 g_object_set_property( G_OBJECT(textRenderer), "text", &gvalue );
2477 g_value_unset( &gvalue );
2478
2479 GtkApplyAttr(textRenderer, GetAttr());
2480
2481 GdkRectangle cell_area;
2482 wxRectToGDKRect(cell, cell_area);
2483 cell_area.x += xoffset;
2484 cell_area.width -= xoffset;
2485
2486 gtk_cell_renderer_render( GTK_CELL_RENDERER(textRenderer),
2487 #ifdef __WXGTK3__
2488 m_renderParams->cr,
2489 #else
2490 m_renderParams->window,
2491 #endif
2492 m_renderParams->widget,
2493 m_renderParams->background_area,
2494 &cell_area,
2495 #ifndef __WXGTK3__
2496 m_renderParams->expose_area,
2497 #endif
2498 GtkCellRendererState(m_renderParams->flags));
2499 }
2500
2501 bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode, int align)
2502 {
2503 GtkWxCellRenderer *renderer = (GtkWxCellRenderer *) gtk_wx_cell_renderer_new();
2504 renderer->cell = this;
2505
2506 m_renderer = (GtkCellRenderer*) renderer;
2507
2508 SetMode(mode);
2509 SetAlignment(align);
2510
2511 GtkInitHandlers();
2512
2513 return true;
2514 }
2515
2516 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
2517 {
2518 if (m_dc)
2519 delete m_dc;
2520
2521 if (m_text_renderer)
2522 g_object_unref(m_text_renderer);
2523 }
2524
2525 wxDC *wxDataViewCustomRenderer::GetDC()
2526 {
2527 if (m_dc == NULL)
2528 {
2529 #ifdef __WXGTK3__
2530 wxASSERT(m_renderParams);
2531 cairo_t* cr = m_renderParams->cr;
2532 wxASSERT(cr && cairo_status(cr) == 0);
2533 m_dc = new wxGTKCairoDC(cr);
2534 #else
2535 if (GetOwner() == NULL)
2536 return NULL;
2537 if (GetOwner()->GetOwner() == NULL)
2538 return NULL;
2539 m_dc = new wxDataViewCtrlDC( GetOwner()->GetOwner() );
2540 #endif
2541 }
2542
2543 return m_dc;
2544 }
2545
2546 // ---------------------------------------------------------
2547 // wxDataViewProgressRenderer
2548 // ---------------------------------------------------------
2549
2550 IMPLEMENT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
2551
2552 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
2553 const wxString &varianttype, wxDataViewCellMode mode, int align ) :
2554 wxDataViewCustomRenderer( varianttype, mode, align, true )
2555 {
2556 m_label = label;
2557 m_value = 0;
2558
2559 #ifdef __WXGTK26__
2560 if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,6,0) == NULL)
2561 {
2562 m_renderer = (GtkCellRenderer*) gtk_cell_renderer_progress_new();
2563
2564 SetMode(mode);
2565 SetAlignment(align);
2566
2567 #if !wxUSE_UNICODE
2568 // We can't initialize the renderer just yet because we don't have the
2569 // pointer to the column that uses this renderer yet and so attempt to
2570 // dereference GetOwner() to get the font that is used as a source of
2571 // encoding in multibyte-to-Unicode conversion in GTKSetLabel() in
2572 // non-Unicode builds would crash. So simply remember to do it later.
2573 if ( !m_label.empty() )
2574 m_needsToSetLabel = true;
2575 else
2576 #endif // !wxUSE_UNICODE
2577 GTKSetLabel();
2578 }
2579 else
2580 #endif
2581 {
2582 // Use custom cell code
2583 wxDataViewCustomRenderer::Init(mode, align);
2584 }
2585 }
2586
2587 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
2588 {
2589 }
2590
2591 void wxDataViewProgressRenderer::GTKSetLabel()
2592 {
2593 GValue gvalue = { 0, };
2594 g_value_init( &gvalue, G_TYPE_STRING );
2595
2596 // Take care to not use GetOwner() here if the label is empty, we can be
2597 // called from ctor when GetOwner() is still NULL in this case.
2598 wxScopedCharBuffer buf;
2599 if ( m_label.empty() )
2600 buf = wxScopedCharBuffer::CreateNonOwned("");
2601 else
2602 buf = wxGTK_CONV_FONT(m_label, GetOwner()->GetOwner()->GetFont());
2603
2604 g_value_set_string( &gvalue, buf);
2605 g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2606 g_value_unset( &gvalue );
2607
2608 #if !wxUSE_UNICODE
2609 m_needsToSetLabel = false;
2610 #endif // !wxUSE_UNICODE
2611 }
2612
2613 bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
2614 {
2615 #ifdef __WXGTK26__
2616 if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,6,0) == NULL)
2617 {
2618 #if !wxUSE_UNICODE
2619 if ( m_needsToSetLabel )
2620 GTKSetLabel();
2621 #endif // !wxUSE_UNICODE
2622
2623 gint tmp = (long) value;
2624 GValue gvalue = { 0, };
2625 g_value_init( &gvalue, G_TYPE_INT );
2626 g_value_set_int( &gvalue, tmp );
2627 g_object_set_property( G_OBJECT(m_renderer), "value", &gvalue );
2628 g_value_unset( &gvalue );
2629 }
2630 else
2631 #endif
2632 {
2633 m_value = (long) value;
2634
2635 if (m_value < 0) m_value = 0;
2636 if (m_value > 100) m_value = 100;
2637 }
2638
2639 return true;
2640 }
2641
2642 bool wxDataViewProgressRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
2643 {
2644 return false;
2645 }
2646
2647 bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
2648 {
2649 double pct = (double)m_value / 100.0;
2650 wxRect bar = cell;
2651 bar.width = (int)(cell.width * pct);
2652 dc->SetPen( *wxTRANSPARENT_PEN );
2653 dc->SetBrush( *wxBLUE_BRUSH );
2654 dc->DrawRectangle( bar );
2655
2656 dc->SetBrush( *wxTRANSPARENT_BRUSH );
2657 dc->SetPen( *wxBLACK_PEN );
2658 dc->DrawRectangle( cell );
2659
2660 return true;
2661 }
2662
2663 wxSize wxDataViewProgressRenderer::GetSize() const
2664 {
2665 return wxSize(40,12);
2666 }
2667
2668 // -------------------------------------
2669 // wxDataViewChoiceRenderer
2670 // -------------------------------------
2671
2672 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString &choices,
2673 wxDataViewCellMode mode, int alignment ) :
2674 wxDataViewCustomRenderer( "string", mode, alignment, true )
2675 {
2676 m_choices = choices;
2677
2678 #ifdef __WXGTK26__
2679 if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,6,0) == NULL)
2680 {
2681 m_renderer = (GtkCellRenderer*) gtk_cell_renderer_combo_new();
2682
2683 GtkListStore *store = gtk_list_store_new( 1, G_TYPE_STRING );
2684 for (size_t n = 0; n < m_choices.GetCount(); n++)
2685 {
2686 gtk_list_store_insert_with_values(
2687 store, NULL, n, 0,
2688 static_cast<const char *>(m_choices[n].utf8_str()), -1 );
2689 }
2690
2691 g_object_set (m_renderer,
2692 "model", store,
2693 "text-column", 0,
2694 "has-entry", FALSE,
2695 NULL);
2696
2697 bool editable = (mode & wxDATAVIEW_CELL_EDITABLE) != 0;
2698 g_object_set (m_renderer, "editable", editable, NULL);
2699
2700 SetAlignment(alignment);
2701
2702 g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
2703
2704 GtkInitHandlers();
2705 }
2706 else
2707 #endif
2708 {
2709 // Use custom cell code
2710 wxDataViewCustomRenderer::Init(mode, alignment);
2711 }
2712 }
2713
2714 bool wxDataViewChoiceRenderer::Render( wxRect rect, wxDC *dc, int state )
2715 {
2716 RenderText( m_data, 0, rect, dc, state );
2717 return true;
2718 }
2719
2720 wxSize wxDataViewChoiceRenderer::GetSize() const
2721 {
2722 return wxSize(70,20);
2723 }
2724
2725 bool wxDataViewChoiceRenderer::SetValue( const wxVariant &value )
2726 {
2727
2728 #ifdef __WXGTK26__
2729 if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,6,0) == NULL)
2730 {
2731 GValue gvalue = { 0, };
2732 g_value_init( &gvalue, G_TYPE_STRING );
2733 g_value_set_string(&gvalue,
2734 wxGTK_CONV_FONT(value.GetString(),
2735 GetOwner()->GetOwner()->GetFont()));
2736 g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2737 g_value_unset( &gvalue );
2738 }
2739 else
2740 #endif
2741 m_data = value.GetString();
2742
2743 return true;
2744 }
2745
2746 bool wxDataViewChoiceRenderer::GetValue( wxVariant &value ) const
2747 {
2748 #ifdef __WXGTK26__
2749 if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,6,0) == NULL)
2750 {
2751 GValue gvalue = { 0, };
2752 g_value_init( &gvalue, G_TYPE_STRING );
2753 g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
2754 wxString temp = wxGTK_CONV_BACK_FONT(g_value_get_string(&gvalue),
2755 GetOwner()->GetOwner()->GetFont());
2756 g_value_unset( &gvalue );
2757 value = temp;
2758
2759 //wxPrintf( "temp %s\n", temp );
2760 // TODO: remove this code
2761 }
2762 else
2763 #endif
2764 value = m_data;
2765
2766 return true;
2767 }
2768
2769 void wxDataViewChoiceRenderer::SetAlignment( int align )
2770 {
2771 wxDataViewCustomRenderer::SetAlignment(align);
2772
2773 #ifndef __WXGTK3__
2774 if (gtk_check_version(2,10,0))
2775 return;
2776 #endif
2777
2778 // horizontal alignment:
2779 PangoAlignment pangoAlign = PANGO_ALIGN_LEFT;
2780 if (align & wxALIGN_RIGHT)
2781 pangoAlign = PANGO_ALIGN_RIGHT;
2782 else if (align & wxALIGN_CENTER_HORIZONTAL)
2783 pangoAlign = PANGO_ALIGN_CENTER;
2784
2785 GValue gvalue = { 0, };
2786 g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
2787 g_value_set_enum( &gvalue, pangoAlign );
2788 g_object_set_property( G_OBJECT(m_renderer), "alignment", &gvalue );
2789 g_value_unset( &gvalue );
2790 }
2791
2792 // ----------------------------------------------------------------------------
2793 // wxDataViewChoiceByIndexRenderer
2794 // ----------------------------------------------------------------------------
2795
2796 wxDataViewChoiceByIndexRenderer::wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
2797 wxDataViewCellMode mode, int alignment ) :
2798 wxDataViewChoiceRenderer( choices, mode, alignment )
2799 {
2800 }
2801
2802 void wxDataViewChoiceByIndexRenderer::GtkOnTextEdited(const char *itempath, const wxString& str)
2803 {
2804 wxVariant value( (long) GetChoices().Index( str ) );
2805
2806 if (!Validate( value ))
2807 return;
2808
2809 wxDataViewItem
2810 item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath)));
2811
2812 GtkOnCellChanged(value, item, GetOwner()->GetModelColumn());
2813 }
2814
2815 bool wxDataViewChoiceByIndexRenderer::SetValue( const wxVariant &value )
2816 {
2817 wxVariant string_value = GetChoice( value.GetLong() );
2818 return wxDataViewChoiceRenderer::SetValue( string_value );
2819 }
2820
2821 bool wxDataViewChoiceByIndexRenderer::GetValue( wxVariant &value ) const
2822 {
2823 wxVariant string_value;
2824 if (!wxDataViewChoiceRenderer::GetValue( string_value ))
2825 return false;
2826
2827 value = (long) GetChoices().Index( string_value.GetString() );
2828 return true;
2829 }
2830
2831 // ---------------------------------------------------------
2832 // wxDataViewIconTextRenderer
2833 // ---------------------------------------------------------
2834
2835 IMPLEMENT_CLASS(wxDataViewIconTextRenderer, wxDataViewCustomRenderer)
2836
2837 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer
2838 (
2839 const wxString &varianttype,
2840 wxDataViewCellMode mode,
2841 int align
2842 )
2843 : wxDataViewTextRenderer(varianttype, mode, align)
2844 {
2845 m_rendererIcon = gtk_cell_renderer_pixbuf_new();
2846 }
2847
2848 wxDataViewIconTextRenderer::~wxDataViewIconTextRenderer()
2849 {
2850 }
2851
2852 void wxDataViewIconTextRenderer::GtkPackIntoColumn(GtkTreeViewColumn *column)
2853 {
2854 // add the icon renderer first
2855 gtk_tree_view_column_pack_start(column, m_rendererIcon, FALSE /* !expand */);
2856
2857 // add the text renderer too
2858 wxDataViewRenderer::GtkPackIntoColumn(column);
2859 }
2860
2861 bool wxDataViewIconTextRenderer::SetValue( const wxVariant &value )
2862 {
2863 m_value << value;
2864
2865 SetTextValue(m_value.GetText());
2866
2867 const wxIcon& icon = m_value.GetIcon();
2868 SetPixbufProp(m_rendererIcon, icon.IsOk() ? icon.GetPixbuf() : NULL);
2869
2870 return true;
2871 }
2872
2873 bool wxDataViewIconTextRenderer::GetValue(wxVariant& value) const
2874 {
2875 wxString str;
2876 if ( !GetTextValue(str) )
2877 return false;
2878
2879 // user doesn't have any way to edit the icon so leave it unchanged
2880 value << wxDataViewIconText(str, m_value.GetIcon());
2881
2882 return true;
2883 }
2884
2885 void
2886 wxDataViewIconTextRenderer::GtkOnCellChanged(const wxVariant& value,
2887 const wxDataViewItem& item,
2888 unsigned col)
2889 {
2890 // we receive just the text part of our value as it's the only one which
2891 // can be edited, but we need the full wxDataViewIconText value for the
2892 // model
2893 wxVariant valueIconText;
2894 valueIconText << wxDataViewIconText(value.GetString(), m_value.GetIcon());
2895 wxDataViewTextRenderer::GtkOnCellChanged(valueIconText, item, col);
2896 }
2897
2898 // ---------------------------------------------------------
2899 // wxDataViewColumn
2900 // ---------------------------------------------------------
2901
2902
2903 static gboolean
2904 gtk_dataview_header_button_press_callback( GtkWidget *WXUNUSED(widget),
2905 GdkEventButton *gdk_event,
2906 wxDataViewColumn *column )
2907 {
2908 if (gdk_event->type != GDK_BUTTON_PRESS)
2909 return FALSE;
2910
2911 if (gdk_event->button == 1)
2912 {
2913 gs_lastLeftClickHeader = column;
2914
2915 wxDataViewCtrl *dv = column->GetOwner();
2916 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, dv->GetId() );
2917 event.SetDataViewColumn( column );
2918 event.SetModel( dv->GetModel() );
2919 if (dv->HandleWindowEvent( event ))
2920 return FALSE;
2921 }
2922
2923 if (gdk_event->button == 3)
2924 {
2925 wxDataViewCtrl *dv = column->GetOwner();
2926 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, dv->GetId() );
2927 event.SetDataViewColumn( column );
2928 event.SetModel( dv->GetModel() );
2929 if (dv->HandleWindowEvent( event ))
2930 return FALSE;
2931 }
2932
2933 return FALSE;
2934 }
2935
2936 extern "C"
2937 {
2938
2939 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *WXUNUSED(column),
2940 GtkCellRenderer *renderer,
2941 GtkTreeModel *model,
2942 GtkTreeIter *iter,
2943 gpointer data )
2944 {
2945 g_return_if_fail (GTK_IS_WX_TREE_MODEL (model));
2946 GtkWxTreeModel *tree_model = (GtkWxTreeModel *) model;
2947
2948 wxDataViewRenderer *cell = (wxDataViewRenderer*) data;
2949
2950 wxDataViewItem item( (void*) iter->user_data );
2951
2952 wxDataViewModel *wx_model = tree_model->internal->GetDataViewModel();
2953
2954 if (!wx_model->IsVirtualListModel())
2955 {
2956 gboolean visible;
2957 if (wx_model->IsContainer( item ))
2958 {
2959 visible = wx_model->HasContainerColumns( item ) ||
2960 (cell->GetOwner()->GetModelColumn() == 0);
2961 }
2962 else
2963 {
2964 visible = true;
2965 }
2966
2967 GValue gvalue = { 0, };
2968 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2969 g_value_set_boolean( &gvalue, visible );
2970 g_object_set_property( G_OBJECT(renderer), "visible", &gvalue );
2971 g_value_unset( &gvalue );
2972
2973 if ( !visible )
2974 return;
2975 }
2976
2977 wxVariant value;
2978 wx_model->GetValue( value, item, cell->GetOwner()->GetModelColumn() );
2979
2980 if (value.GetType() != cell->GetVariantType())
2981 {
2982 wxLogError( wxT("Wrong type, required: %s but: %s"),
2983 value.GetType().c_str(),
2984 cell->GetVariantType().c_str() );
2985 }
2986
2987 cell->SetValue( value );
2988
2989 // deal with disabled items
2990 bool enabled = wx_model->IsEnabled( item, cell->GetOwner()->GetModelColumn() );
2991
2992 // a) this sets the appearance to disabled grey
2993 GValue gvalue = { 0, };
2994 g_value_init( &gvalue, G_TYPE_BOOLEAN );
2995 g_value_set_boolean( &gvalue, enabled );
2996 g_object_set_property( G_OBJECT(renderer), "sensitive", &gvalue );
2997 g_value_unset( &gvalue );
2998
2999 // b) this actually disables the control/renderer
3000 if (enabled)
3001 cell->SetMode( cell->GtkGetMode() );
3002 else
3003 cell->SetMode( wxDATAVIEW_CELL_INERT );
3004
3005
3006 // deal with attributes: if the renderer doesn't support them at all, we
3007 // don't even need to query the model for them
3008 if ( !cell->GtkSupportsAttrs() )
3009 return;
3010
3011 // it can support attributes so check if this item has any
3012 wxDataViewItemAttr attr;
3013 if ( wx_model->GetAttr( item, cell->GetOwner()->GetModelColumn(), attr )
3014 || !cell->GtkIsUsingDefaultAttrs() )
3015 {
3016 bool usingDefaultAttrs = !cell->GtkSetAttr(attr);
3017 cell->GtkSetUsingDefaultAttrs(usingDefaultAttrs);
3018 }
3019 // else: no custom attributes specified and we're already using the default
3020 // ones -- nothing to do
3021
3022 }
3023
3024 } // extern "C"
3025
3026 #include <wx/listimpl.cpp>
3027 WX_DEFINE_LIST(wxDataViewColumnList)
3028
3029 wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell,
3030 unsigned int model_column, int width,
3031 wxAlignment align, int flags )
3032 : wxDataViewColumnBase( cell, model_column )
3033 {
3034 Init( align, flags, width );
3035
3036 SetTitle( title );
3037 }
3038
3039 wxDataViewColumn::wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *cell,
3040 unsigned int model_column, int width,
3041 wxAlignment align, int flags )
3042 : wxDataViewColumnBase( bitmap, cell, model_column )
3043 {
3044 Init( align, flags, width );
3045
3046 SetBitmap( bitmap );
3047 }
3048
3049 void wxDataViewColumn::Init(wxAlignment align, int flags, int width)
3050 {
3051 m_isConnected = false;
3052
3053 GtkTreeViewColumn *column = gtk_tree_view_column_new();
3054 m_column = (GtkWidget*) column;
3055
3056 SetFlags( flags );
3057 SetAlignment( align );
3058
3059 SetWidth( width );
3060
3061 // Create container for icon and label
3062 GtkWidget *box = gtk_hbox_new( FALSE, 1 );
3063 gtk_widget_show( box );
3064 // gtk_container_set_border_width((GtkContainer*)box, 2);
3065 m_image = gtk_image_new();
3066 gtk_box_pack_start(GTK_BOX(box), m_image, FALSE, FALSE, 1);
3067 m_label = gtk_label_new("");
3068 gtk_box_pack_end( GTK_BOX(box), GTK_WIDGET(m_label), FALSE, FALSE, 1 );
3069 gtk_tree_view_column_set_widget( column, box );
3070
3071 wxDataViewRenderer * const colRenderer = GetRenderer();
3072 GtkCellRenderer * const cellRenderer = colRenderer->GetGtkHandle();
3073
3074 colRenderer->GtkPackIntoColumn(column);
3075
3076 gtk_tree_view_column_set_cell_data_func( column, cellRenderer,
3077 wxGtkTreeCellDataFunc, (gpointer) colRenderer, NULL );
3078 }
3079
3080 void wxDataViewColumn::OnInternalIdle()
3081 {
3082 if (m_isConnected)
3083 return;
3084
3085 if (gtk_widget_get_realized(GetOwner()->m_treeview))
3086 {
3087 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3088 GtkWidget* button = gtk_tree_view_column_get_button(column);
3089 if (button)
3090 {
3091 g_signal_connect(button, "button_press_event",
3092 G_CALLBACK (gtk_dataview_header_button_press_callback), this);
3093
3094 // otherwise the event will be blocked by GTK+
3095 gtk_tree_view_column_set_clickable( column, TRUE );
3096
3097 m_isConnected = true;
3098 }
3099 }
3100 }
3101
3102 void wxDataViewColumn::SetOwner( wxDataViewCtrl *owner )
3103 {
3104 wxDataViewColumnBase::SetOwner( owner );
3105
3106 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3107
3108 gtk_tree_view_column_set_title( column, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
3109 }
3110
3111 void wxDataViewColumn::SetTitle( const wxString &title )
3112 {
3113 wxDataViewCtrl *ctrl = GetOwner();
3114 gtk_label_set_text( GTK_LABEL(m_label), ctrl ? wxGTK_CONV_FONT(title, ctrl->GetFont())
3115 : wxGTK_CONV_SYS(title) );
3116 if (title.empty())
3117 gtk_widget_hide( m_label );
3118 else
3119 gtk_widget_show( m_label );
3120 }
3121
3122 wxString wxDataViewColumn::GetTitle() const
3123 {
3124 return wxGTK_CONV_BACK_FONT(
3125 gtk_label_get_text( GTK_LABEL(m_label) ),
3126 GetOwner()->GetFont()
3127 );
3128 }
3129
3130 void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )
3131 {
3132 wxDataViewColumnBase::SetBitmap( bitmap );
3133
3134 if (bitmap.IsOk())
3135 {
3136 GtkImage *gtk_image = GTK_IMAGE(m_image);
3137
3138 gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image), bitmap.GetPixbuf());
3139 gtk_widget_show( m_image );
3140 }
3141 else
3142 {
3143 gtk_widget_hide( m_image );
3144 }
3145 }
3146
3147 void wxDataViewColumn::SetHidden( bool hidden )
3148 {
3149 gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column), !hidden );
3150 }
3151
3152 void wxDataViewColumn::SetResizeable( bool resizable )
3153 {
3154 gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column), resizable );
3155 }
3156
3157 void wxDataViewColumn::SetAlignment( wxAlignment align )
3158 {
3159 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3160
3161 gfloat xalign = 0.0;
3162 if (align == wxALIGN_RIGHT)
3163 xalign = 1.0;
3164 if (align == wxALIGN_CENTER_HORIZONTAL ||
3165 align == wxALIGN_CENTER)
3166 xalign = 0.5;
3167
3168 gtk_tree_view_column_set_alignment( column, xalign );
3169
3170 if (m_renderer && m_renderer->GetAlignment() == -1)
3171 m_renderer->GtkUpdateAlignment();
3172 }
3173
3174 wxAlignment wxDataViewColumn::GetAlignment() const
3175 {
3176 gfloat xalign = gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column) );
3177
3178 if (xalign == 1.0)
3179 return wxALIGN_RIGHT;
3180 if (xalign == 0.5)
3181 return wxALIGN_CENTER_HORIZONTAL;
3182
3183 return wxALIGN_LEFT;
3184 }
3185
3186 void wxDataViewColumn::SetSortable( bool sortable )
3187 {
3188 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3189
3190 if ( sortable )
3191 {
3192 gtk_tree_view_column_set_sort_column_id( column, GetModelColumn() );
3193 }
3194 else
3195 {
3196 gtk_tree_view_column_set_sort_column_id( column, -1 );
3197 gtk_tree_view_column_set_sort_indicator( column, FALSE );
3198 gtk_tree_view_column_set_clickable( column, FALSE );
3199 }
3200 }
3201
3202 bool wxDataViewColumn::IsSortable() const
3203 {
3204 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3205 return gtk_tree_view_column_get_clickable( column ) != 0;
3206 }
3207
3208 bool wxDataViewColumn::IsSortKey() const
3209 {
3210 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3211 return gtk_tree_view_column_get_sort_indicator( column ) != 0;
3212 }
3213
3214 bool wxDataViewColumn::IsResizeable() const
3215 {
3216 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3217 return gtk_tree_view_column_get_resizable( column ) != 0;
3218 }
3219
3220 bool wxDataViewColumn::IsHidden() const
3221 {
3222 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3223 return !gtk_tree_view_column_get_visible( column );
3224 }
3225
3226 void wxDataViewColumn::SetSortOrder( bool ascending )
3227 {
3228 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3229
3230 if (ascending)
3231 gtk_tree_view_column_set_sort_order( column, GTK_SORT_ASCENDING );
3232 else
3233 gtk_tree_view_column_set_sort_order( column, GTK_SORT_DESCENDING );
3234
3235 gtk_tree_view_column_set_sort_indicator( column, TRUE );
3236 }
3237
3238 bool wxDataViewColumn::IsSortOrderAscending() const
3239 {
3240 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3241
3242 return (gtk_tree_view_column_get_sort_order( column ) != GTK_SORT_DESCENDING);
3243 }
3244
3245 void wxDataViewColumn::SetMinWidth( int width )
3246 {
3247 gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column), width );
3248 }
3249
3250 int wxDataViewColumn::GetMinWidth() const
3251 {
3252 return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column) );
3253 }
3254
3255 int wxDataViewColumn::GetWidth() const
3256 {
3257 return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column) );
3258 }
3259
3260 void wxDataViewColumn::SetWidth( int width )
3261 {
3262 if ( width == wxCOL_WIDTH_AUTOSIZE )
3263 {
3264 // NB: this disables user resizing
3265 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column), GTK_TREE_VIEW_COLUMN_AUTOSIZE );
3266 }
3267 else
3268 {
3269 if ( width == wxCOL_WIDTH_DEFAULT )
3270 {
3271 // TODO find a better calculation
3272 width = wxDVC_DEFAULT_WIDTH;
3273 }
3274
3275 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column), GTK_TREE_VIEW_COLUMN_FIXED );
3276 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column), width );
3277 }
3278 }
3279
3280 void wxDataViewColumn::SetReorderable( bool reorderable )
3281 {
3282 gtk_tree_view_column_set_reorderable( GTK_TREE_VIEW_COLUMN(m_column), reorderable );
3283 }
3284
3285 bool wxDataViewColumn::IsReorderable() const
3286 {
3287 return gtk_tree_view_column_get_reorderable( GTK_TREE_VIEW_COLUMN(m_column) ) != 0;
3288 }
3289
3290 //-----------------------------------------------------------------------------
3291 // wxGtkTreeModelNode
3292 //-----------------------------------------------------------------------------
3293
3294 #if 0
3295 class wxGtkTreeModelChildWithPos
3296 {
3297 public:
3298 unsigned int pos;
3299 void *id;
3300 };
3301
3302 static
3303 int wxGtkTreeModelChildWithPosCmp( const void* data1, const void* data2, const void* user_data )
3304 {
3305 const wxGtkTreeModelChildWithPos* child1 = (const wxGtkTreeModelChildWithPos*) data1;
3306 const wxGtkTreeModelChildWithPos* child2 = (const wxGtkTreeModelChildWithPos*) data2;
3307 const wxDataViewCtrlInternal *internal = (const wxDataViewCtrlInternal *) user_data;
3308 int ret = internal->GetDataViewModel()->Compare( child1->id, child2->id,
3309 internal->GetSortColumn(), (internal->GetSortOrder() == GTK_SORT_DESCENDING) );
3310
3311 return ret;
3312 }
3313 #else
3314 static
3315 int LINKAGEMODE wxGtkTreeModelChildPtrCmp( void*** data1, void*** data2 )
3316 {
3317 return gs_internal->GetDataViewModel()->Compare( wxDataViewItem(**data1), wxDataViewItem(**data2),
3318 gs_internal->GetSortColumn(), (gs_internal->GetSortOrder() == GTK_SORT_ASCENDING) );
3319 }
3320
3321 WX_DEFINE_ARRAY_PTR( void**, wxGtkTreeModelChildrenPtr );
3322 #endif
3323
3324 void wxGtkTreeModelNode::Resort()
3325 {
3326 size_t child_count = GetChildCount();
3327 if (child_count == 0)
3328 return;
3329
3330 size_t node_count = GetNodesCount();
3331
3332 if (child_count == 1)
3333 {
3334 if (node_count == 1)
3335 {
3336 wxGtkTreeModelNode *node = m_nodes.Item( 0 );
3337 node->Resort();
3338 }
3339 return;
3340 }
3341
3342 gint *new_order = new gint[child_count];
3343
3344 #if 1
3345 // m_children has the original *void
3346 // ptrs points to these
3347 wxGtkTreeModelChildrenPtr ptrs;
3348 size_t i;
3349 for (i = 0; i < child_count; i++)
3350 ptrs.Add( &(m_children[i]) );
3351 // Sort the ptrs
3352 gs_internal = m_internal;
3353 ptrs.Sort( &wxGtkTreeModelChildPtrCmp );
3354
3355 wxGtkTreeModelChildren temp;
3356 void** base_ptr = &(m_children[0]);
3357 // Transfer positions to new_order array and
3358 // IDs to temp
3359 for (i = 0; i < child_count; i++)
3360 {
3361 new_order[i] = ptrs[i] - base_ptr;
3362 temp.Add( *ptrs[i] );
3363 }
3364
3365 // Transfer IDs back to m_children
3366 m_children.Clear();
3367 WX_APPEND_ARRAY( temp, m_children );
3368 #endif
3369 #if 0
3370 // Too slow
3371
3372 // Build up array with IDs and original positions
3373 wxGtkTreeModelChildWithPos* temp = new wxGtkTreeModelChildWithPos[child_count];
3374 size_t i;
3375 for (i = 0; i < child_count; i++)
3376 {
3377 temp[i].pos = i;
3378 temp[i].id = m_children[i];
3379 }
3380 // Sort array keeping original positions
3381 wxQsort( temp, child_count, sizeof(wxGtkTreeModelChildWithPos),
3382 &wxGtkTreeModelChildWithPosCmp, m_internal );
3383 // Transfer positions to new_order array and
3384 // IDs to m_children
3385 m_children.Clear();
3386 for (i = 0; i < child_count; i++)
3387 {
3388 new_order[i] = temp[i].pos;
3389 m_children.Add( temp[i].id );
3390 }
3391 // Delete array
3392 delete [] temp;
3393 #endif
3394
3395 #if 0
3396 // Too slow
3397
3398 wxGtkTreeModelChildren temp;
3399 WX_APPEND_ARRAY( temp, m_children );
3400
3401 gs_internal = m_internal;
3402 m_children.Sort( &wxGtkTreeModelChildCmp );
3403
3404 unsigned int pos;
3405 for (pos = 0; pos < child_count; pos++)
3406 {
3407 void *id = m_children.Item( pos );
3408 int old_pos = temp.Index( id );
3409 new_order[pos] = old_pos;
3410 }
3411 #endif
3412
3413 GtkTreeModel *gtk_tree_model = GTK_TREE_MODEL( m_internal->GetGtkModel() );
3414
3415 GtkTreeIter iter;
3416 iter.user_data = GetItem().GetID();
3417 iter.stamp = m_internal->GetGtkModel()->stamp;
3418
3419 gtk_tree_model_rows_reordered( gtk_tree_model,
3420 wxGtkTreePath(m_internal->get_path(&iter)), &iter, new_order );
3421
3422 delete [] new_order;
3423
3424 unsigned int pos;
3425 for (pos = 0; pos < node_count; pos++)
3426 {
3427 wxGtkTreeModelNode *node = m_nodes.Item( pos );
3428 node->Resort();
3429 }
3430 }
3431
3432 //-----------------------------------------------------------------------------
3433 // wxDataViewCtrlInternal
3434 //-----------------------------------------------------------------------------
3435
3436 wxDataViewCtrlInternal::wxDataViewCtrlInternal( wxDataViewCtrl *owner, wxDataViewModel *wx_model )
3437 {
3438 m_owner = owner;
3439 m_wx_model = wx_model;
3440
3441 m_gtk_model = NULL;
3442 m_root = NULL;
3443 m_sort_order = GTK_SORT_ASCENDING;
3444 m_sort_column = -1;
3445 m_dataview_sort_column = NULL;
3446
3447 m_dragDataObject = NULL;
3448 m_dropDataObject = NULL;
3449
3450 m_dirty = false;
3451
3452 m_gtk_model = wxgtk_tree_model_new();
3453 m_gtk_model->internal = this;
3454
3455 m_notifier = new wxGtkDataViewModelNotifier( wx_model, this );
3456
3457 wx_model->AddNotifier( m_notifier );
3458
3459 // g_object_unref( gtk_model ); ???
3460
3461 if (!m_wx_model->IsVirtualListModel())
3462 InitTree();
3463
3464 gtk_tree_view_set_model( GTK_TREE_VIEW(m_owner->GtkGetTreeView()), GTK_TREE_MODEL(m_gtk_model) );
3465 }
3466
3467 wxDataViewCtrlInternal::~wxDataViewCtrlInternal()
3468 {
3469 m_wx_model->RemoveNotifier( m_notifier );
3470
3471 // remove the model from the GtkTreeView before it gets destroyed
3472 gtk_tree_view_set_model( GTK_TREE_VIEW( m_owner->GtkGetTreeView() ), NULL );
3473
3474 g_object_unref( m_gtk_model );
3475
3476 delete m_dragDataObject;
3477 delete m_dropDataObject;
3478 }
3479
3480 void wxDataViewCtrlInternal::ScheduleRefresh()
3481 {
3482 m_dirty = true;
3483 }
3484
3485 void wxDataViewCtrlInternal::OnInternalIdle()
3486 {
3487 if (m_dirty)
3488 {
3489 GtkWidget *widget = m_owner->GtkGetTreeView();
3490 gtk_widget_queue_draw( widget );
3491 m_dirty = false;
3492 }
3493 }
3494
3495 void wxDataViewCtrlInternal::InitTree()
3496 {
3497 wxDataViewItem item;
3498 m_root = new wxGtkTreeModelNode( NULL, item, this );
3499
3500 BuildBranch( m_root );
3501 }
3502
3503 void wxDataViewCtrlInternal::BuildBranch( wxGtkTreeModelNode *node )
3504 {
3505 if (node->GetChildCount() == 0)
3506 {
3507 wxDataViewItemArray children;
3508 unsigned int count = m_wx_model->GetChildren( node->GetItem(), children );
3509
3510 unsigned int pos;
3511 for (pos = 0; pos < count; pos++)
3512 {
3513 wxDataViewItem child = children[pos];
3514
3515 if (m_wx_model->IsContainer( child ))
3516 node->AddNode( new wxGtkTreeModelNode( node, child, this ) );
3517 else
3518 node->AddLeaf( child.GetID() );
3519
3520 // Don't send any events here
3521 }
3522 }
3523 }
3524
3525 // GTK+ dnd iface
3526
3527 bool wxDataViewCtrlInternal::EnableDragSource( const wxDataFormat &format )
3528 {
3529 wxGtkString atom_str( gdk_atom_name( format ) );
3530 m_dragSourceTargetEntryTarget = wxCharBuffer( atom_str );
3531
3532 m_dragSourceTargetEntry.target = m_dragSourceTargetEntryTarget.data();
3533 m_dragSourceTargetEntry.flags = 0;
3534 m_dragSourceTargetEntry.info = static_cast<guint>(-1);
3535
3536 gtk_tree_view_enable_model_drag_source( GTK_TREE_VIEW(m_owner->GtkGetTreeView() ),
3537 GDK_BUTTON1_MASK, &m_dragSourceTargetEntry, 1, (GdkDragAction) GDK_ACTION_COPY );
3538
3539 return true;
3540 }
3541
3542 bool wxDataViewCtrlInternal::EnableDropTarget( const wxDataFormat &format )
3543 {
3544 wxGtkString atom_str( gdk_atom_name( format ) );
3545 m_dropTargetTargetEntryTarget = wxCharBuffer( atom_str );
3546
3547 m_dropTargetTargetEntry.target = m_dropTargetTargetEntryTarget.data();
3548 m_dropTargetTargetEntry.flags = 0;
3549 m_dropTargetTargetEntry.info = static_cast<guint>(-1);
3550
3551 gtk_tree_view_enable_model_drag_dest( GTK_TREE_VIEW(m_owner->GtkGetTreeView() ),
3552 &m_dropTargetTargetEntry, 1, (GdkDragAction) GDK_ACTION_COPY );
3553
3554 return true;
3555 }
3556
3557 gboolean wxDataViewCtrlInternal::row_draggable( GtkTreeDragSource *WXUNUSED(drag_source),
3558 GtkTreePath *path )
3559 {
3560 delete m_dragDataObject;
3561 m_dragDataObject = NULL;
3562
3563 wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3564 if ( !item )
3565 return FALSE;
3566
3567 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, m_owner->GetId() );
3568 event.SetEventObject( m_owner );
3569 event.SetItem( item );
3570 event.SetModel( m_wx_model );
3571 gint x, y;
3572 gtk_widget_get_pointer(m_owner->GtkGetTreeView(), &x, &y);
3573 event.SetPosition(x, y);
3574 if (!m_owner->HandleWindowEvent( event ))
3575 return FALSE;
3576
3577 if (!event.IsAllowed())
3578 return FALSE;
3579
3580 wxDataObject *obj = event.GetDataObject();
3581 if (!obj)
3582 return FALSE;
3583
3584 m_dragDataObject = obj;
3585
3586 return TRUE;
3587 }
3588
3589 gboolean
3590 wxDataViewCtrlInternal::drag_data_delete(GtkTreeDragSource *WXUNUSED(drag_source),
3591 GtkTreePath *WXUNUSED(path))
3592 {
3593 return FALSE;
3594 }
3595
3596 gboolean wxDataViewCtrlInternal::drag_data_get( GtkTreeDragSource *WXUNUSED(drag_source),
3597 GtkTreePath *path, GtkSelectionData *selection_data )
3598 {
3599 wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3600 if ( !item )
3601 return FALSE;
3602
3603 GdkAtom target = gtk_selection_data_get_target(selection_data);
3604 if (!m_dragDataObject->IsSupported(target))
3605 return FALSE;
3606
3607 size_t size = m_dragDataObject->GetDataSize(target);
3608 if (size == 0)
3609 return FALSE;
3610
3611 void *buf = malloc( size );
3612
3613 gboolean res = FALSE;
3614 if (m_dragDataObject->GetDataHere(target, buf))
3615 {
3616 res = TRUE;
3617
3618 gtk_selection_data_set(selection_data, target,
3619 8, (const guchar*) buf, size );
3620 }
3621
3622 free( buf );
3623
3624 return res;
3625 }
3626
3627 gboolean
3628 wxDataViewCtrlInternal::drag_data_received(GtkTreeDragDest *WXUNUSED(drag_dest),
3629 GtkTreePath *path,
3630 GtkSelectionData *selection_data)
3631 {
3632 wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3633 if ( !item )
3634 return FALSE;
3635
3636 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, m_owner->GetId() );
3637 event.SetEventObject( m_owner );
3638 event.SetItem( item );
3639 event.SetModel( m_wx_model );
3640 event.SetDataFormat(gtk_selection_data_get_target(selection_data));
3641 event.SetDataSize(gtk_selection_data_get_length(selection_data));
3642 event.SetDataBuffer(const_cast<guchar*>(gtk_selection_data_get_data(selection_data)));
3643 if (!m_owner->HandleWindowEvent( event ))
3644 return FALSE;
3645
3646 if (!event.IsAllowed())
3647 return FALSE;
3648
3649 return TRUE;
3650 }
3651
3652 gboolean
3653 wxDataViewCtrlInternal::row_drop_possible(GtkTreeDragDest *WXUNUSED(drag_dest),
3654 GtkTreePath *path,
3655 GtkSelectionData *selection_data)
3656 {
3657 wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3658 if ( !item )
3659 return FALSE;
3660
3661 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() );
3662 event.SetEventObject( m_owner );
3663 event.SetItem( item );
3664 event.SetModel( m_wx_model );
3665 event.SetDataFormat(gtk_selection_data_get_target(selection_data));
3666 event.SetDataSize(gtk_selection_data_get_length(selection_data));
3667 if (!m_owner->HandleWindowEvent( event ))
3668 return FALSE;
3669
3670 if (!event.IsAllowed())
3671 return FALSE;
3672
3673 return TRUE;
3674 }
3675
3676 // notifications from wxDataViewModel
3677
3678 bool wxDataViewCtrlInternal::Cleared()
3679 {
3680 if (m_root)
3681 {
3682 delete m_root;
3683 m_root = NULL;
3684 }
3685
3686 InitTree();
3687
3688 ScheduleRefresh();
3689
3690 return true;
3691 }
3692
3693 void wxDataViewCtrlInternal::Resort()
3694 {
3695 if (!m_wx_model->IsVirtualListModel())
3696 m_root->Resort();
3697
3698 ScheduleRefresh();
3699 }
3700
3701 bool wxDataViewCtrlInternal::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
3702 {
3703 if (!m_wx_model->IsVirtualListModel())
3704 {
3705 wxGtkTreeModelNode *parent_node = FindNode( parent );
3706 wxCHECK_MSG(parent_node, false,
3707 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3708
3709 wxDataViewItemArray modelSiblings;
3710 m_wx_model->GetChildren(parent, modelSiblings);
3711 const int modelSiblingsSize = modelSiblings.size();
3712
3713 int posInModel = modelSiblings.Index(item, /*fromEnd=*/true);
3714 wxCHECK_MSG( posInModel != wxNOT_FOUND, false, "adding non-existent item?" );
3715
3716 const wxGtkTreeModelChildren& nodeSiblings = parent_node->GetChildren();
3717 const int nodeSiblingsSize = nodeSiblings.size();
3718
3719 int nodePos = 0;
3720
3721 if ( posInModel == modelSiblingsSize - 1 )
3722 {
3723 nodePos = nodeSiblingsSize;
3724 }
3725 else if ( modelSiblingsSize == nodeSiblingsSize + 1 )
3726 {
3727 // This is the simple case when our node tree already matches the
3728 // model and only this one item is missing.
3729 nodePos = posInModel;
3730 }
3731 else
3732 {
3733 // It's possible that a larger discrepancy between the model and
3734 // our realization exists. This can happen e.g. when adding a bunch
3735 // of items to the model and then calling ItemsAdded() just once
3736 // afterwards. In this case, we must find the right position by
3737 // looking at sibling items.
3738
3739 // append to the end if we won't find a better position:
3740 nodePos = nodeSiblingsSize;
3741
3742 for ( int nextItemPos = posInModel + 1;
3743 nextItemPos < modelSiblingsSize;
3744 nextItemPos++ )
3745 {
3746 int nextNodePos = parent_node->FindChildByItem(modelSiblings[nextItemPos]);
3747 if ( nextNodePos != wxNOT_FOUND )
3748 {
3749 nodePos = nextNodePos;
3750 break;
3751 }
3752 }
3753 }
3754
3755 if (m_wx_model->IsContainer( item ))
3756 parent_node->InsertNode( new wxGtkTreeModelNode( parent_node, item, this ), nodePos );
3757 else
3758 parent_node->InsertLeaf( item.GetID(), nodePos );
3759 }
3760
3761 ScheduleRefresh();
3762
3763 return true;
3764 }
3765
3766 bool wxDataViewCtrlInternal::ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
3767 {
3768 if (!m_wx_model->IsVirtualListModel())
3769 {
3770 wxGtkTreeModelNode *parent_node = FindNode( parent );
3771 wxASSERT_MSG(parent_node,
3772 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3773
3774 parent_node->DeleteChild( item.GetID() );
3775 }
3776
3777 ScheduleRefresh();
3778
3779 return true;
3780 }
3781
3782 bool wxDataViewCtrlInternal::ItemChanged( const wxDataViewItem &item )
3783 {
3784 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, m_owner->GetId() );
3785 event.SetEventObject( m_owner );
3786 event.SetModel( m_owner->GetModel() );
3787 event.SetItem( item );
3788 m_owner->HandleWindowEvent( event );
3789
3790 return true;
3791 }
3792
3793 bool wxDataViewCtrlInternal::ValueChanged( const wxDataViewItem &item, unsigned int view_column )
3794 {
3795 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, m_owner->GetId() );
3796 event.SetEventObject( m_owner );
3797 event.SetModel( m_owner->GetModel() );
3798 event.SetColumn( view_column );
3799 event.SetDataViewColumn( GetOwner()->GetColumn(view_column) );
3800 event.SetItem( item );
3801 m_owner->HandleWindowEvent( event );
3802
3803 return true;
3804 }
3805
3806 // GTK+ model iface
3807
3808 GtkTreeModelFlags wxDataViewCtrlInternal::get_flags()
3809 {
3810 int flags = 0;
3811
3812 if ( m_wx_model->IsListModel() )
3813 flags |= GTK_TREE_MODEL_LIST_ONLY;
3814
3815 if ( !m_wx_model->IsVirtualListModel() )
3816 flags |= GTK_TREE_MODEL_ITERS_PERSIST;
3817
3818 return GtkTreeModelFlags(flags);
3819 }
3820
3821 gboolean wxDataViewCtrlInternal::get_iter( GtkTreeIter *iter, GtkTreePath *path )
3822 {
3823
3824 if (m_wx_model->IsVirtualListModel())
3825 {
3826 wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3827
3828 unsigned int i = (unsigned int)gtk_tree_path_get_indices (path)[0];
3829
3830 if (i >= wx_model->GetCount())
3831 return FALSE;
3832
3833 iter->stamp = m_gtk_model->stamp;
3834 // user_data is just the index +1
3835 iter->user_data = wxUIntToPtr(i+1);
3836
3837 return TRUE;
3838 }
3839 else
3840 {
3841 int depth = gtk_tree_path_get_depth( path );
3842
3843 wxGtkTreeModelNode *node = m_root;
3844
3845 int i;
3846 for (i = 0; i < depth; i++)
3847 {
3848 BuildBranch( node );
3849
3850 gint pos = gtk_tree_path_get_indices (path)[i];
3851 if (pos < 0) return FALSE;
3852 if ((size_t)pos >= node->GetChildCount()) return FALSE;
3853
3854 void* id = node->GetChildren().Item( (size_t) pos );
3855
3856 if (i == depth-1)
3857 {
3858 iter->stamp = m_gtk_model->stamp;
3859 iter->user_data = id;
3860 return TRUE;
3861 }
3862
3863 size_t count = node->GetNodes().GetCount();
3864 size_t pos2;
3865 for (pos2 = 0; pos2 < count; pos2++)
3866 {
3867 wxGtkTreeModelNode *child_node = node->GetNodes().Item( pos2 );
3868 if (child_node->GetItem().GetID() == id)
3869 {
3870 node = child_node;
3871 break;
3872 }
3873 }
3874 }
3875 }
3876
3877 return FALSE;
3878 }
3879
3880 GtkTreePath *wxDataViewCtrlInternal::get_path( GtkTreeIter *iter )
3881 {
3882 // When this is called from ItemDeleted(), the item is already
3883 // deleted in the model.
3884
3885 GtkTreePath *retval = gtk_tree_path_new ();
3886
3887 if (m_wx_model->IsVirtualListModel())
3888 {
3889 // iter is root, add nothing
3890 if (!iter->user_data)
3891 return retval;
3892
3893 // user_data is just the index +1
3894 int i = ( (wxUIntPtr) iter->user_data ) -1;
3895 gtk_tree_path_append_index (retval, i);
3896 }
3897 else
3898 {
3899 void *id = iter->user_data;
3900
3901 wxGtkTreeModelNode *node = FindParentNode( iter );
3902 while (node)
3903 {
3904 int pos = node->GetChildren().Index( id );
3905
3906 gtk_tree_path_prepend_index( retval, pos );
3907
3908 id = node->GetItem().GetID();
3909 node = node->GetParent();
3910 }
3911 }
3912
3913 return retval;
3914 }
3915
3916 gboolean wxDataViewCtrlInternal::iter_next( GtkTreeIter *iter )
3917 {
3918 if (m_wx_model->IsVirtualListModel())
3919 {
3920 wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3921
3922 // user_data is just the index +1
3923 int n = ( (wxUIntPtr) iter->user_data ) -1;
3924
3925 if (n == -1)
3926 {
3927 iter->user_data = NULL;
3928 return FALSE;
3929 }
3930
3931 if (n >= (int) wx_model->GetCount()-1)
3932 {
3933 iter->user_data = NULL;
3934 return FALSE;
3935 }
3936
3937 // user_data is just the index +1 (+2 because we need the next)
3938 iter->user_data = wxUIntToPtr(n+2);
3939 }
3940 else
3941 {
3942 wxGtkTreeModelNode *parent = FindParentNode( iter );
3943 if( parent == NULL )
3944 {
3945 iter->user_data = NULL;
3946 return FALSE;
3947 }
3948
3949 int pos = parent->GetChildren().Index( iter->user_data );
3950
3951 if (pos == (int) parent->GetChildCount()-1)
3952 {
3953 iter->user_data = NULL;
3954 return FALSE;
3955 }
3956
3957 iter->user_data = parent->GetChildren().Item( pos+1 );
3958 }
3959
3960 return TRUE;
3961 }
3962
3963 gboolean wxDataViewCtrlInternal::iter_children( GtkTreeIter *iter, GtkTreeIter *parent )
3964 {
3965 if (m_wx_model->IsVirtualListModel())
3966 {
3967 // this is a list, nodes have no children
3968 if (parent)
3969 return FALSE;
3970
3971 iter->stamp = m_gtk_model->stamp;
3972 iter->user_data = (gpointer) 1;
3973
3974 return TRUE;
3975 }
3976 else
3977 {
3978 if (iter == NULL)
3979 {
3980 if (m_root->GetChildCount() == 0) return FALSE;
3981 iter->stamp = m_gtk_model->stamp;
3982 iter->user_data = (gpointer) m_root->GetChildren().Item( 0 );
3983 return TRUE;
3984 }
3985
3986
3987 wxDataViewItem item;
3988 if (parent)
3989 item = wxDataViewItem( (void*) parent->user_data );
3990
3991 if (!m_wx_model->IsContainer( item ))
3992 return FALSE;
3993
3994 wxGtkTreeModelNode *parent_node = FindNode( parent );
3995 wxASSERT_MSG(parent_node,
3996 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3997
3998 BuildBranch( parent_node );
3999
4000 if (parent_node->GetChildCount() == 0)
4001 return FALSE;
4002
4003 iter->stamp = m_gtk_model->stamp;
4004 iter->user_data = (gpointer) parent_node->GetChildren().Item( 0 );
4005 }
4006
4007 return TRUE;
4008 }
4009
4010 gboolean wxDataViewCtrlInternal::iter_has_child( GtkTreeIter *iter )
4011 {
4012 if (m_wx_model->IsVirtualListModel())
4013 {
4014 wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
4015
4016 if (iter == NULL)
4017 return (wx_model->GetCount() > 0);
4018
4019 // this is a list, nodes have no children
4020 return FALSE;
4021 }
4022 else
4023 {
4024 if (iter == NULL)
4025 return (m_root->GetChildCount() > 0);
4026
4027 wxDataViewItem item( (void*) iter->user_data );
4028
4029 bool is_container = m_wx_model->IsContainer( item );
4030
4031 if (!is_container)
4032 return FALSE;
4033
4034 wxGtkTreeModelNode *node = FindNode( iter );
4035 wxASSERT_MSG(node,
4036 "Did you forget a call to ItemAdded()? The iterator is unknown to the wxGtkTreeModel");
4037
4038 BuildBranch( node );
4039
4040 return (node->GetChildCount() > 0);
4041 }
4042 }
4043
4044 gint wxDataViewCtrlInternal::iter_n_children( GtkTreeIter *iter )
4045 {
4046 if (m_wx_model->IsVirtualListModel())
4047 {
4048 wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
4049
4050 if (iter == NULL)
4051 return (gint) wx_model->GetCount();
4052
4053 return 0;
4054 }
4055 else
4056 {
4057 if (iter == NULL)
4058 return m_root->GetChildCount();
4059
4060 wxDataViewItem item( (void*) iter->user_data );
4061
4062 if (!m_wx_model->IsContainer( item ))
4063 return 0;
4064
4065 wxGtkTreeModelNode *parent_node = FindNode( iter );
4066 wxASSERT_MSG(parent_node,
4067 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
4068
4069 BuildBranch( parent_node );
4070
4071 return parent_node->GetChildCount();
4072 }
4073 }
4074
4075 gboolean wxDataViewCtrlInternal::iter_nth_child( GtkTreeIter *iter, GtkTreeIter *parent, gint n )
4076 {
4077 if (m_wx_model->IsVirtualListModel())
4078 {
4079 wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
4080
4081 if (parent)
4082 return FALSE;
4083
4084 if (n < 0)
4085 return FALSE;
4086
4087 if (n >= (gint) wx_model->GetCount())
4088 return FALSE;
4089
4090 iter->stamp = m_gtk_model->stamp;
4091 // user_data is just the index +1
4092 iter->user_data = wxUIntToPtr(n+1);
4093
4094 return TRUE;
4095 }
4096 else
4097 {
4098 void* id = NULL;
4099 if (parent) id = (void*) parent->user_data;
4100 wxDataViewItem item( id );
4101
4102 if (!m_wx_model->IsContainer( item ))
4103 return FALSE;
4104
4105 wxGtkTreeModelNode *parent_node = FindNode( parent );
4106 wxASSERT_MSG(parent_node,
4107 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
4108
4109 BuildBranch( parent_node );
4110
4111 iter->stamp = m_gtk_model->stamp;
4112 iter->user_data = parent_node->GetChildren().Item( n );
4113
4114 return TRUE;
4115 }
4116 }
4117
4118 gboolean wxDataViewCtrlInternal::iter_parent( GtkTreeIter *iter, GtkTreeIter *child )
4119 {
4120 if (m_wx_model->IsVirtualListModel())
4121 {
4122 return FALSE;
4123 }
4124 else
4125 {
4126 wxGtkTreeModelNode *node = FindParentNode( child );
4127 if (!node)
4128 return FALSE;
4129
4130 iter->stamp = m_gtk_model->stamp;
4131 iter->user_data = (gpointer) node->GetItem().GetID();
4132
4133 return TRUE;
4134 }
4135 }
4136
4137 // item can be deleted already in the model
4138 int wxDataViewCtrlInternal::GetIndexOf( const wxDataViewItem &parent, const wxDataViewItem &item )
4139 {
4140 if (m_wx_model->IsVirtualListModel())
4141 {
4142 return wxPtrToUInt(item.GetID()) - 1;
4143 }
4144 else
4145 {
4146 wxGtkTreeModelNode *parent_node = FindNode( parent );
4147 wxGtkTreeModelChildren &children = parent_node->GetChildren();
4148 size_t j;
4149 for (j = 0; j < children.GetCount(); j++)
4150 {
4151 if (children[j] == item.GetID())
4152 return j;
4153 }
4154 }
4155 return -1;
4156 }
4157
4158
4159 static wxGtkTreeModelNode*
4160 wxDataViewCtrlInternal_FindNode( wxDataViewModel * model, wxGtkTreeModelNode *treeNode, const wxDataViewItem &item )
4161 {
4162 if( model == NULL )
4163 return NULL;
4164
4165 ItemList list;
4166 list.DeleteContents( true );
4167 wxDataViewItem it( item );
4168
4169 while( it.IsOk() )
4170 {
4171 wxDataViewItem * pItem = new wxDataViewItem( it );
4172 list.Insert( pItem );
4173 it = model->GetParent( it );
4174 }
4175
4176 wxGtkTreeModelNode * node = treeNode;
4177 for( ItemList::compatibility_iterator n = list.GetFirst(); n; n = n->GetNext() )
4178 {
4179 if( node && node->GetNodes().GetCount() != 0 )
4180 {
4181 int len = node->GetNodes().GetCount();
4182 wxGtkTreeModelNodes &nodes = node->GetNodes();
4183 int j = 0;
4184 for( ; j < len; j ++)
4185 {
4186 if( nodes[j]->GetItem() == *(n->GetData()))
4187 {
4188 node = nodes[j];
4189 break;
4190 }
4191 }
4192
4193 if( j == len )
4194 {
4195 return NULL;
4196 }
4197 }
4198 else
4199 return NULL;
4200 }
4201 return node;
4202
4203 }
4204
4205 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindNode( GtkTreeIter *iter )
4206 {
4207 if (!iter)
4208 return m_root;
4209
4210 wxDataViewItem item( (void*) iter->user_data );
4211 if (!item.IsOk())
4212 return m_root;
4213
4214 wxGtkTreeModelNode *result = wxDataViewCtrlInternal_FindNode( m_wx_model, m_root, item );
4215
4216 /*
4217 if (!result)
4218 {
4219 wxLogDebug( "Not found %p", iter->user_data );
4220 char *crash = NULL;
4221 *crash = 0;
4222 }
4223 // TODO: remove this code
4224 */
4225
4226 return result;
4227 }
4228
4229 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindNode( const wxDataViewItem &item )
4230 {
4231 if (!item.IsOk())
4232 return m_root;
4233
4234 wxGtkTreeModelNode *result = wxDataViewCtrlInternal_FindNode( m_wx_model, m_root, item );
4235
4236 /*
4237 if (!result)
4238 {
4239 wxLogDebug( "Not found %p", item.GetID() );
4240 char *crash = NULL;
4241 *crash = 0;
4242 }
4243 // TODO: remove this code
4244 */
4245
4246 return result;
4247 }
4248
4249 static wxGtkTreeModelNode*
4250 wxDataViewCtrlInternal_FindParentNode( wxDataViewModel * model, wxGtkTreeModelNode *treeNode, const wxDataViewItem &item )
4251 {
4252 if( model == NULL )
4253 return NULL;
4254
4255 ItemList list;
4256 list.DeleteContents( true );
4257 if( !item.IsOk() )
4258 return NULL;
4259
4260 wxDataViewItem it( model->GetParent( item ) );
4261 while( it.IsOk() )
4262 {
4263 wxDataViewItem * pItem = new wxDataViewItem( it );
4264 list.Insert( pItem );
4265 it = model->GetParent( it );
4266 }
4267
4268 wxGtkTreeModelNode * node = treeNode;
4269 for( ItemList::compatibility_iterator n = list.GetFirst(); n; n = n->GetNext() )
4270 {
4271 if( node && node->GetNodes().GetCount() != 0 )
4272 {
4273 int len = node->GetNodes().GetCount();
4274 wxGtkTreeModelNodes nodes = node->GetNodes();
4275 int j = 0;
4276 for( ; j < len; j ++)
4277 {
4278 if( nodes[j]->GetItem() == *(n->GetData()))
4279 {
4280 node = nodes[j];
4281 break;
4282 }
4283 }
4284
4285 if( j == len )
4286 {
4287 return NULL;
4288 }
4289 }
4290 else
4291 return NULL;
4292 }
4293 //Examine whether the node is item's parent node
4294 int len = node->GetChildCount();
4295 for( int i = 0; i < len ; i ++ )
4296 {
4297 if( node->GetChildren().Item( i ) == item.GetID() )
4298 return node;
4299 }
4300 return NULL;
4301 }
4302
4303 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindParentNode( GtkTreeIter *iter )
4304 {
4305 if (!iter)
4306 return NULL;
4307
4308 wxDataViewItem item( (void*) iter->user_data );
4309 if (!item.IsOk())
4310 return NULL;
4311
4312 return wxDataViewCtrlInternal_FindParentNode( m_wx_model, m_root, item );
4313 }
4314
4315 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindParentNode( const wxDataViewItem &item )
4316 {
4317 if (!item.IsOk())
4318 return NULL;
4319
4320 return wxDataViewCtrlInternal_FindParentNode( m_wx_model, m_root, item );
4321 }
4322
4323 //-----------------------------------------------------------------------------
4324 // wxDataViewCtrl signal callbacks
4325 //-----------------------------------------------------------------------------
4326
4327 static void
4328 wxdataview_selection_changed_callback( GtkTreeSelection* WXUNUSED(selection), wxDataViewCtrl *dv )
4329 {
4330 if (!gtk_widget_get_realized(dv->m_widget))
4331 return;
4332
4333 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, dv->GetId() );
4334 event.SetItem( dv->GetSelection() );
4335 event.SetModel( dv->GetModel() );
4336 dv->HandleWindowEvent( event );
4337 }
4338
4339 static void
4340 wxdataview_row_activated_callback( GtkTreeView* WXUNUSED(treeview), GtkTreePath *path,
4341 GtkTreeViewColumn *WXUNUSED(column), wxDataViewCtrl *dv )
4342 {
4343 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, dv->GetId() );
4344
4345 wxDataViewItem item(dv->GTKPathToItem(path));
4346 event.SetItem( item );
4347 event.SetModel( dv->GetModel() );
4348 dv->HandleWindowEvent( event );
4349 }
4350
4351 static gboolean
4352 wxdataview_test_expand_row_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4353 GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4354 {
4355 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, dv->GetId() );
4356
4357 wxDataViewItem item( (void*) iter->user_data );;
4358 event.SetItem( item );
4359 event.SetModel( dv->GetModel() );
4360 dv->HandleWindowEvent( event );
4361
4362 return !event.IsAllowed();
4363 }
4364
4365 static void
4366 wxdataview_row_expanded_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4367 GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4368 {
4369 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED, dv->GetId() );
4370
4371 wxDataViewItem item( (void*) iter->user_data );;
4372 event.SetItem( item );
4373 event.SetModel( dv->GetModel() );
4374 dv->HandleWindowEvent( event );
4375 }
4376
4377 static gboolean
4378 wxdataview_test_collapse_row_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4379 GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4380 {
4381 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING, dv->GetId() );
4382
4383 wxDataViewItem item( (void*) iter->user_data );;
4384 event.SetItem( item );
4385 event.SetModel( dv->GetModel() );
4386 dv->HandleWindowEvent( event );
4387
4388 return !event.IsAllowed();
4389 }
4390
4391 static void
4392 wxdataview_row_collapsed_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4393 GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4394 {
4395 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED, dv->GetId() );
4396
4397 wxDataViewItem item( (void*) iter->user_data );;
4398 event.SetItem( item );
4399 event.SetModel( dv->GetModel() );
4400 dv->HandleWindowEvent( event );
4401 }
4402
4403 //-----------------------------------------------------------------------------
4404 // wxDataViewCtrl
4405 //-----------------------------------------------------------------------------
4406
4407 void wxDataViewCtrl::AddChildGTK(wxWindowGTK* child)
4408 {
4409 GtkWidget* treeview = GtkGetTreeView();
4410
4411 // Insert widget in GtkTreeView
4412 if (gtk_widget_get_realized(treeview))
4413 gtk_widget_set_parent_window( child->m_widget,
4414 gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview) ) );
4415 gtk_widget_set_parent( child->m_widget, treeview );
4416 }
4417
4418 static
4419 void gtk_dataviewctrl_size_callback( GtkWidget *WXUNUSED(widget),
4420 GtkAllocation *WXUNUSED(gtk_alloc),
4421 wxDataViewCtrl *win )
4422 {
4423 wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
4424 while (node)
4425 {
4426 wxWindow *child = node->GetData();
4427
4428 GtkRequisition req;
4429 gtk_widget_size_request( child->m_widget, &req );
4430
4431 GtkAllocation alloc;
4432 alloc.x = child->m_x;
4433 alloc.y = child->m_y;
4434 alloc.width = child->m_width;
4435 alloc.height = child->m_height;
4436 gtk_widget_size_allocate( child->m_widget, &alloc );
4437
4438 node = node->GetNext();
4439 }
4440 }
4441
4442
4443 //-----------------------------------------------------------------------------
4444 // "motion_notify_event"
4445 //-----------------------------------------------------------------------------
4446
4447 static gboolean
4448 gtk_dataview_motion_notify_callback( GtkWidget *WXUNUSED(widget),
4449 GdkEventMotion *gdk_event,
4450 wxDataViewCtrl *dv )
4451 {
4452 if (gdk_event->is_hint)
4453 {
4454 int x = 0;
4455 int y = 0;
4456 GdkModifierType state;
4457 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
4458 gdk_event->x = x;
4459 gdk_event->y = y;
4460 }
4461
4462 wxGtkTreePath path;
4463 GtkTreeViewColumn *column = NULL;
4464 gint cell_x = 0;
4465 gint cell_y = 0;
4466 if (gtk_tree_view_get_path_at_pos(
4467 GTK_TREE_VIEW(dv->GtkGetTreeView()),
4468 (int) gdk_event->x, (int) gdk_event->y,
4469 path.ByRef(),
4470 &column,
4471 &cell_x,
4472 &cell_y))
4473 {
4474 if (path)
4475 {
4476 GtkTreeIter iter;
4477 dv->GtkGetInternal()->get_iter( &iter, path );
4478 }
4479 }
4480
4481
4482 return FALSE;
4483 }
4484
4485 //-----------------------------------------------------------------------------
4486 // "button_press_event"
4487 //-----------------------------------------------------------------------------
4488
4489 static gboolean
4490 gtk_dataview_button_press_callback( GtkWidget *WXUNUSED(widget),
4491 GdkEventButton *gdk_event,
4492 wxDataViewCtrl *dv )
4493 {
4494 if ((gdk_event->button == 3) && (gdk_event->type == GDK_BUTTON_PRESS))
4495 {
4496 wxGtkTreePath path;
4497 GtkTreeViewColumn *column = NULL;
4498 gint cell_x = 0;
4499 gint cell_y = 0;
4500 gtk_tree_view_get_path_at_pos
4501 (
4502 GTK_TREE_VIEW(dv->GtkGetTreeView()),
4503 (int) gdk_event->x, (int) gdk_event->y,
4504 path.ByRef(),
4505 &column,
4506 &cell_x,
4507 &cell_y
4508 );
4509
4510 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, dv->GetId() );
4511 if (path)
4512 event.SetItem(dv->GTKPathToItem(path));
4513 event.SetModel( dv->GetModel() );
4514 return dv->HandleWindowEvent( event );
4515 }
4516
4517 return FALSE;
4518 }
4519
4520 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
4521
4522 wxDataViewCtrl::~wxDataViewCtrl()
4523 {
4524 // Stop editing before destroying the control to remove any event handlers
4525 // which are added when editing started: if we didn't do this, the base
4526 // class dtor would assert as it checks for any leftover handlers.
4527 if ( m_treeview )
4528 {
4529 GtkTreeViewColumn *col;
4530 gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview), NULL, &col);
4531
4532 wxDataViewColumn * const wxcol = FromGTKColumn(col);
4533 if ( wxcol )
4534 {
4535 // This won't do anything if we're not editing it
4536 wxcol->GetRenderer()->CancelEditing();
4537 }
4538 }
4539
4540 m_cols.Clear();
4541
4542 delete m_internal;
4543 }
4544
4545 void wxDataViewCtrl::Init()
4546 {
4547 m_internal = NULL;
4548
4549 m_cols.DeleteContents( true );
4550
4551 m_uniformRowHeight = -1;
4552 }
4553
4554 bool wxDataViewCtrl::Create(wxWindow *parent,
4555 wxWindowID id,
4556 const wxPoint& pos,
4557 const wxSize& size,
4558 long style,
4559 const wxValidator& validator,
4560 const wxString& name)
4561 {
4562 if (!PreCreation( parent, pos, size ) ||
4563 !CreateBase( parent, id, pos, size, style, validator, name ))
4564 {
4565 wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
4566 return false;
4567 }
4568
4569 m_widget = gtk_scrolled_window_new (NULL, NULL);
4570 g_object_ref(m_widget);
4571
4572 GTKScrolledWindowSetBorder(m_widget, style);
4573
4574 m_treeview = gtk_tree_view_new();
4575 gtk_container_add (GTK_CONTAINER (m_widget), m_treeview);
4576
4577 m_focusWidget = GTK_WIDGET(m_treeview);
4578
4579 g_signal_connect (m_treeview, "size_allocate",
4580 G_CALLBACK (gtk_dataviewctrl_size_callback), this);
4581
4582 #ifdef __WXGTK26__
4583 #ifndef __WXGTK3__
4584 if (!gtk_check_version(2,6,0))
4585 #endif
4586 {
4587 bool fixed = (style & wxDV_VARIABLE_LINE_HEIGHT) == 0;
4588 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), fixed );
4589 }
4590 #endif
4591
4592 if (style & wxDV_MULTIPLE)
4593 {
4594 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4595 gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
4596 }
4597
4598 gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview), (style & wxDV_NO_HEADER) == 0 );
4599
4600 #ifdef __WXGTK210__
4601 #ifndef __WXGTK3__
4602 if (!gtk_check_version(2,10,0))
4603 #endif
4604 {
4605 GtkTreeViewGridLines grid = GTK_TREE_VIEW_GRID_LINES_NONE;
4606
4607 if ((style & wxDV_HORIZ_RULES) != 0 &&
4608 (style & wxDV_VERT_RULES) != 0)
4609 grid = GTK_TREE_VIEW_GRID_LINES_BOTH;
4610 else if (style & wxDV_VERT_RULES)
4611 grid = GTK_TREE_VIEW_GRID_LINES_VERTICAL;
4612 else if (style & wxDV_HORIZ_RULES)
4613 grid = GTK_TREE_VIEW_GRID_LINES_HORIZONTAL;
4614
4615 if (grid != GTK_TREE_VIEW_GRID_LINES_NONE)
4616 gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview), grid );
4617 }
4618 #endif
4619
4620 gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview), (style & wxDV_ROW_LINES) != 0 );
4621
4622 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget),
4623 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
4624 gtk_widget_show (m_treeview);
4625
4626 m_parent->DoAddChild( this );
4627
4628 PostCreation(size);
4629
4630 GtkEnableSelectionEvents();
4631
4632 g_signal_connect_after (m_treeview, "row-activated",
4633 G_CALLBACK (wxdataview_row_activated_callback), this);
4634
4635 g_signal_connect (m_treeview, "test-collapse-row",
4636 G_CALLBACK (wxdataview_test_collapse_row_callback), this);
4637
4638 g_signal_connect_after (m_treeview, "row-collapsed",
4639 G_CALLBACK (wxdataview_row_collapsed_callback), this);
4640
4641 g_signal_connect (m_treeview, "test-expand-row",
4642 G_CALLBACK (wxdataview_test_expand_row_callback), this);
4643
4644 g_signal_connect_after (m_treeview, "row-expanded",
4645 G_CALLBACK (wxdataview_row_expanded_callback), this);
4646
4647 g_signal_connect (m_treeview, "motion_notify_event",
4648 G_CALLBACK (gtk_dataview_motion_notify_callback), this);
4649
4650 g_signal_connect (m_treeview, "button_press_event",
4651 G_CALLBACK (gtk_dataview_button_press_callback), this);
4652
4653 return true;
4654 }
4655
4656 wxDataViewItem wxDataViewCtrl::GTKPathToItem(GtkTreePath *path) const
4657 {
4658 GtkTreeIter iter;
4659 return wxDataViewItem(path && m_internal->get_iter(&iter, path)
4660 ? iter.user_data
4661 : NULL);
4662 }
4663
4664 void wxDataViewCtrl::OnInternalIdle()
4665 {
4666 wxWindow::OnInternalIdle();
4667
4668 m_internal->OnInternalIdle();
4669
4670 unsigned int cols = GetColumnCount();
4671 unsigned int i;
4672 for (i = 0; i < cols; i++)
4673 {
4674 wxDataViewColumn *col = GetColumn( i );
4675 col->OnInternalIdle();
4676 }
4677
4678 if (m_ensureVisibleDefered.IsOk())
4679 {
4680 ExpandAncestors(m_ensureVisibleDefered);
4681 GtkTreeIter iter;
4682 iter.user_data = (gpointer) m_ensureVisibleDefered.GetID();
4683 wxGtkTreePath path(m_internal->get_path( &iter ));
4684 gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview), path, NULL, false, 0.0, 0.0 );
4685 m_ensureVisibleDefered = wxDataViewItem(0);
4686 }
4687 }
4688
4689 bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model )
4690 {
4691 wxDELETE(m_internal);
4692
4693 if (!wxDataViewCtrlBase::AssociateModel( model ))
4694 return false;
4695
4696 #ifdef __WXGTK26__
4697 #ifndef __WXGTK3__
4698 if (!gtk_check_version(2,6,0))
4699 #endif
4700 {
4701 bool fixed = (((GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT) == 0) || (model->IsVirtualListModel()));
4702 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), fixed );
4703 }
4704 #endif
4705
4706 m_internal = new wxDataViewCtrlInternal( this, model );
4707
4708 return true;
4709 }
4710
4711 bool wxDataViewCtrl::EnableDragSource( const wxDataFormat &format )
4712 {
4713 return m_internal->EnableDragSource( format );
4714 }
4715
4716 bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat &format )
4717 {
4718 return m_internal->EnableDropTarget( format );
4719 }
4720
4721 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
4722 {
4723 if (!wxDataViewCtrlBase::AppendColumn(col))
4724 return false;
4725
4726 m_cols.Append( col );
4727
4728 #ifdef __WXGTK26__
4729 #ifndef __WXGTK3__
4730 if (!gtk_check_version(2,6,0))
4731 #endif
4732 {
4733 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4734 GTK_TREE_VIEW_COLUMN_FIXED)
4735 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4736 }
4737 #endif
4738
4739 gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview),
4740 GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) );
4741
4742 return true;
4743 }
4744
4745 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col )
4746 {
4747 if (!wxDataViewCtrlBase::PrependColumn(col))
4748 return false;
4749
4750 m_cols.Insert( col );
4751
4752 #ifdef __WXGTK26__
4753 #ifndef __WXGTK3__
4754 if (!gtk_check_version(2,6,0))
4755 #endif
4756 {
4757 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4758 GTK_TREE_VIEW_COLUMN_FIXED)
4759 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4760 }
4761 #endif
4762
4763 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview),
4764 GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()), 0 );
4765
4766 return true;
4767 }
4768
4769 bool wxDataViewCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
4770 {
4771 if (!wxDataViewCtrlBase::InsertColumn(pos,col))
4772 return false;
4773
4774 m_cols.Insert( pos, col );
4775
4776 #ifdef __WXGTK26__
4777 #ifndef __WXGTK3__
4778 if (!gtk_check_version(2,6,0))
4779 #endif
4780 {
4781 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4782 GTK_TREE_VIEW_COLUMN_FIXED)
4783 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4784 }
4785 #endif
4786
4787 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview),
4788 GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()), pos );
4789
4790 return true;
4791 }
4792
4793 unsigned int wxDataViewCtrl::GetColumnCount() const
4794 {
4795 return m_cols.GetCount();
4796 }
4797
4798 wxDataViewColumn* wxDataViewCtrl::FromGTKColumn(GtkTreeViewColumn *gtk_col) const
4799 {
4800 if ( !gtk_col )
4801 return NULL;
4802
4803 wxDataViewColumnList::const_iterator iter;
4804 for (iter = m_cols.begin(); iter != m_cols.end(); ++iter)
4805 {
4806 wxDataViewColumn *col = *iter;
4807 if (GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) == gtk_col)
4808 {
4809 return col;
4810 }
4811 }
4812
4813 wxFAIL_MSG( "No matching column?" );
4814
4815 return NULL;
4816 }
4817
4818 wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int pos ) const
4819 {
4820 GtkTreeViewColumn *gtk_col = gtk_tree_view_get_column( GTK_TREE_VIEW(m_treeview), pos );
4821
4822 return FromGTKColumn(gtk_col);
4823 }
4824
4825 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column )
4826 {
4827 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview),
4828 GTK_TREE_VIEW_COLUMN(column->GetGtkHandle()) );
4829
4830 m_cols.DeleteObject( column );
4831
4832 return true;
4833 }
4834
4835 bool wxDataViewCtrl::ClearColumns()
4836 {
4837 wxDataViewColumnList::iterator iter;
4838 for (iter = m_cols.begin(); iter != m_cols.end(); ++iter)
4839 {
4840 wxDataViewColumn *col = *iter;
4841 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview),
4842 GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) );
4843 }
4844
4845 m_cols.Clear();
4846
4847 return true;
4848 }
4849
4850 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const
4851 {
4852 GtkTreeViewColumn *gtk_column = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
4853
4854 wxGtkList list(gtk_tree_view_get_columns(GTK_TREE_VIEW(m_treeview)));
4855
4856 return g_list_index( list, (gconstpointer) gtk_column );
4857 }
4858
4859 wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const
4860 {
4861 return m_internal->GetDataViewSortColumn();
4862 }
4863
4864 void wxDataViewCtrl::Expand( const wxDataViewItem & item )
4865 {
4866 GtkTreeIter iter;
4867 iter.user_data = item.GetID();
4868 wxGtkTreePath path(m_internal->get_path( &iter ));
4869 gtk_tree_view_expand_row( GTK_TREE_VIEW(m_treeview), path, false );
4870 }
4871
4872 void wxDataViewCtrl::Collapse( const wxDataViewItem & item )
4873 {
4874 GtkTreeIter iter;
4875 iter.user_data = item.GetID();
4876 wxGtkTreePath path(m_internal->get_path( &iter ));
4877 gtk_tree_view_collapse_row( GTK_TREE_VIEW(m_treeview), path );
4878 }
4879
4880 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem & item ) const
4881 {
4882 GtkTreeIter iter;
4883 iter.user_data = item.GetID();
4884 wxGtkTreePath path(m_internal->get_path( &iter ));
4885 return gtk_tree_view_row_expanded( GTK_TREE_VIEW(m_treeview), path ) != 0;
4886 }
4887
4888 wxDataViewItem wxDataViewCtrl::DoGetCurrentItem() const
4889 {
4890 // The tree doesn't have any current item if it hadn't been created yet but
4891 // it's arguably not an error to call this function in this case so just
4892 // return an invalid item without asserting.
4893 if ( !m_treeview )
4894 return wxDataViewItem();
4895
4896 wxGtkTreePath path;
4897 gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview), path.ByRef(), NULL);
4898
4899 return GTKPathToItem(path);
4900 }
4901
4902 void wxDataViewCtrl::DoSetCurrentItem(const wxDataViewItem& item)
4903 {
4904 wxCHECK_RET( m_treeview,
4905 "Current item can't be set before creating the control." );
4906
4907 // We need to make sure the model knows about this item or the path would
4908 // be invalid and gtk_tree_view_set_cursor() would silently do nothing.
4909 ExpandAncestors(item);
4910
4911 // We also need to preserve the existing selection from changing.
4912 // Unfortunately the only way to do it seems to use our own selection
4913 // function and forbid any selection changes during set cursor call.
4914 wxGtkTreeSelectionLock
4915 lock(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_treeview)));
4916
4917 // Do move the cursor now.
4918 GtkTreeIter iter;
4919 iter.user_data = item.GetID();
4920 wxGtkTreePath path(m_internal->get_path( &iter ));
4921
4922 gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_treeview), path, NULL, FALSE);
4923 }
4924
4925 wxDataViewColumn *wxDataViewCtrl::GetCurrentColumn() const
4926 {
4927 // The tree doesn't have any current item if it hadn't been created yet but
4928 // it's arguably not an error to call this function in this case so just
4929 // return NULL without asserting.
4930 if ( !m_treeview )
4931 return NULL;
4932
4933 GtkTreeViewColumn *col;
4934 gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview), NULL, &col);
4935 return FromGTKColumn(col);
4936 }
4937
4938 void wxDataViewCtrl::EditItem(const wxDataViewItem& item, const wxDataViewColumn *column)
4939 {
4940 wxCHECK_RET( m_treeview,
4941 "Current item can't be set before creating the control." );
4942 wxCHECK_RET( item.IsOk(), "invalid item" );
4943 wxCHECK_RET( column, "no column provided" );
4944
4945 // We need to make sure the model knows about this item or the path would
4946 // be invalid and gtk_tree_view_set_cursor() would silently do nothing.
4947 ExpandAncestors(item);
4948
4949 GtkTreeViewColumn *gcolumn = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
4950
4951 // We also need to preserve the existing selection from changing.
4952 // Unfortunately the only way to do it seems to use our own selection
4953 // function and forbid any selection changes during set cursor call.
4954 wxGtkTreeSelectionLock
4955 lock(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_treeview)));
4956
4957 // Do move the cursor now.
4958 GtkTreeIter iter;
4959 iter.user_data = item.GetID();
4960 wxGtkTreePath path(m_internal->get_path( &iter ));
4961
4962 gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_treeview), path, gcolumn, TRUE);
4963 }
4964
4965 int wxDataViewCtrl::GetSelectedItemsCount() const
4966 {
4967 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4968
4969 return gtk_tree_selection_count_selected_rows(selection);
4970 }
4971
4972 int wxDataViewCtrl::GetSelections( wxDataViewItemArray & sel ) const
4973 {
4974 sel.Clear();
4975
4976 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4977 if (HasFlag(wxDV_MULTIPLE))
4978 {
4979 GtkTreeModel *model;
4980 wxGtkTreePathList list(gtk_tree_selection_get_selected_rows(selection, &model));
4981
4982 for ( GList* current = list; current; current = g_list_next(current) )
4983 {
4984 GtkTreePath *path = (GtkTreePath*) current->data;
4985
4986 sel.Add(GTKPathToItem(path));
4987 }
4988 }
4989 else
4990 {
4991 GtkTreeIter iter;
4992 if (gtk_tree_selection_get_selected( selection, NULL, &iter ))
4993 {
4994 sel.Add( wxDataViewItem(iter.user_data) );
4995 }
4996 }
4997
4998 return sel.size();
4999 }
5000
5001 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel )
5002 {
5003 GtkDisableSelectionEvents();
5004
5005 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5006
5007 gtk_tree_selection_unselect_all( selection );
5008
5009 wxDataViewItem last_parent;
5010
5011 size_t i;
5012 for (i = 0; i < sel.GetCount(); i++)
5013 {
5014 wxDataViewItem item = sel[i];
5015 wxDataViewItem parent = GetModel()->GetParent( item );
5016 if (parent)
5017 {
5018 if (parent != last_parent)
5019 ExpandAncestors(item);
5020 }
5021 last_parent = parent;
5022
5023 GtkTreeIter iter;
5024 iter.stamp = m_internal->GetGtkModel()->stamp;
5025 iter.user_data = (gpointer) item.GetID();
5026 gtk_tree_selection_select_iter( selection, &iter );
5027 }
5028
5029 GtkEnableSelectionEvents();
5030 }
5031
5032 void wxDataViewCtrl::Select( const wxDataViewItem & item )
5033 {
5034 ExpandAncestors(item);
5035
5036 GtkDisableSelectionEvents();
5037
5038 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5039
5040 GtkTreeIter iter;
5041 iter.stamp = m_internal->GetGtkModel()->stamp;
5042 iter.user_data = (gpointer) item.GetID();
5043 gtk_tree_selection_select_iter( selection, &iter );
5044
5045 GtkEnableSelectionEvents();
5046 }
5047
5048 void wxDataViewCtrl::Unselect( const wxDataViewItem & item )
5049 {
5050 GtkDisableSelectionEvents();
5051
5052 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5053
5054 GtkTreeIter iter;
5055 iter.stamp = m_internal->GetGtkModel()->stamp;
5056 iter.user_data = (gpointer) item.GetID();
5057 gtk_tree_selection_unselect_iter( selection, &iter );
5058
5059 GtkEnableSelectionEvents();
5060 }
5061
5062 bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const
5063 {
5064 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5065
5066 GtkTreeIter iter;
5067 iter.stamp = m_internal->GetGtkModel()->stamp;
5068 iter.user_data = (gpointer) item.GetID();
5069
5070 return gtk_tree_selection_iter_is_selected( selection, &iter ) != 0;
5071 }
5072
5073 void wxDataViewCtrl::SelectAll()
5074 {
5075 GtkDisableSelectionEvents();
5076
5077 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5078
5079 gtk_tree_selection_select_all( selection );
5080
5081 GtkEnableSelectionEvents();
5082 }
5083
5084 void wxDataViewCtrl::UnselectAll()
5085 {
5086 GtkDisableSelectionEvents();
5087
5088 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5089
5090 gtk_tree_selection_unselect_all( selection );
5091
5092 GtkEnableSelectionEvents();
5093 }
5094
5095 void wxDataViewCtrl::EnsureVisible(const wxDataViewItem& item,
5096 const wxDataViewColumn *WXUNUSED(column))
5097 {
5098 m_ensureVisibleDefered = item;
5099 ExpandAncestors(item);
5100
5101 GtkTreeIter iter;
5102 iter.user_data = (gpointer) item.GetID();
5103 wxGtkTreePath path(m_internal->get_path( &iter ));
5104 gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview), path, NULL, false, 0.0, 0.0 );
5105 }
5106
5107 void wxDataViewCtrl::HitTest(const wxPoint& point,
5108 wxDataViewItem& item,
5109 wxDataViewColumn *& column) const
5110 {
5111 // gtk_tree_view_get_dest_row_at_pos() is the right one. But it does not tell the column.
5112 // gtk_tree_view_get_path_at_pos() is the wrong function. It doesn't mind the header but returns column.
5113 // See http://mail.gnome.org/archives/gtkmm-list/2005-January/msg00080.html
5114 // So we have to use both of them.
5115 item = wxDataViewItem(0);
5116 column = NULL;
5117 wxGtkTreePath path, pathScratch;
5118 GtkTreeViewColumn* GtkColumn = NULL;
5119 GtkTreeViewDropPosition pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
5120 gint cell_x = 0;
5121 gint cell_y = 0;
5122
5123 // cannot directly call GtkGetTreeView(), HitTest is const and so is this pointer
5124 wxDataViewCtrl* self = const_cast<wxDataViewCtrl *>(this); // ugly workaround, self is NOT const
5125 GtkTreeView* treeView = GTK_TREE_VIEW(self->GtkGetTreeView());
5126
5127 // is there possibly a better suited function to get the column?
5128 gtk_tree_view_get_path_at_pos( // and this is the wrong call but it delivers the column
5129 treeView,
5130 (int) point.x, (int) point.y,
5131 pathScratch.ByRef(),
5132 &GtkColumn, // here we get the GtkColumn
5133 &cell_x,
5134 &cell_y );
5135
5136 if ( GtkColumn != NULL )
5137 {
5138 // we got GTK column
5139 // the right call now which takes the header into account
5140 gtk_tree_view_get_dest_row_at_pos( treeView, (int) point.x, (int) point.y, path.ByRef(), &pos);
5141
5142 if (path)
5143 item = wxDataViewItem(GTKPathToItem(path));
5144 // else we got a GTK column but the position is not over an item, e.g. below last item
5145 for ( unsigned int i=0, cols=GetColumnCount(); i<cols; ++i ) // search the wx column
5146 {
5147 wxDataViewColumn* col = GetColumn(i);
5148 if ( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) == GtkColumn )
5149 {
5150 column = col; // here we get the wx column
5151 break;
5152 }
5153 }
5154 }
5155 // else no column and thus no item, both null
5156 }
5157
5158 wxRect
5159 wxDataViewCtrl::GetItemRect(const wxDataViewItem& WXUNUSED(item),
5160 const wxDataViewColumn *WXUNUSED(column)) const
5161 {
5162 return wxRect();
5163 }
5164
5165 bool wxDataViewCtrl::SetRowHeight(int rowHeight)
5166 {
5167 m_uniformRowHeight = rowHeight;
5168 return true;
5169 }
5170
5171 void wxDataViewCtrl::DoSetExpanderColumn()
5172 {
5173 gtk_tree_view_set_expander_column( GTK_TREE_VIEW(m_treeview),
5174 GTK_TREE_VIEW_COLUMN( GetExpanderColumn()->GetGtkHandle() ) );
5175 }
5176
5177 void wxDataViewCtrl::DoSetIndent()
5178 {
5179 }
5180
5181 void wxDataViewCtrl::GtkDisableSelectionEvents()
5182 {
5183 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5184 g_signal_handlers_disconnect_by_func( selection,
5185 (gpointer) (wxdataview_selection_changed_callback), this);
5186 }
5187
5188 void wxDataViewCtrl::GtkEnableSelectionEvents()
5189 {
5190 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5191 g_signal_connect_after (selection, "changed",
5192 G_CALLBACK (wxdataview_selection_changed_callback), this);
5193 }
5194
5195 // ----------------------------------------------------------------------------
5196 // visual attributes stuff
5197 // ----------------------------------------------------------------------------
5198
5199 // static
5200 wxVisualAttributes
5201 wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
5202 {
5203 return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new);
5204 }
5205
5206 void wxDataViewCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
5207 {
5208 wxDataViewCtrlBase::DoApplyWidgetStyle(style);
5209 GTKApplyStyle(m_treeview, style);
5210 }
5211
5212 #endif // !wxUSE_GENERICDATAVIEWCTRL
5213
5214 #endif // wxUSE_DATAVIEWCTRL
wxWidgets (Impactor)