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