1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/dataview.cpp
3 // Purpose: wxDataViewCtrl GTK+2 implementation
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
13 #if wxUSE_DATAVIEWCTRL
15 #include "wx/dataview.h"
17 #ifndef wxUSE_GENERICDATAVIEWCTRL
21 #include "wx/dcclient.h"
23 #include "wx/settings.h"
27 #include "wx/stockitem.h"
28 #include "wx/calctrl.h"
29 #include "wx/popupwin.h"
30 #include "wx/listimpl.cpp"
32 #include "wx/gtk/private.h"
33 #include "wx/gtk/dc.h"
34 #include "wx/gtk/dcclient.h"
36 #include "wx/gtk/private/gdkconv.h"
37 using namespace wxGTKImpl
;
39 //-----------------------------------------------------------------------------
40 //-----------------------------------------------------------------------------
42 static wxDataViewCtrlInternal
*gs_internal
= NULL
;
44 class wxGtkTreeModelNode
;
47 typedef struct _GtkWxTreeModel GtkWxTreeModel
;
50 //-----------------------------------------------------------------------------
51 // wxDataViewCtrlInternal
52 //-----------------------------------------------------------------------------
54 WX_DECLARE_LIST(wxDataViewItem
, ItemList
);
55 WX_DEFINE_LIST(ItemList
)
57 class WXDLLIMPEXP_ADV wxDataViewCtrlInternal
60 wxDataViewCtrlInternal( wxDataViewCtrl
*owner
, wxDataViewModel
*wx_model
, GtkWxTreeModel
*gtk_model
);
61 ~wxDataViewCtrlInternal();
64 GtkTreeModelFlags
get_flags();
65 gboolean
get_iter( GtkTreeIter
*iter
, GtkTreePath
*path
);
66 GtkTreePath
*get_path( GtkTreeIter
*iter
);
67 gboolean
iter_next( GtkTreeIter
*iter
);
68 gboolean
iter_children( GtkTreeIter
*iter
, GtkTreeIter
*parent
);
69 gboolean
iter_has_child( GtkTreeIter
*iter
);
70 gint
iter_n_children( GtkTreeIter
*iter
);
71 gboolean
iter_nth_child( GtkTreeIter
*iter
, GtkTreeIter
*parent
, gint n
);
72 gboolean
iter_parent( GtkTreeIter
*iter
, GtkTreeIter
*child
);
76 bool EnableDragSource( const wxDataFormat
&format
);
77 bool EnableDropTarget( const wxDataFormat
&format
);
79 gboolean
row_draggable( GtkTreeDragSource
*drag_source
, GtkTreePath
*path
);
80 gboolean
drag_data_delete( GtkTreeDragSource
*drag_source
, GtkTreePath
* path
);
81 gboolean
drag_data_get( GtkTreeDragSource
*drag_source
, GtkTreePath
*path
,
82 GtkSelectionData
*selection_data
);
83 gboolean
drag_data_received( GtkTreeDragDest
*drag_dest
, GtkTreePath
*dest
,
84 GtkSelectionData
*selection_data
);
85 gboolean
row_drop_possible( GtkTreeDragDest
*drag_dest
, GtkTreePath
*dest_path
,
86 GtkSelectionData
*selection_data
);
88 // notifactions from wxDataViewModel
89 bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
90 bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
91 bool ItemChanged( const wxDataViewItem
&item
);
92 bool ValueChanged( const wxDataViewItem
&item
, unsigned int col
);
97 void SetSortOrder( GtkSortType sort_order
) { m_sort_order
= sort_order
; }
98 GtkSortType
GetSortOrder() const { return m_sort_order
; }
100 void SetSortColumn( int column
) { m_sort_column
= column
; }
101 int GetSortColumn() const { return m_sort_column
; }
103 void SetDataViewSortColumn( wxDataViewColumn
*column
) { m_dataview_sort_column
= column
; }
104 wxDataViewColumn
*GetDataViewSortColumn() { return m_dataview_sort_column
; }
106 bool IsSorted() { return (m_sort_column
>= 0); }
109 wxDataViewModel
* GetDataViewModel() { return m_wx_model
; }
110 const wxDataViewModel
* GetDataViewModel() const { return m_wx_model
; }
111 wxDataViewCtrl
* GetOwner() { return m_owner
; }
112 GtkWxTreeModel
* GetGtkModel() { return m_gtk_model
; }
116 wxGtkTreeModelNode
*FindNode( const wxDataViewItem
&item
);
117 wxGtkTreeModelNode
*FindNode( GtkTreeIter
*iter
);
118 wxGtkTreeModelNode
*FindParentNode( const wxDataViewItem
&item
);
119 wxGtkTreeModelNode
*FindParentNode( GtkTreeIter
*iter
);
120 void BuildBranch( wxGtkTreeModelNode
*branch
);
123 wxGtkTreeModelNode
*m_root
;
124 wxDataViewModel
*m_wx_model
;
125 GtkWxTreeModel
*m_gtk_model
;
126 wxDataViewCtrl
*m_owner
;
127 GtkSortType m_sort_order
;
128 wxDataViewColumn
*m_dataview_sort_column
;
131 GtkTargetEntry m_dragSourceTargetEntry
;
132 wxCharBuffer m_dragSourceTargetEntryTarget
;
133 wxDataObject
*m_dragDataObject
;
135 GtkTargetEntry m_dropTargetTargetEntry
;
136 wxCharBuffer m_dropTargetTargetEntryTarget
;
137 wxDataObject
*m_dropDataObject
;
141 //-----------------------------------------------------------------------------
142 // wxGtkTreeModelNode
143 //-----------------------------------------------------------------------------
146 int LINKAGEMODE
wxGtkTreeModelChildCmp( void** id1
, void** id2
)
148 int ret
= gs_internal
->GetDataViewModel()->Compare( *id1
, *id2
,
149 gs_internal
->GetSortColumn(), (gs_internal
->GetSortOrder() == GTK_SORT_ASCENDING
) );
154 WX_DEFINE_ARRAY_PTR( wxGtkTreeModelNode
*, wxGtkTreeModelNodes
);
155 WX_DEFINE_ARRAY_PTR( void*, wxGtkTreeModelChildren
);
157 class wxGtkTreeModelNode
160 wxGtkTreeModelNode( wxGtkTreeModelNode
* parent
, const wxDataViewItem
&item
,
161 wxDataViewCtrlInternal
*internal
)
165 m_internal
= internal
;
168 ~wxGtkTreeModelNode()
170 size_t count
= m_nodes
.GetCount();
172 for (i
= 0; i
< count
; i
++)
174 wxGtkTreeModelNode
*child
= m_nodes
.Item( i
);
179 unsigned int AddNode( wxGtkTreeModelNode
* child
)
181 m_nodes
.Add( child
);
183 void *id
= child
->GetItem().GetID();
185 m_children
.Add( id
);
187 if (m_internal
->IsSorted() || m_internal
->GetDataViewModel()->HasDefaultCompare())
189 gs_internal
= m_internal
;
190 m_children
.Sort( &wxGtkTreeModelChildCmp
);
191 return m_children
.Index( id
);
194 return m_children
.GetCount()-1;
197 unsigned int AddLeave( void* id
)
199 m_children
.Add( id
);
201 if (m_internal
->IsSorted() || m_internal
->GetDataViewModel()->HasDefaultCompare())
203 gs_internal
= m_internal
;
204 m_children
.Sort( &wxGtkTreeModelChildCmp
);
205 return m_children
.Index( id
);
208 return m_children
.GetCount()-1;
211 void DeleteChild( void* id
)
213 m_children
.Remove( id
);
215 unsigned int count
= m_nodes
.GetCount();
217 for (pos
= 0; pos
< count
; pos
++)
219 wxGtkTreeModelNode
*node
= m_nodes
.Item( pos
);
220 if (node
->GetItem().GetID() == id
)
222 m_nodes
.RemoveAt( pos
);
229 wxGtkTreeModelNode
* GetParent()
231 wxGtkTreeModelNodes
&GetNodes()
233 wxGtkTreeModelChildren
&GetChildren()
234 { return m_children
; }
236 unsigned int GetChildCount() const { return m_children
.GetCount(); }
237 unsigned int GetNodesCount() const { return m_nodes
.GetCount(); }
239 wxDataViewItem
&GetItem() { return m_item
; }
240 wxDataViewCtrlInternal
*GetInternal() { return m_internal
; }
245 wxGtkTreeModelNode
*m_parent
;
246 wxGtkTreeModelNodes m_nodes
;
247 wxGtkTreeModelChildren m_children
;
248 wxDataViewItem m_item
;
249 wxDataViewCtrlInternal
*m_internal
;
253 //-----------------------------------------------------------------------------
255 //-----------------------------------------------------------------------------
257 extern bool g_blockEventsOnDrag
;
259 //-----------------------------------------------------------------------------
260 // define new GTK+ class wxGtkTreeModel
261 //-----------------------------------------------------------------------------
265 #define GTK_TYPE_WX_TREE_MODEL (gtk_wx_tree_model_get_type ())
266 #define GTK_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModel))
267 #define GTK_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
268 #define GTK_IS_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_TREE_MODEL))
269 #define GTK_IS_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_TREE_MODEL))
270 #define GTK_WX_TREE_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
272 GType
gtk_wx_tree_model_get_type (void);
274 typedef struct _GtkWxTreeModelClass GtkWxTreeModelClass
;
276 struct _GtkWxTreeModel
282 wxDataViewCtrlInternal
*internal
;
285 struct _GtkWxTreeModelClass
287 GObjectClass list_parent_class
;
290 static GtkWxTreeModel
*wxgtk_tree_model_new (void);
291 static void wxgtk_tree_model_init (GtkWxTreeModel
*tree_model
);
292 static void wxgtk_tree_model_class_init (GtkWxTreeModelClass
*klass
);
294 static void wxgtk_tree_model_tree_model_init (GtkTreeModelIface
*iface
);
295 static void wxgtk_tree_model_sortable_init (GtkTreeSortableIface
*iface
);
296 static void wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface
*iface
);
297 static void wxgtk_tree_model_drag_dest_init (GtkTreeDragDestIface
*iface
);
299 static void wxgtk_tree_model_finalize (GObject
*object
);
300 static GtkTreeModelFlags
wxgtk_tree_model_get_flags (GtkTreeModel
*tree_model
);
301 static gint
wxgtk_tree_model_get_n_columns (GtkTreeModel
*tree_model
);
302 static GType
wxgtk_tree_model_get_column_type (GtkTreeModel
*tree_model
,
304 static gboolean
wxgtk_tree_model_get_iter (GtkTreeModel
*tree_model
,
307 static GtkTreePath
*wxgtk_tree_model_get_path (GtkTreeModel
*tree_model
,
309 static void wxgtk_tree_model_get_value (GtkTreeModel
*tree_model
,
313 static gboolean
wxgtk_tree_model_iter_next (GtkTreeModel
*tree_model
,
315 static gboolean
wxgtk_tree_model_iter_children (GtkTreeModel
*tree_model
,
317 GtkTreeIter
*parent
);
318 static gboolean
wxgtk_tree_model_iter_has_child (GtkTreeModel
*tree_model
,
320 static gint
wxgtk_tree_model_iter_n_children (GtkTreeModel
*tree_model
,
322 static gboolean
wxgtk_tree_model_iter_nth_child (GtkTreeModel
*tree_model
,
326 static gboolean
wxgtk_tree_model_iter_parent (GtkTreeModel
*tree_model
,
331 static gboolean
wxgtk_tree_model_get_sort_column_id (GtkTreeSortable
*sortable
,
332 gint
*sort_column_id
,
334 static void wxgtk_tree_model_set_sort_column_id (GtkTreeSortable
*sortable
,
337 static void wxgtk_tree_model_set_sort_func (GtkTreeSortable
*sortable
,
339 GtkTreeIterCompareFunc func
,
341 GtkDestroyNotify destroy
);
342 static void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable
*sortable
,
343 GtkTreeIterCompareFunc func
,
345 GtkDestroyNotify destroy
);
346 static gboolean
wxgtk_tree_model_has_default_sort_func (GtkTreeSortable
*sortable
);
349 static gboolean
wxgtk_tree_model_row_draggable (GtkTreeDragSource
*drag_source
,
351 static gboolean
wxgtk_tree_model_drag_data_delete (GtkTreeDragSource
*drag_source
,
353 static gboolean
wxgtk_tree_model_drag_data_get (GtkTreeDragSource
*drag_source
,
355 GtkSelectionData
*selection_data
);
356 static gboolean
wxgtk_tree_model_drag_data_received (GtkTreeDragDest
*drag_dest
,
358 GtkSelectionData
*selection_data
);
359 static gboolean
wxgtk_tree_model_row_drop_possible (GtkTreeDragDest
*drag_dest
,
360 GtkTreePath
*dest_path
,
361 GtkSelectionData
*selection_data
);
364 static GObjectClass
*list_parent_class
= NULL
;
367 gtk_wx_tree_model_get_type (void)
369 static GType tree_model_type
= 0;
371 if (!tree_model_type
)
373 const GTypeInfo tree_model_info
=
375 sizeof (GtkWxTreeModelClass
),
376 NULL
, /* base_init */
377 NULL
, /* base_finalize */
378 (GClassInitFunc
) wxgtk_tree_model_class_init
,
379 NULL
, /* class_finalize */
380 NULL
, /* class_data */
381 sizeof (GtkWxTreeModel
),
383 (GInstanceInitFunc
) wxgtk_tree_model_init
,
386 static const GInterfaceInfo tree_model_iface_info
=
388 (GInterfaceInitFunc
) wxgtk_tree_model_tree_model_init
,
393 static const GInterfaceInfo sortable_iface_info
=
395 (GInterfaceInitFunc
) wxgtk_tree_model_sortable_init
,
400 static const GInterfaceInfo drag_source_iface_info
=
402 (GInterfaceInitFunc
) wxgtk_tree_model_drag_source_init
,
407 static const GInterfaceInfo drag_dest_iface_info
=
409 (GInterfaceInitFunc
) wxgtk_tree_model_drag_dest_init
,
414 tree_model_type
= g_type_register_static (G_TYPE_OBJECT
, "GtkWxTreeModel",
415 &tree_model_info
, (GTypeFlags
)0 );
417 g_type_add_interface_static (tree_model_type
,
419 &tree_model_iface_info
);
420 g_type_add_interface_static (tree_model_type
,
421 GTK_TYPE_TREE_SORTABLE
,
422 &sortable_iface_info
);
423 g_type_add_interface_static (tree_model_type
,
424 GTK_TYPE_TREE_DRAG_DEST
,
425 &drag_dest_iface_info
);
426 g_type_add_interface_static (tree_model_type
,
427 GTK_TYPE_TREE_DRAG_SOURCE
,
428 &drag_source_iface_info
);
431 return tree_model_type
;
434 static GtkWxTreeModel
*
435 wxgtk_tree_model_new(void)
437 GtkWxTreeModel
*retval
= (GtkWxTreeModel
*) g_object_new (GTK_TYPE_WX_TREE_MODEL
, NULL
);
442 wxgtk_tree_model_class_init (GtkWxTreeModelClass
*klass
)
444 list_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
445 GObjectClass
*object_class
= (GObjectClass
*) klass
;
446 object_class
->finalize
= wxgtk_tree_model_finalize
;
450 wxgtk_tree_model_tree_model_init (GtkTreeModelIface
*iface
)
452 iface
->get_flags
= wxgtk_tree_model_get_flags
;
453 iface
->get_n_columns
= wxgtk_tree_model_get_n_columns
;
454 iface
->get_column_type
= wxgtk_tree_model_get_column_type
;
455 iface
->get_iter
= wxgtk_tree_model_get_iter
;
456 iface
->get_path
= wxgtk_tree_model_get_path
;
457 iface
->get_value
= wxgtk_tree_model_get_value
;
458 iface
->iter_next
= wxgtk_tree_model_iter_next
;
459 iface
->iter_children
= wxgtk_tree_model_iter_children
;
460 iface
->iter_has_child
= wxgtk_tree_model_iter_has_child
;
461 iface
->iter_n_children
= wxgtk_tree_model_iter_n_children
;
462 iface
->iter_nth_child
= wxgtk_tree_model_iter_nth_child
;
463 iface
->iter_parent
= wxgtk_tree_model_iter_parent
;
467 wxgtk_tree_model_sortable_init (GtkTreeSortableIface
*iface
)
469 iface
->get_sort_column_id
= wxgtk_tree_model_get_sort_column_id
;
470 iface
->set_sort_column_id
= wxgtk_tree_model_set_sort_column_id
;
471 iface
->set_sort_func
= wxgtk_tree_model_set_sort_func
;
472 iface
->set_default_sort_func
= wxgtk_tree_model_set_default_sort_func
;
473 iface
->has_default_sort_func
= wxgtk_tree_model_has_default_sort_func
;
477 wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface
*iface
)
479 iface
->row_draggable
= wxgtk_tree_model_row_draggable
;
480 iface
->drag_data_delete
= wxgtk_tree_model_drag_data_delete
;
481 iface
->drag_data_get
= wxgtk_tree_model_drag_data_get
;
485 wxgtk_tree_model_drag_dest_init (GtkTreeDragDestIface
*iface
)
487 iface
->drag_data_received
= wxgtk_tree_model_drag_data_received
;
488 iface
->row_drop_possible
= wxgtk_tree_model_row_drop_possible
;
492 wxgtk_tree_model_init (GtkWxTreeModel
*tree_model
)
494 tree_model
->internal
= NULL
;
495 tree_model
->stamp
= g_random_int();
499 wxgtk_tree_model_finalize (GObject
*object
)
502 (* list_parent_class
->finalize
) (object
);
507 //-----------------------------------------------------------------------------
508 // implement callbacks from wxGtkTreeModel class by letting
509 // them call the methods of wxWidgets' wxDataViewModel
510 //-----------------------------------------------------------------------------
512 static GtkTreeModelFlags
513 wxgtk_tree_model_get_flags (GtkTreeModel
*tree_model
)
515 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
516 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), (GtkTreeModelFlags
)0 );
518 return wxtree_model
->internal
->get_flags();
522 wxgtk_tree_model_get_n_columns (GtkTreeModel
*tree_model
)
524 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
525 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), 0);
527 return wxtree_model
->internal
->GetDataViewModel()->GetColumnCount();
531 wxgtk_tree_model_get_column_type (GtkTreeModel
*tree_model
,
534 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
535 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), G_TYPE_INVALID
);
537 GType gtype
= G_TYPE_INVALID
;
539 wxString wxtype
= wxtree_model
->internal
->GetDataViewModel()->GetColumnType( (unsigned int) index
);
541 if (wxtype
== wxT("string"))
542 gtype
= G_TYPE_STRING
;
545 gtype
= G_TYPE_STRING
;
546 // wxFAIL_MSG( wxT("non-string columns not supported yet") );
553 wxgtk_tree_model_get_iter (GtkTreeModel
*tree_model
,
557 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
558 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
559 g_return_val_if_fail (gtk_tree_path_get_depth (path
) > 0, FALSE
);
561 return wxtree_model
->internal
->get_iter( iter
, path
);
565 wxgtk_tree_model_get_path (GtkTreeModel
*tree_model
,
568 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
569 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), NULL
);
570 g_return_val_if_fail (iter
->stamp
== GTK_WX_TREE_MODEL (wxtree_model
)->stamp
, NULL
);
572 return wxtree_model
->internal
->get_path( iter
);
576 wxgtk_tree_model_get_value (GtkTreeModel
*tree_model
,
581 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
582 g_return_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
) );
584 wxDataViewModel
*model
= wxtree_model
->internal
->GetDataViewModel();
585 wxString mtype
= model
->GetColumnType( (unsigned int) column
);
586 if (mtype
== wxT("string"))
589 g_value_init( value
, G_TYPE_STRING
);
590 wxDataViewItem
item( (void*) iter
->user_data
);
591 model
->GetValue( variant
, item
, (unsigned int) column
);
593 g_value_set_string( value
, variant
.GetString().utf8_str() );
597 wxFAIL_MSG( wxT("non-string columns not supported yet") );
602 wxgtk_tree_model_iter_next (GtkTreeModel
*tree_model
,
605 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
607 // This happens when clearing the view by calling .._set_model( NULL );
608 if (iter
->stamp
== 0) return FALSE
;
610 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
611 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, FALSE
);
613 return wxtree_model
->internal
->iter_next( iter
);
617 wxgtk_tree_model_iter_children (GtkTreeModel
*tree_model
,
621 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
622 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
623 g_return_val_if_fail (wxtree_model
->stamp
== parent
->stamp
, FALSE
);
625 return wxtree_model
->internal
->iter_children( iter
, parent
);
629 wxgtk_tree_model_iter_has_child (GtkTreeModel
*tree_model
,
632 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
633 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
634 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, FALSE
);
636 return wxtree_model
->internal
->iter_has_child( iter
);
640 wxgtk_tree_model_iter_n_children (GtkTreeModel
*tree_model
,
643 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
644 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), 0);
645 g_return_val_if_fail ( !iter
|| wxtree_model
->stamp
== iter
->stamp
, 0);
647 return wxtree_model
->internal
->iter_n_children( iter
);
651 wxgtk_tree_model_iter_nth_child (GtkTreeModel
*tree_model
,
656 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
657 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
659 return wxtree_model
->internal
->iter_nth_child( iter
, parent
, n
);
663 wxgtk_tree_model_iter_parent (GtkTreeModel
*tree_model
,
667 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
668 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
669 g_return_val_if_fail (wxtree_model
->stamp
== child
->stamp
, FALSE
);
671 return wxtree_model
->internal
->iter_parent( iter
, child
);
674 /* drag'n'drop iface */
676 wxgtk_tree_model_row_draggable (GtkTreeDragSource
*drag_source
,
679 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
680 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
682 return wxtree_model
->internal
->row_draggable( drag_source
, path
);
686 wxgtk_tree_model_drag_data_delete (GtkTreeDragSource
*drag_source
,
689 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
690 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
692 return wxtree_model
->internal
->drag_data_delete( drag_source
, path
);
696 wxgtk_tree_model_drag_data_get (GtkTreeDragSource
*drag_source
,
698 GtkSelectionData
*selection_data
)
700 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
701 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
704 wxPrintf( "drag_get_data\n");
706 wxGtkString
atom_selection(gdk_atom_name(selection_data
->selection
));
707 wxPrintf( "selection %s\n", wxString::FromAscii(atom_selection
) );
709 wxGtkString
atom_target(gdk_atom_name(selection_data
->target
));
710 wxPrintf( "target %s\n", wxString::FromAscii(atom_target
) );
712 wxGtkString
atom_type(gdk_atom_name(selection_data
->type
));
713 wxPrintf( "type %s\n", wxString::FromAscii(atom_type
) );
715 wxPrintf( "format %d\n", selection_data
->format
);
718 return wxtree_model
->internal
->drag_data_get( drag_source
, path
, selection_data
);
722 wxgtk_tree_model_drag_data_received (GtkTreeDragDest
*drag_dest
,
724 GtkSelectionData
*selection_data
)
726 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_dest
;
727 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
729 return wxtree_model
->internal
->drag_data_received( drag_dest
, dest
, selection_data
);
733 wxgtk_tree_model_row_drop_possible (GtkTreeDragDest
*drag_dest
,
734 GtkTreePath
*dest_path
,
735 GtkSelectionData
*selection_data
)
737 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_dest
;
738 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
740 return wxtree_model
->internal
->row_drop_possible( drag_dest
, dest_path
, selection_data
);
745 wxgtk_tree_model_get_sort_column_id (GtkTreeSortable
*sortable
,
746 gint
*sort_column_id
,
749 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) sortable
;
751 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable
), FALSE
);
753 if (!wxtree_model
->internal
->IsSorted())
756 *sort_column_id
= -1;
763 *sort_column_id
= wxtree_model
->internal
->GetSortColumn();
766 *order
= wxtree_model
->internal
->GetSortOrder();
771 wxDataViewColumn
*gs_lastLeftClickHeader
= NULL
;
774 wxgtk_tree_model_set_sort_column_id (GtkTreeSortable
*sortable
,
778 GtkWxTreeModel
*tree_model
= (GtkWxTreeModel
*) sortable
;
779 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
781 tree_model
->internal
->SetDataViewSortColumn( gs_lastLeftClickHeader
);
783 if ((sort_column_id
!= (gint
) tree_model
->internal
->GetSortColumn()) ||
784 (order
!= tree_model
->internal
->GetSortOrder()))
786 tree_model
->internal
->SetSortColumn( sort_column_id
);
787 tree_model
->internal
->SetSortOrder( order
);
789 gtk_tree_sortable_sort_column_changed (sortable
);
791 tree_model
->internal
->GetDataViewModel()->Resort();
794 if (gs_lastLeftClickHeader
)
796 wxDataViewCtrl
*dv
= tree_model
->internal
->GetOwner();
797 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED
, dv
->GetId() );
798 event
.SetDataViewColumn( gs_lastLeftClickHeader
);
799 event
.SetModel( dv
->GetModel() );
800 dv
->HandleWindowEvent( event
);
803 gs_lastLeftClickHeader
= NULL
;
807 wxgtk_tree_model_set_sort_func (GtkTreeSortable
*sortable
,
808 gint
WXUNUSED(sort_column_id
),
809 GtkTreeIterCompareFunc func
,
810 gpointer
WXUNUSED(data
),
811 GtkDestroyNotify
WXUNUSED(destroy
))
813 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
814 g_return_if_fail (func
!= NULL
);
818 wxgtk_tree_model_set_default_sort_func (GtkTreeSortable
*sortable
,
819 GtkTreeIterCompareFunc func
,
820 gpointer
WXUNUSED(data
),
821 GtkDestroyNotify
WXUNUSED(destroy
))
823 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
824 g_return_if_fail (func
!= NULL
);
826 //wxPrintf( "wxgtk_tree_model_set_default_sort_func\n" );
827 // TODO: remove this code
831 wxgtk_tree_model_has_default_sort_func (GtkTreeSortable
*sortable
)
833 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable
), FALSE
);
838 //-----------------------------------------------------------------------------
839 // define new GTK+ class GtkWxRendererText
840 //-----------------------------------------------------------------------------
844 #define GTK_TYPE_WX_CELL_RENDERER_TEXT (gtk_wx_cell_renderer_text_get_type ())
845 #define GTK_WX_CELL_RENDERER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererText))
846 #define GTK_WX_CELL_RENDERER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererTextClass))
847 #define GTK_IS_WX_CELL_RENDERER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT))
848 #define GTK_IS_WX_CELL_RENDERER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT))
849 #define GTK_WX_CELL_RENDERER_TEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererTextClass))
851 GType
gtk_wx_cell_renderer_text_get_type (void);
853 typedef struct _GtkWxCellRendererText GtkWxCellRendererText
;
854 typedef struct _GtkWxCellRendererTextClass GtkWxCellRendererTextClass
;
856 struct _GtkWxCellRendererText
858 GtkCellRendererText parent
;
860 wxDataViewRenderer
*wx_renderer
;
863 struct _GtkWxCellRendererTextClass
865 GtkCellRendererTextClass cell_parent_class
;
869 static GtkWxCellRendererText
*gtk_wx_cell_renderer_text_new (void);
870 static void gtk_wx_cell_renderer_text_init (
871 GtkWxCellRendererText
*cell
);
872 static void gtk_wx_cell_renderer_text_class_init(
873 GtkWxCellRendererTextClass
*klass
);
874 static void gtk_wx_cell_renderer_text_finalize (
876 static GtkCellEditable
*gtk_wx_cell_renderer_text_start_editing(
877 GtkCellRenderer
*cell
,
881 GdkRectangle
*background_area
,
882 GdkRectangle
*cell_area
,
883 GtkCellRendererState flags
);
886 static GObjectClass
*text_cell_parent_class
= NULL
;
891 gtk_wx_cell_renderer_text_get_type (void)
893 static GType cell_wx_type
= 0;
897 const GTypeInfo cell_wx_info
=
899 sizeof (GtkWxCellRendererTextClass
),
900 NULL
, /* base_init */
901 NULL
, /* base_finalize */
902 (GClassInitFunc
) gtk_wx_cell_renderer_text_class_init
,
903 NULL
, /* class_finalize */
904 NULL
, /* class_data */
905 sizeof (GtkWxCellRendererText
),
907 (GInstanceInitFunc
) gtk_wx_cell_renderer_text_init
,
910 cell_wx_type
= g_type_register_static( GTK_TYPE_CELL_RENDERER_TEXT
,
911 "GtkWxCellRendererText", &cell_wx_info
, (GTypeFlags
)0 );
918 gtk_wx_cell_renderer_text_init (GtkWxCellRendererText
*cell
)
920 cell
->wx_renderer
= NULL
;
924 gtk_wx_cell_renderer_text_class_init (GtkWxCellRendererTextClass
*klass
)
926 GObjectClass
*object_class
= G_OBJECT_CLASS (klass
);
927 GtkCellRendererClass
*cell_class
= GTK_CELL_RENDERER_CLASS (klass
);
929 text_cell_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
931 object_class
->finalize
= gtk_wx_cell_renderer_text_finalize
;
933 cell_class
->start_editing
= gtk_wx_cell_renderer_text_start_editing
;
937 gtk_wx_cell_renderer_text_finalize (GObject
*object
)
940 (* G_OBJECT_CLASS (text_cell_parent_class
)->finalize
) (object
);
943 GtkWxCellRendererText
*
944 gtk_wx_cell_renderer_text_new (void)
946 return (GtkWxCellRendererText
*) g_object_new (GTK_TYPE_WX_CELL_RENDERER_TEXT
, NULL
);
949 static GtkCellEditable
*gtk_wx_cell_renderer_text_start_editing(
950 GtkCellRenderer
*gtk_renderer
,
954 GdkRectangle
*background_area
,
955 GdkRectangle
*cell_area
,
956 GtkCellRendererState flags
)
958 GtkWxCellRendererText
*wxgtk_renderer
= (GtkWxCellRendererText
*) gtk_renderer
;
959 wxDataViewRenderer
*wx_renderer
= wxgtk_renderer
->wx_renderer
;
961 GtkTreePath
*treepath
= gtk_tree_path_new_from_string( path
);
963 wx_renderer
->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, treepath
);
964 wxDataViewItem
item( (void*) iter
.user_data
);;
965 gtk_tree_path_free( treepath
);
967 wxDataViewColumn
*column
= wx_renderer
->GetOwner();
968 wxDataViewCtrl
*dv
= column
->GetOwner();
969 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING
, dv
->GetId() );
970 event
.SetDataViewColumn( column
);
971 event
.SetModel( dv
->GetModel() );
972 event
.SetColumn( wx_renderer
->GetOwner()->GetModelColumn() );
973 event
.SetItem( item
);
974 dv
->HandleWindowEvent( event
);
976 if (event
.IsAllowed())
977 return GTK_CELL_RENDERER_CLASS(text_cell_parent_class
)->
978 start_editing( gtk_renderer
, gdk_event
, widget
, path
, background_area
, cell_area
, flags
);
983 //-----------------------------------------------------------------------------
984 // define new GTK+ class GtkWxCellRenderer
985 //-----------------------------------------------------------------------------
989 #define GTK_TYPE_WX_CELL_RENDERER (gtk_wx_cell_renderer_get_type ())
990 #define GTK_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRenderer))
991 #define GTK_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
992 #define GTK_IS_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER))
993 #define GTK_IS_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER))
994 #define GTK_WX_CELL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
996 GType
gtk_wx_cell_renderer_get_type (void);
998 typedef struct _GtkWxCellRenderer GtkWxCellRenderer
;
999 typedef struct _GtkWxCellRendererClass GtkWxCellRendererClass
;
1001 struct _GtkWxCellRenderer
1003 GtkCellRenderer parent
;
1006 wxDataViewCustomRenderer
*cell
;
1010 struct _GtkWxCellRendererClass
1012 GtkCellRendererClass cell_parent_class
;
1016 static GtkCellRenderer
*gtk_wx_cell_renderer_new (void);
1017 static void gtk_wx_cell_renderer_init (
1018 GtkWxCellRenderer
*cell
);
1019 static void gtk_wx_cell_renderer_class_init(
1020 GtkWxCellRendererClass
*klass
);
1021 static void gtk_wx_cell_renderer_finalize (
1023 static void gtk_wx_cell_renderer_get_size (
1024 GtkCellRenderer
*cell
,
1026 GdkRectangle
*rectangle
,
1031 static void gtk_wx_cell_renderer_render (
1032 GtkCellRenderer
*cell
,
1035 GdkRectangle
*background_area
,
1036 GdkRectangle
*cell_area
,
1037 GdkRectangle
*expose_area
,
1038 GtkCellRendererState flags
);
1039 static gboolean
gtk_wx_cell_renderer_activate(
1040 GtkCellRenderer
*cell
,
1044 GdkRectangle
*background_area
,
1045 GdkRectangle
*cell_area
,
1046 GtkCellRendererState flags
);
1047 static GtkCellEditable
*gtk_wx_cell_renderer_start_editing(
1048 GtkCellRenderer
*cell
,
1052 GdkRectangle
*background_area
,
1053 GdkRectangle
*cell_area
,
1054 GtkCellRendererState flags
);
1057 static GObjectClass
*cell_parent_class
= NULL
;
1062 gtk_wx_cell_renderer_get_type (void)
1064 static GType cell_wx_type
= 0;
1068 const GTypeInfo cell_wx_info
=
1070 sizeof (GtkWxCellRendererClass
),
1071 NULL
, /* base_init */
1072 NULL
, /* base_finalize */
1073 (GClassInitFunc
) gtk_wx_cell_renderer_class_init
,
1074 NULL
, /* class_finalize */
1075 NULL
, /* class_data */
1076 sizeof (GtkWxCellRenderer
),
1077 0, /* n_preallocs */
1078 (GInstanceInitFunc
) gtk_wx_cell_renderer_init
,
1081 cell_wx_type
= g_type_register_static( GTK_TYPE_CELL_RENDERER
,
1082 "GtkWxCellRenderer", &cell_wx_info
, (GTypeFlags
)0 );
1085 return cell_wx_type
;
1089 gtk_wx_cell_renderer_init (GtkWxCellRenderer
*cell
)
1092 cell
->last_click
= 0;
1096 gtk_wx_cell_renderer_class_init (GtkWxCellRendererClass
*klass
)
1098 GObjectClass
*object_class
= G_OBJECT_CLASS (klass
);
1099 GtkCellRendererClass
*cell_class
= GTK_CELL_RENDERER_CLASS (klass
);
1101 cell_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
1103 object_class
->finalize
= gtk_wx_cell_renderer_finalize
;
1105 cell_class
->get_size
= gtk_wx_cell_renderer_get_size
;
1106 cell_class
->render
= gtk_wx_cell_renderer_render
;
1107 cell_class
->activate
= gtk_wx_cell_renderer_activate
;
1108 cell_class
->start_editing
= gtk_wx_cell_renderer_start_editing
;
1112 gtk_wx_cell_renderer_finalize (GObject
*object
)
1115 (* G_OBJECT_CLASS (cell_parent_class
)->finalize
) (object
);
1119 gtk_wx_cell_renderer_new (void)
1121 return (GtkCellRenderer
*) g_object_new (GTK_TYPE_WX_CELL_RENDERER
, NULL
);
1124 static GtkCellEditable
*gtk_wx_cell_renderer_start_editing(
1125 GtkCellRenderer
*renderer
,
1126 GdkEvent
*WXUNUSED(event
),
1129 GdkRectangle
*WXUNUSED(background_area
),
1130 GdkRectangle
*cell_area
,
1131 GtkCellRendererState
WXUNUSED(flags
) )
1133 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1134 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1136 // Renderer doesn't support in-place editing
1137 if (!cell
->HasEditorCtrl())
1140 // An in-place editing control is still around
1141 if (cell
->GetEditorCtrl())
1145 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1151 rect
.x
+= cell_area
->x
;
1152 rect
.y
+= cell_area
->y
;
1153 // rect.width -= renderer->xpad * 2;
1154 // rect.height -= renderer->ypad * 2;
1156 // wxRect renderrect(wxRectFromGDKRect(&rect));
1157 wxRect
renderrect(wxRectFromGDKRect(cell_area
));
1159 GtkTreePath
*treepath
= gtk_tree_path_new_from_string( path
);
1161 cell
->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, treepath
);
1162 wxDataViewItem
item( (void*) iter
.user_data
);
1163 gtk_tree_path_free( treepath
);
1165 cell
->StartEditing( item
, renderrect
);
1171 gtk_wx_cell_renderer_get_size (GtkCellRenderer
*renderer
,
1172 GtkWidget
*WXUNUSED(widget
),
1173 GdkRectangle
*cell_area
,
1179 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1180 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1182 wxSize size
= cell
->GetSize();
1184 gint calc_width
= (gint
) renderer
->xpad
* 2 + size
.x
;
1185 gint calc_height
= (gint
) renderer
->ypad
* 2 + size
.y
;
1192 if (cell_area
&& size
.x
> 0 && size
.y
> 0)
1196 *x_offset
= (gint
)((renderer
->xalign
*
1197 (cell_area
->width
- calc_width
- 2 * renderer
->xpad
)));
1198 *x_offset
= MAX (*x_offset
, 0) + renderer
->xpad
;
1202 *y_offset
= (gint
)((renderer
->yalign
*
1203 (cell_area
->height
- calc_height
- 2 * renderer
->ypad
)));
1204 *y_offset
= MAX (*y_offset
, 0) + renderer
->ypad
;
1209 *width
= calc_width
;
1212 *height
= calc_height
;
1216 gtk_wx_cell_renderer_render (GtkCellRenderer
*renderer
,
1219 GdkRectangle
*background_area
,
1220 GdkRectangle
*cell_area
,
1221 GdkRectangle
*expose_area
,
1222 GtkCellRendererState flags
)
1225 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1226 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1228 cell
->GTKStashRenderParams(window
, widget
,
1229 background_area
, expose_area
, flags
);
1231 wxRect
rect(wxRectFromGDKRect(cell_area
));
1232 rect
= rect
.Deflate(renderer
->xpad
, renderer
->ypad
);
1234 wxWindowDC
* dc
= (wxWindowDC
*) cell
->GetDC();
1235 wxWindowDCImpl
*impl
= (wxWindowDCImpl
*) dc
->GetImpl();
1237 // Reinitialize wxWindowDC's GDK window if drawing occurs into a different
1238 // window such as a DnD drop window.
1239 if (window
!= impl
->m_gdkwindow
)
1242 impl
->m_gdkwindow
= window
;
1247 if (flags
& GTK_CELL_RENDERER_SELECTED
)
1248 state
|= wxDATAVIEW_CELL_SELECTED
;
1249 if (flags
& GTK_CELL_RENDERER_PRELIT
)
1250 state
|= wxDATAVIEW_CELL_PRELIT
;
1251 if (flags
& GTK_CELL_RENDERER_INSENSITIVE
)
1252 state
|= wxDATAVIEW_CELL_INSENSITIVE
;
1253 if (flags
& GTK_CELL_RENDERER_INSENSITIVE
)
1254 state
|= wxDATAVIEW_CELL_INSENSITIVE
;
1255 if (flags
& GTK_CELL_RENDERER_FOCUSED
)
1256 state
|= wxDATAVIEW_CELL_FOCUSED
;
1257 cell
->WXCallRender( rect
, dc
, state
);
1261 gtk_wx_cell_renderer_activate(
1262 GtkCellRenderer
*renderer
,
1266 GdkRectangle
*WXUNUSED(background_area
),
1267 GdkRectangle
*cell_area
,
1268 GtkCellRendererState
WXUNUSED(flags
) )
1270 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1271 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1274 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1280 rect
.x
+= cell_area
->x
;
1281 rect
.y
+= cell_area
->y
;
1282 rect
.width
-= renderer
->xpad
* 2;
1283 rect
.height
-= renderer
->ypad
* 2;
1285 wxRect
renderrect(wxRectFromGDKRect(&rect
));
1287 wxDataViewModel
*model
= cell
->GetOwner()->GetOwner()->GetModel();
1289 GtkTreePath
*treepath
= gtk_tree_path_new_from_string( path
);
1292 cell
->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, treepath
);
1293 wxDataViewItem
item( iter
.user_data
);
1294 gtk_tree_path_free( treepath
);
1296 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
1302 // activated by <ENTER>
1303 if (cell
->Activate( renderrect
, model
, item
, model_col
))
1308 else if (event
->type
== GDK_BUTTON_PRESS
)
1310 GdkEventButton
*button_event
= (GdkEventButton
*) event
;
1311 wxPoint
pt( ((int) button_event
->x
) - renderrect
.x
,
1312 ((int) button_event
->y
) - renderrect
.y
);
1315 if (button_event
->button
== 1)
1317 if (cell
->LeftClick( pt
, renderrect
, model
, item
, model_col
))
1319 // TODO: query system double-click time
1320 if (button_event
->time
- wxrenderer
->last_click
< 400)
1321 if (cell
->Activate( renderrect
, model
, item
, model_col
))
1324 wxrenderer
->last_click
= button_event
->time
;
1332 // ---------------------------------------------------------
1333 // wxGtkDataViewModelNotifier
1334 // ---------------------------------------------------------
1336 class wxGtkDataViewModelNotifier
: public wxDataViewModelNotifier
1339 wxGtkDataViewModelNotifier( GtkWxTreeModel
*wxgtk_model
,
1340 wxDataViewModel
*wx_model
,
1341 wxDataViewCtrl
*ctrl
);
1342 ~wxGtkDataViewModelNotifier();
1344 virtual bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
1345 virtual bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
1346 virtual bool ItemChanged( const wxDataViewItem
&item
);
1347 virtual bool ValueChanged( const wxDataViewItem
&item
, unsigned int col
);
1348 virtual bool Cleared();
1349 virtual void Resort();
1351 void SetGtkModel( GtkWxTreeModel
*model
) { m_wxgtk_model
= model
; }
1354 GtkWxTreeModel
*m_wxgtk_model
;
1355 wxDataViewModel
*m_wx_model
;
1356 wxDataViewCtrl
*m_owner
;
1359 // ---------------------------------------------------------
1360 // wxGtkDataViewListModelNotifier
1361 // ---------------------------------------------------------
1363 wxGtkDataViewModelNotifier::wxGtkDataViewModelNotifier(
1364 GtkWxTreeModel
* wxgtk_model
, wxDataViewModel
*wx_model
,
1365 wxDataViewCtrl
*ctrl
)
1367 m_wxgtk_model
= wxgtk_model
;
1368 m_wx_model
= wx_model
;
1372 wxGtkDataViewModelNotifier::~wxGtkDataViewModelNotifier()
1375 m_wxgtk_model
= NULL
;
1378 bool wxGtkDataViewModelNotifier::ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
1380 m_owner
->GtkGetInternal()->ItemAdded( parent
, item
);
1383 iter
.stamp
= m_wxgtk_model
->stamp
;
1384 iter
.user_data
= (gpointer
) item
.GetID();
1386 GtkTreePath
*path
= wxgtk_tree_model_get_path(
1387 GTK_TREE_MODEL(m_wxgtk_model
), &iter
);
1388 gtk_tree_model_row_inserted(
1389 GTK_TREE_MODEL(m_wxgtk_model
), path
, &iter
);
1390 gtk_tree_path_free (path
);
1395 bool wxGtkDataViewModelNotifier::ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
1398 iter
.stamp
= m_wxgtk_model
->stamp
;
1399 iter
.user_data
= (gpointer
) item
.GetID();
1401 GtkTreePath
*path
= wxgtk_tree_model_get_path(
1402 GTK_TREE_MODEL(m_wxgtk_model
), &iter
);
1403 gtk_tree_model_row_deleted(
1404 GTK_TREE_MODEL(m_wxgtk_model
), path
);
1405 gtk_tree_path_free (path
);
1407 m_owner
->GtkGetInternal()->ItemDeleted( parent
, item
);
1412 void wxGtkDataViewModelNotifier::Resort()
1414 m_owner
->GtkGetInternal()->Resort();
1417 bool wxGtkDataViewModelNotifier::ItemChanged( const wxDataViewItem
&item
)
1420 iter
.stamp
= m_wxgtk_model
->stamp
;
1421 iter
.user_data
= (gpointer
) item
.GetID();
1423 GtkTreePath
*path
= wxgtk_tree_model_get_path(
1424 GTK_TREE_MODEL(m_wxgtk_model
), &iter
);
1425 gtk_tree_model_row_changed(
1426 GTK_TREE_MODEL(m_wxgtk_model
), path
, &iter
);
1427 gtk_tree_path_free (path
);
1429 m_owner
->GtkGetInternal()->ItemChanged( item
);
1434 bool wxGtkDataViewModelNotifier::ValueChanged( const wxDataViewItem
&item
, unsigned int model_col
)
1436 // This adds GTK+'s missing MVC logic for ValueChanged
1438 for (index
= 0; index
< m_owner
->GetColumnCount(); index
++)
1440 wxDataViewColumn
*column
= m_owner
->GetColumn( index
);
1441 if (column
->GetModelColumn() == model_col
)
1443 GtkTreeView
*widget
= GTK_TREE_VIEW(m_owner
->m_treeview
);
1444 GtkTreeViewColumn
*gcolumn
= GTK_TREE_VIEW_COLUMN(column
->GetGtkHandle());
1448 iter
.stamp
= m_wxgtk_model
->stamp
;
1449 iter
.user_data
= (gpointer
) item
.GetID();
1450 GtkTreePath
*path
= wxgtk_tree_model_get_path(
1451 GTK_TREE_MODEL(m_wxgtk_model
), &iter
);
1452 GdkRectangle cell_area
;
1453 gtk_tree_view_get_cell_area( widget
, path
, gcolumn
, &cell_area
);
1454 gtk_tree_path_free( path
);
1456 GtkAdjustment
* hadjust
= gtk_tree_view_get_hadjustment( widget
);
1457 double d
= gtk_adjustment_get_value( hadjust
);
1458 int xdiff
= (int) d
;
1460 int ydiff
= gcolumn
->button
->allocation
.height
;
1462 gtk_widget_queue_draw_area( GTK_WIDGET(widget
),
1463 cell_area
.x
- xdiff
, ydiff
+ cell_area
.y
, cell_area
.width
, cell_area
.height
);
1465 m_owner
->GtkGetInternal()->ValueChanged( item
, model_col
);
1474 bool wxGtkDataViewModelNotifier::Cleared()
1476 m_owner
->GtkGetInternal()->Cleared();
1481 // ---------------------------------------------------------
1482 // wxDataViewRenderer
1483 // ---------------------------------------------------------
1485 static gpointer s_user_data
= NULL
;
1488 wxgtk_cell_editable_editing_done( GtkCellEditable
*WXUNUSED(editable
),
1489 wxDataViewRenderer
*wxrenderer
)
1491 wxDataViewColumn
*column
= wxrenderer
->GetOwner();
1492 wxDataViewCtrl
*dv
= column
->GetOwner();
1493 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE
, dv
->GetId() );
1494 event
.SetDataViewColumn( column
);
1495 event
.SetModel( dv
->GetModel() );
1496 wxDataViewItem
item( s_user_data
);
1497 event
.SetItem( item
);
1498 dv
->HandleWindowEvent( event
);
1502 wxgtk_renderer_editing_started( GtkCellRenderer
*WXUNUSED(cell
), GtkCellEditable
*editable
,
1503 gchar
*path
, wxDataViewRenderer
*wxrenderer
)
1508 wxDataViewColumn
*column
= wxrenderer
->GetOwner();
1509 wxDataViewCtrl
*dv
= column
->GetOwner();
1510 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED
, dv
->GetId() );
1511 event
.SetDataViewColumn( column
);
1512 event
.SetModel( dv
->GetModel() );
1513 GtkTreePath
*tree_path
= gtk_tree_path_new_from_string( path
);
1515 dv
->GtkGetInternal()->get_iter( &iter
, tree_path
);
1516 gtk_tree_path_free( tree_path
);
1517 wxDataViewItem
item( iter
.user_data
);
1518 event
.SetItem( item
);
1519 dv
->HandleWindowEvent( event
);
1521 if (GTK_IS_CELL_EDITABLE(editable
))
1523 s_user_data
= iter
.user_data
;
1525 g_signal_connect (GTK_CELL_EDITABLE (editable
), "editing_done",
1526 G_CALLBACK (wxgtk_cell_editable_editing_done
),
1527 (gpointer
) wxrenderer
);
1533 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer
, wxDataViewRendererBase
)
1535 wxDataViewRenderer::wxDataViewRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
1537 wxDataViewRendererBase( varianttype
, mode
, align
)
1541 // we haven't changed them yet
1542 m_usingDefaultAttrs
= true;
1544 // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
1545 // after the m_renderer pointer has been initialized
1548 void wxDataViewRenderer::GtkPackIntoColumn(GtkTreeViewColumn
*column
)
1550 gtk_tree_view_column_pack_end( column
, m_renderer
, TRUE
/* expand */);
1553 void wxDataViewRenderer::GtkInitHandlers()
1555 if (!gtk_check_version(2,6,0))
1557 g_signal_connect (GTK_CELL_RENDERER(m_renderer
), "editing_started",
1558 G_CALLBACK (wxgtk_renderer_editing_started
),
1563 void wxDataViewRenderer::SetMode( wxDataViewCellMode mode
)
1565 GtkCellRendererMode gtkMode
;
1568 case wxDATAVIEW_CELL_INERT
:
1569 gtkMode
= GTK_CELL_RENDERER_MODE_INERT
;
1572 case wxDATAVIEW_CELL_ACTIVATABLE
:
1573 gtkMode
= GTK_CELL_RENDERER_MODE_ACTIVATABLE
;
1576 case wxDATAVIEW_CELL_EDITABLE
:
1577 gtkMode
= GTK_CELL_RENDERER_MODE_EDITABLE
;
1581 wxFAIL_MSG( "unknown wxDataViewCellMode value" );
1585 // This value is most often ignored in GtkTreeView
1586 GValue gvalue
= { 0, };
1587 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
1588 g_value_set_enum( &gvalue
, gtkMode
);
1589 g_object_set_property( G_OBJECT(m_renderer
), "mode", &gvalue
);
1590 g_value_unset( &gvalue
);
1593 wxDataViewCellMode
wxDataViewRenderer::GetMode() const
1595 wxDataViewCellMode ret
;
1598 g_object_get( G_OBJECT(m_renderer
), "mode", &gvalue
, NULL
);
1600 switch (g_value_get_enum(&gvalue
))
1603 wxFAIL_MSG( "unknown GtkCellRendererMode value" );
1604 // fall through (we have to return something)
1606 case GTK_CELL_RENDERER_MODE_INERT
:
1607 ret
= wxDATAVIEW_CELL_INERT
;
1610 case GTK_CELL_RENDERER_MODE_ACTIVATABLE
:
1611 ret
= wxDATAVIEW_CELL_ACTIVATABLE
;
1614 case GTK_CELL_RENDERER_MODE_EDITABLE
:
1615 ret
= wxDATAVIEW_CELL_EDITABLE
;
1619 g_value_unset( &gvalue
);
1624 void wxDataViewRenderer::GtkUpdateAlignment()
1626 int align
= m_alignment
;
1628 // query alignment from column ?
1632 if (GetOwner() == NULL
)
1635 align
= GetOwner()->GetAlignment();
1636 align
|= wxALIGN_CENTRE_VERTICAL
;
1639 // horizontal alignment:
1641 gfloat xalign
= 0.0;
1642 if (align
& wxALIGN_RIGHT
)
1644 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
1647 GValue gvalue
= { 0, };
1648 g_value_init( &gvalue
, G_TYPE_FLOAT
);
1649 g_value_set_float( &gvalue
, xalign
);
1650 g_object_set_property( G_OBJECT(m_renderer
), "xalign", &gvalue
);
1651 g_value_unset( &gvalue
);
1653 // vertical alignment:
1655 gfloat yalign
= 0.0;
1656 if (align
& wxALIGN_BOTTOM
)
1658 else if (align
& wxALIGN_CENTER_VERTICAL
)
1661 GValue gvalue2
= { 0, };
1662 g_value_init( &gvalue2
, G_TYPE_FLOAT
);
1663 g_value_set_float( &gvalue2
, yalign
);
1664 g_object_set_property( G_OBJECT(m_renderer
), "yalign", &gvalue2
);
1665 g_value_unset( &gvalue2
);
1668 void wxDataViewRenderer::SetAlignment( int align
)
1670 m_alignment
= align
;
1671 GtkUpdateAlignment();
1674 int wxDataViewRenderer::GetAlignment() const
1679 void wxDataViewRenderer::EnableEllipsize(wxEllipsizeMode mode
)
1681 if ( gtk_check_version(2, 6, 0) != NULL
)
1684 // we use the same values in wxEllipsizeMode as PangoEllipsizeMode so we
1685 // can just cast between them
1686 GValue gvalue
= { 0, };
1687 g_value_init( &gvalue
, PANGO_TYPE_ELLIPSIZE_MODE
);
1688 g_value_set_enum( &gvalue
, static_cast<PangoEllipsizeMode
>(mode
) );
1689 g_object_set_property( G_OBJECT(m_renderer
), "ellipsize", &gvalue
);
1690 g_value_unset( &gvalue
);
1693 wxEllipsizeMode
wxDataViewRenderer::GetEllipsizeMode() const
1695 if ( gtk_check_version(2, 6, 0) != NULL
)
1696 return wxELLIPSIZE_NONE
;
1698 GValue gvalue
= { 0, };
1699 g_value_init( &gvalue
, PANGO_TYPE_ELLIPSIZE_MODE
);
1700 g_object_get_property( G_OBJECT(m_renderer
), "ellipsize", &gvalue
);
1702 mode
= static_cast<wxEllipsizeMode
>(g_value_get_enum( &gvalue
));
1703 g_value_unset( &gvalue
);
1709 wxDataViewRenderer::GtkOnTextEdited(const gchar
*itempath
, const wxString
& str
)
1711 wxVariant
value(str
);
1712 if (!Validate( value
))
1715 GtkTreePath
*path
= gtk_tree_path_new_from_string( itempath
);
1717 GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, path
);
1718 wxDataViewItem
item( (void*) iter
.user_data
);;
1719 gtk_tree_path_free( path
);
1721 GtkOnCellChanged(value
, item
, GetOwner()->GetModelColumn());
1725 wxDataViewRenderer::GtkOnCellChanged(const wxVariant
& value
,
1726 const wxDataViewItem
& item
,
1729 wxDataViewModel
*model
= GetOwner()->GetOwner()->GetModel();
1730 model
->ChangeValue( value
, item
, col
);
1733 // ---------------------------------------------------------
1734 // wxDataViewTextRenderer
1735 // ---------------------------------------------------------
1740 static void wxGtkTextRendererEditedCallback( GtkCellRendererText
*WXUNUSED(renderer
),
1741 gchar
*arg1
, gchar
*arg2
, gpointer user_data
)
1743 wxDataViewRenderer
*cell
= (wxDataViewRenderer
*) user_data
;
1745 cell
->GtkOnTextEdited(arg1
, wxGTK_CONV_BACK_FONT(
1746 arg2
, cell
->GetOwner()->GetOwner()->GetFont()));
1754 // helper function used by wxDataViewTextRenderer and
1755 // wxDataViewCustomRenderer::RenderText(): it applies the attributes to the
1756 // given text renderer and returns true if anything was done
1757 bool GtkApplyAttr(GtkCellRendererText
*renderer
, const wxDataViewItemAttr
& attr
)
1759 bool usingDefaultAttrs
= true;
1760 if (attr
.HasColour())
1762 const GdkColor
* const gcol
= attr
.GetColour().GetColor();
1764 GValue gvalue
= { 0, };
1765 g_value_init( &gvalue
, GDK_TYPE_COLOR
);
1766 g_value_set_boxed( &gvalue
, gcol
);
1767 g_object_set_property( G_OBJECT(renderer
), "foreground_gdk", &gvalue
);
1768 g_value_unset( &gvalue
);
1770 usingDefaultAttrs
= false;
1774 GValue gvalue
= { 0, };
1775 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1776 g_value_set_boolean( &gvalue
, FALSE
);
1777 g_object_set_property( G_OBJECT(renderer
), "foreground-set", &gvalue
);
1778 g_value_unset( &gvalue
);
1781 if (attr
.GetItalic())
1783 GValue gvalue
= { 0, };
1784 g_value_init( &gvalue
, PANGO_TYPE_STYLE
);
1785 g_value_set_enum( &gvalue
, PANGO_STYLE_ITALIC
);
1786 g_object_set_property( G_OBJECT(renderer
), "style", &gvalue
);
1787 g_value_unset( &gvalue
);
1789 usingDefaultAttrs
= false;
1793 GValue gvalue
= { 0, };
1794 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1795 g_value_set_boolean( &gvalue
, FALSE
);
1796 g_object_set_property( G_OBJECT(renderer
), "style-set", &gvalue
);
1797 g_value_unset( &gvalue
);
1803 GValue gvalue
= { 0, };
1804 g_value_init( &gvalue
, PANGO_TYPE_WEIGHT
);
1805 g_value_set_enum( &gvalue
, PANGO_WEIGHT_BOLD
);
1806 g_object_set_property( G_OBJECT(renderer
), "weight", &gvalue
);
1807 g_value_unset( &gvalue
);
1809 usingDefaultAttrs
= false;
1813 GValue gvalue
= { 0, };
1814 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1815 g_value_set_boolean( &gvalue
, FALSE
);
1816 g_object_set_property( G_OBJECT(renderer
), "weight-set", &gvalue
);
1817 g_value_unset( &gvalue
);
1821 if (attr
.HasBackgroundColour())
1823 wxColour colour
= attr
.GetBackgroundColour();
1824 const GdkColor
* const gcol
= colour
.GetColor();
1826 GValue gvalue
= { 0, };
1827 g_value_init( &gvalue
, GDK_TYPE_COLOR
);
1828 g_value_set_boxed( &gvalue
, gcol
);
1829 g_object_set_property( G_OBJECT(renderer
), "cell-background_gdk", &gvalue
);
1830 g_value_unset( &gvalue
);
1834 GValue gvalue
= { 0, };
1835 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1836 g_value_set_boolean( &gvalue
, FALSE
);
1837 g_object_set_property( G_OBJECT(renderer
), "cell-background-set", &gvalue
);
1838 g_value_unset( &gvalue
);
1842 return !usingDefaultAttrs
;
1845 } // anonymous namespace
1847 IMPLEMENT_CLASS(wxDataViewTextRenderer
, wxDataViewRenderer
)
1849 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
1851 wxDataViewRenderer( varianttype
, mode
, align
)
1853 GtkWxCellRendererText
*text_renderer
= gtk_wx_cell_renderer_text_new();
1854 text_renderer
->wx_renderer
= this;
1855 m_renderer
= (GtkCellRenderer
*) text_renderer
;
1857 if (mode
& wxDATAVIEW_CELL_EDITABLE
)
1859 GValue gvalue
= { 0, };
1860 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1861 g_value_set_boolean( &gvalue
, true );
1862 g_object_set_property( G_OBJECT(m_renderer
), "editable", &gvalue
);
1863 g_value_unset( &gvalue
);
1865 g_signal_connect_after( m_renderer
, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback
), this );
1871 SetAlignment(align
);
1874 bool wxDataViewTextRenderer::SetTextValue(const wxString
& str
)
1876 GValue gvalue
= { 0, };
1877 g_value_init( &gvalue
, G_TYPE_STRING
);
1878 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( str
, GetOwner()->GetOwner()->GetFont() ) );
1879 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
1880 g_value_unset( &gvalue
);
1885 bool wxDataViewTextRenderer::GetTextValue(wxString
& str
) const
1887 GValue gvalue
= { 0, };
1888 g_value_init( &gvalue
, G_TYPE_STRING
);
1889 g_object_get_property( G_OBJECT(m_renderer
), "text", &gvalue
);
1890 str
= wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue
), const_cast<wxDataViewTextRenderer
*>(this)->GetOwner()->GetOwner()->GetFont() );
1891 g_value_unset( &gvalue
);
1896 void wxDataViewTextRenderer::SetAlignment( int align
)
1898 wxDataViewRenderer::SetAlignment(align
);
1900 if (gtk_check_version(2,10,0))
1903 // horizontal alignment:
1904 PangoAlignment pangoAlign
= PANGO_ALIGN_LEFT
;
1905 if (align
& wxALIGN_RIGHT
)
1906 pangoAlign
= PANGO_ALIGN_RIGHT
;
1907 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
1908 pangoAlign
= PANGO_ALIGN_CENTER
;
1910 GValue gvalue
= { 0, };
1911 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
1912 g_value_set_enum( &gvalue
, pangoAlign
);
1913 g_object_set_property( G_OBJECT(m_renderer
), "alignment", &gvalue
);
1914 g_value_unset( &gvalue
);
1917 bool wxDataViewTextRenderer::GtkSetAttr(const wxDataViewItemAttr
& attr
)
1919 return GtkApplyAttr(GTK_CELL_RENDERER_TEXT(m_renderer
), attr
);
1922 // ---------------------------------------------------------
1923 // wxDataViewBitmapRenderer
1924 // ---------------------------------------------------------
1929 // set "pixbuf" property on the given renderer
1930 void SetPixbufProp(GtkCellRenderer
*renderer
, GdkPixbuf
*pixbuf
)
1932 GValue gvalue
= { 0, };
1933 g_value_init( &gvalue
, G_TYPE_OBJECT
);
1934 g_value_set_object( &gvalue
, pixbuf
);
1935 g_object_set_property( G_OBJECT(renderer
), "pixbuf", &gvalue
);
1936 g_value_unset( &gvalue
);
1939 } // anonymous namespace
1941 IMPLEMENT_CLASS(wxDataViewBitmapRenderer
, wxDataViewRenderer
)
1943 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
1945 wxDataViewRenderer( varianttype
, mode
, align
)
1947 m_renderer
= gtk_cell_renderer_pixbuf_new();
1950 SetAlignment(align
);
1953 bool wxDataViewBitmapRenderer::SetValue( const wxVariant
&value
)
1955 if (value
.GetType() == wxT("wxBitmap"))
1960 // GetPixbuf() may create a Pixbuf representation in the wxBitmap
1961 // object (and it will stay there and remain owned by wxBitmap)
1962 SetPixbufProp(m_renderer
, bitmap
.GetPixbuf());
1964 else if (value
.GetType() == wxT("wxIcon"))
1969 SetPixbufProp(m_renderer
, icon
.GetPixbuf());
1979 bool wxDataViewBitmapRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
1984 // ---------------------------------------------------------
1985 // wxDataViewToggleRenderer
1986 // ---------------------------------------------------------
1989 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle
*renderer
,
1990 gchar
*path
, gpointer user_data
);
1993 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle
*renderer
,
1994 gchar
*path
, gpointer user_data
)
1996 wxDataViewToggleRenderer
*cell
= (wxDataViewToggleRenderer
*) user_data
;
1999 GValue gvalue
= { 0, };
2000 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2001 g_object_get_property( G_OBJECT(renderer
), "active", &gvalue
);
2002 bool tmp
= g_value_get_boolean( &gvalue
);
2003 g_value_unset( &gvalue
);
2007 wxVariant value
= tmp
;
2008 if (!cell
->Validate( value
))
2011 wxDataViewModel
*model
= cell
->GetOwner()->GetOwner()->GetModel();
2013 GtkTreePath
*gtk_path
= gtk_tree_path_new_from_string( path
);
2015 cell
->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, gtk_path
);
2016 wxDataViewItem
item( (void*) iter
.user_data
);;
2017 gtk_tree_path_free( gtk_path
);
2019 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
2021 model
->ChangeValue( value
, item
, model_col
);
2024 IMPLEMENT_CLASS(wxDataViewToggleRenderer
, wxDataViewRenderer
)
2026 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString
&varianttype
,
2027 wxDataViewCellMode mode
, int align
) :
2028 wxDataViewRenderer( varianttype
, mode
, align
)
2030 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_toggle_new();
2032 if (mode
& wxDATAVIEW_CELL_ACTIVATABLE
)
2034 g_signal_connect_after( m_renderer
, "toggled",
2035 G_CALLBACK(wxGtkToggleRendererToggledCallback
), this );
2039 GValue gvalue
= { 0, };
2040 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2041 g_value_set_boolean( &gvalue
, false );
2042 g_object_set_property( G_OBJECT(m_renderer
), "activatable", &gvalue
);
2043 g_value_unset( &gvalue
);
2047 SetAlignment(align
);
2050 bool wxDataViewToggleRenderer::SetValue( const wxVariant
&value
)
2054 GValue gvalue
= { 0, };
2055 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2056 g_value_set_boolean( &gvalue
, tmp
);
2057 g_object_set_property( G_OBJECT(m_renderer
), "active", &gvalue
);
2058 g_value_unset( &gvalue
);
2063 bool wxDataViewToggleRenderer::GetValue( wxVariant
&value
) const
2065 GValue gvalue
= { 0, };
2066 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2067 g_object_get_property( G_OBJECT(m_renderer
), "active", &gvalue
);
2068 bool tmp
= g_value_get_boolean( &gvalue
);
2069 g_value_unset( &gvalue
);
2076 // ---------------------------------------------------------
2077 // wxDataViewCustomRenderer
2078 // ---------------------------------------------------------
2080 class wxDataViewCtrlDCImpl
: public wxWindowDCImpl
2083 wxDataViewCtrlDCImpl( wxDC
*owner
, wxDataViewCtrl
*window
) :
2084 wxWindowDCImpl( owner
)
2086 GtkWidget
*widget
= window
->m_treeview
;
2092 m_context
= window
->GTKGetPangoDefaultContext();
2093 m_layout
= pango_layout_new( m_context
);
2094 m_fontdesc
= pango_font_description_copy( widget
->style
->font_desc
);
2096 m_cmap
= gtk_widget_get_colormap( widget
? widget
: window
->m_widget
);
2098 // Set m_gdkwindow later
2103 class wxDataViewCtrlDC
: public wxWindowDC
2106 wxDataViewCtrlDC( wxDataViewCtrl
*window
) :
2107 wxWindowDC( new wxDataViewCtrlDCImpl( this, window
) )
2112 // ---------------------------------------------------------
2113 // wxDataViewCustomRenderer
2114 // ---------------------------------------------------------
2116 IMPLEMENT_CLASS(wxDataViewCustomRenderer
, wxDataViewRenderer
)
2118 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString
&varianttype
,
2119 wxDataViewCellMode mode
,
2122 : wxDataViewCustomRendererBase( varianttype
, mode
, align
)
2125 m_text_renderer
= NULL
;
2133 void wxDataViewCustomRenderer::RenderText( const wxString
&text
,
2137 int WXUNUSED(state
) )
2139 if (!m_text_renderer
)
2140 m_text_renderer
= GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
2142 GValue gvalue
= { 0, };
2143 g_value_init( &gvalue
, G_TYPE_STRING
);
2144 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( text
, GetOwner()->GetOwner()->GetFont() ) );
2145 g_object_set_property( G_OBJECT(m_text_renderer
), "text", &gvalue
);
2146 g_value_unset( &gvalue
);
2148 GtkApplyAttr(m_text_renderer
, GetAttr());
2150 GdkRectangle cell_area
;
2151 wxRectToGDKRect(cell
, cell_area
);
2152 cell_area
.x
+= xoffset
;
2153 cell_area
.width
-= xoffset
;
2155 gtk_cell_renderer_render( GTK_CELL_RENDERER(m_text_renderer
),
2156 m_renderParams
.window
,
2157 m_renderParams
.widget
,
2158 m_renderParams
.background_area
,
2160 m_renderParams
.expose_area
,
2161 (GtkCellRendererState
) m_renderParams
.flags
);
2164 bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode
, int align
)
2166 GtkWxCellRenderer
*renderer
= (GtkWxCellRenderer
*) gtk_wx_cell_renderer_new();
2167 renderer
->cell
= this;
2169 m_renderer
= (GtkCellRenderer
*) renderer
;
2172 SetAlignment(align
);
2179 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
2184 if (m_text_renderer
)
2185 gtk_object_sink( GTK_OBJECT(m_text_renderer
) );
2188 wxDC
*wxDataViewCustomRenderer::GetDC()
2192 if (GetOwner() == NULL
)
2194 if (GetOwner()->GetOwner() == NULL
)
2196 m_dc
= new wxDataViewCtrlDC( GetOwner()->GetOwner() );
2202 // ---------------------------------------------------------
2203 // wxDataViewProgressRenderer
2204 // ---------------------------------------------------------
2206 IMPLEMENT_CLASS(wxDataViewProgressRenderer
, wxDataViewCustomRenderer
)
2208 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString
&label
,
2209 const wxString
&varianttype
, wxDataViewCellMode mode
, int align
) :
2210 wxDataViewCustomRenderer( varianttype
, mode
, align
, true )
2216 if (!gtk_check_version(2,6,0))
2218 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_progress_new();
2220 GValue gvalue
= { 0, };
2221 g_value_init( &gvalue
, G_TYPE_STRING
);
2223 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( m_label
, GetOwner()->GetOwner()->GetFont() ) );
2224 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2225 g_value_unset( &gvalue
);
2228 SetAlignment(align
);
2233 // Use custom cell code
2234 wxDataViewCustomRenderer::Init(mode
, align
);
2238 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
2242 bool wxDataViewProgressRenderer::SetValue( const wxVariant
&value
)
2245 if (!gtk_check_version(2,6,0))
2247 gint tmp
= (long) value
;
2248 GValue gvalue
= { 0, };
2249 g_value_init( &gvalue
, G_TYPE_INT
);
2250 g_value_set_int( &gvalue
, tmp
);
2251 g_object_set_property( G_OBJECT(m_renderer
), "value", &gvalue
);
2252 g_value_unset( &gvalue
);
2257 m_value
= (long) value
;
2259 if (m_value
< 0) m_value
= 0;
2260 if (m_value
> 100) m_value
= 100;
2266 bool wxDataViewProgressRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
2271 bool wxDataViewProgressRenderer::Render( wxRect cell
, wxDC
*dc
, int WXUNUSED(state
) )
2273 double pct
= (double)m_value
/ 100.0;
2275 bar
.width
= (int)(cell
.width
* pct
);
2276 dc
->SetPen( *wxTRANSPARENT_PEN
);
2277 dc
->SetBrush( *wxBLUE_BRUSH
);
2278 dc
->DrawRectangle( bar
);
2280 dc
->SetBrush( *wxTRANSPARENT_BRUSH
);
2281 dc
->SetPen( *wxBLACK_PEN
);
2282 dc
->DrawRectangle( cell
);
2287 wxSize
wxDataViewProgressRenderer::GetSize() const
2289 return wxSize(40,12);
2292 // -------------------------------------
2293 // wxDataViewChoiceRenderer
2294 // -------------------------------------
2296 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString
&choices
,
2297 wxDataViewCellMode mode
, int alignment
) :
2298 wxDataViewCustomRenderer( "string", mode
, alignment
, true )
2300 m_choices
= choices
;
2303 if (!gtk_check_version(2,6,0))
2305 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_combo_new();
2307 GtkListStore
*store
= gtk_list_store_new( 1, G_TYPE_STRING
);
2308 for (size_t n
= 0; n
< m_choices
.GetCount(); n
++)
2310 gtk_list_store_insert_with_values(
2312 static_cast<const char *>(m_choices
[n
].utf8_str()), -1 );
2315 g_object_set (m_renderer
,
2321 bool editable
= (mode
& wxDATAVIEW_CELL_EDITABLE
);
2322 g_object_set (m_renderer
, "editable", editable
, NULL
);
2324 SetAlignment(alignment
);
2326 g_signal_connect_after( m_renderer
, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback
), this );
2333 // Use custom cell code
2334 wxDataViewCustomRenderer::Init(mode
, alignment
);
2338 bool wxDataViewChoiceRenderer::Render( wxRect rect
, wxDC
*dc
, int state
)
2340 RenderText( m_data
, 0, rect
, dc
, state
);
2344 wxSize
wxDataViewChoiceRenderer::GetSize() const
2346 return wxSize(70,20);
2349 bool wxDataViewChoiceRenderer::SetValue( const wxVariant
&value
)
2353 if (!gtk_check_version(2,6,0))
2355 GValue gvalue
= { 0, };
2356 g_value_init( &gvalue
, G_TYPE_STRING
);
2357 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( value
.GetString(), GetOwner()->GetOwner()->GetFont() ) );
2358 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2359 g_value_unset( &gvalue
);
2363 m_data
= value
.GetString();
2368 bool wxDataViewChoiceRenderer::GetValue( wxVariant
&value
) const
2371 if (!gtk_check_version(2,6,0))
2373 GValue gvalue
= { 0, };
2374 g_value_init( &gvalue
, G_TYPE_STRING
);
2375 g_object_get_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2376 wxString temp
= wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue
),
2377 const_cast<wxDataViewChoiceRenderer
*>(this)->GetOwner()->GetOwner()->GetFont() );
2378 g_value_unset( &gvalue
);
2381 //wxPrintf( "temp %s\n", temp );
2382 // TODO: remove this code
2391 void wxDataViewChoiceRenderer::SetAlignment( int align
)
2393 wxDataViewCustomRenderer::SetAlignment(align
);
2395 if (gtk_check_version(2,10,0))
2398 // horizontal alignment:
2399 PangoAlignment pangoAlign
= PANGO_ALIGN_LEFT
;
2400 if (align
& wxALIGN_RIGHT
)
2401 pangoAlign
= PANGO_ALIGN_RIGHT
;
2402 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
2403 pangoAlign
= PANGO_ALIGN_CENTER
;
2405 GValue gvalue
= { 0, };
2406 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
2407 g_value_set_enum( &gvalue
, pangoAlign
);
2408 g_object_set_property( G_OBJECT(m_renderer
), "alignment", &gvalue
);
2409 g_value_unset( &gvalue
);
2412 // ---------------------------------------------------------
2413 // wxDataViewDateRenderer
2414 // ---------------------------------------------------------
2416 class wxDataViewDateRendererPopupTransient
: public wxPopupTransientWindow
2419 wxDataViewDateRendererPopupTransient( wxWindow
* parent
, wxDateTime
*value
,
2420 wxDataViewModel
*model
, const wxDataViewItem
&item
, unsigned int col
) :
2421 wxPopupTransientWindow( parent
, wxBORDER_SIMPLE
)
2426 m_cal
= new wxCalendarCtrl( this, -1, *value
);
2427 wxBoxSizer
*sizer
= new wxBoxSizer( wxHORIZONTAL
);
2428 sizer
->Add( m_cal
, 1, wxGROW
);
2433 virtual void OnDismiss()
2437 void OnCalendar( wxCalendarEvent
&event
);
2439 wxCalendarCtrl
*m_cal
;
2440 wxDataViewModel
*m_model
;
2441 wxDataViewItem m_item
;
2445 DECLARE_EVENT_TABLE()
2448 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient
,wxPopupTransientWindow
)
2449 EVT_CALENDAR( -1, wxDataViewDateRendererPopupTransient::OnCalendar
)
2452 void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent
&event
)
2454 m_model
->ChangeValue( event
.GetDate(), m_item
, m_col
);
2458 IMPLEMENT_CLASS(wxDataViewDateRenderer
, wxDataViewCustomRenderer
)
2460 wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString
&varianttype
,
2461 wxDataViewCellMode mode
, int align
) :
2462 wxDataViewCustomRenderer( varianttype
, mode
, align
)
2465 SetAlignment(align
);
2468 bool wxDataViewDateRenderer::SetValue( const wxVariant
&value
)
2470 m_date
= value
.GetDateTime();
2475 bool wxDataViewDateRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
2480 bool wxDataViewDateRenderer::Render( wxRect cell
, wxDC
*dc
, int state
)
2482 dc
->SetFont( GetOwner()->GetOwner()->GetFont() );
2483 wxString tmp
= m_date
.FormatDate();
2484 RenderText( tmp
, 0, cell
, dc
, state
);
2488 wxSize
wxDataViewDateRenderer::GetSize() const
2490 wxString tmp
= m_date
.FormatDate();
2492 GetView()->GetTextExtent( tmp
, &x
, &y
, &d
);
2493 return wxSize(x
,y
+d
);
2496 bool wxDataViewDateRenderer::Activate( wxRect
WXUNUSED(cell
), wxDataViewModel
*model
,
2497 const wxDataViewItem
&item
, unsigned int col
)
2500 model
->GetValue( variant
, item
, col
);
2501 wxDateTime value
= variant
.GetDateTime();
2503 wxDataViewDateRendererPopupTransient
*popup
= new wxDataViewDateRendererPopupTransient(
2504 GetOwner()->GetOwner()->GetParent(), &value
, model
, item
, col
);
2505 wxPoint pos
= wxGetMousePosition();
2508 popup
->Popup( popup
->m_cal
);
2514 // ---------------------------------------------------------
2515 // wxDataViewIconTextRenderer
2516 // ---------------------------------------------------------
2518 IMPLEMENT_CLASS(wxDataViewIconTextRenderer
, wxDataViewCustomRenderer
)
2520 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer
2522 const wxString
&varianttype
,
2523 wxDataViewCellMode mode
,
2526 : wxDataViewTextRenderer(varianttype
, mode
, align
)
2528 m_rendererIcon
= gtk_cell_renderer_pixbuf_new();
2531 wxDataViewIconTextRenderer::~wxDataViewIconTextRenderer()
2535 void wxDataViewIconTextRenderer::GtkPackIntoColumn(GtkTreeViewColumn
*column
)
2537 // add the icon renderer first
2538 gtk_tree_view_column_pack_start(column
, m_rendererIcon
, FALSE
/* !expand */);
2540 // add the text renderer too
2541 wxDataViewRenderer::GtkPackIntoColumn(column
);
2544 bool wxDataViewIconTextRenderer::SetValue( const wxVariant
&value
)
2548 SetTextValue(m_value
.GetText());
2549 SetPixbufProp(m_rendererIcon
, m_value
.GetIcon().GetPixbuf());
2554 bool wxDataViewIconTextRenderer::GetValue(wxVariant
& value
) const
2557 if ( !GetTextValue(str
) )
2560 // user doesn't have any way to edit the icon so leave it unchanged
2561 value
<< wxDataViewIconText(str
, m_value
.GetIcon());
2567 wxDataViewIconTextRenderer::GtkOnCellChanged(const wxVariant
& value
,
2568 const wxDataViewItem
& item
,
2571 // we receive just the text part of our value as it's the only one which
2572 // can be edited, but we need the full wxDataViewIconText value for the
2574 wxVariant valueIconText
;
2575 valueIconText
<< wxDataViewIconText(value
.GetString(), m_value
.GetIcon());
2576 wxDataViewTextRenderer::GtkOnCellChanged(valueIconText
, item
, col
);
2579 // ---------------------------------------------------------
2581 // ---------------------------------------------------------
2585 gtk_dataview_header_button_press_callback( GtkWidget
*WXUNUSED(widget
),
2586 GdkEventButton
*gdk_event
,
2587 wxDataViewColumn
*column
)
2589 if (gdk_event
->type
!= GDK_BUTTON_PRESS
)
2592 if (gdk_event
->button
== 1)
2594 gs_lastLeftClickHeader
= column
;
2596 wxDataViewCtrl
*dv
= column
->GetOwner();
2597 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK
, dv
->GetId() );
2598 event
.SetDataViewColumn( column
);
2599 event
.SetModel( dv
->GetModel() );
2600 if (dv
->HandleWindowEvent( event
))
2604 if (gdk_event
->button
== 3)
2606 wxDataViewCtrl
*dv
= column
->GetOwner();
2607 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK
, dv
->GetId() );
2608 event
.SetDataViewColumn( column
);
2609 event
.SetModel( dv
->GetModel() );
2610 if (dv
->HandleWindowEvent( event
))
2620 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn
*WXUNUSED(column
),
2621 GtkCellRenderer
*renderer
,
2622 GtkTreeModel
*model
,
2626 g_return_if_fail (GTK_IS_WX_TREE_MODEL (model
));
2627 GtkWxTreeModel
*tree_model
= (GtkWxTreeModel
*) model
;
2629 wxDataViewRenderer
*cell
= (wxDataViewRenderer
*) data
;
2631 wxDataViewItem
item( (void*) iter
->user_data
);
2633 wxDataViewModel
*wx_model
= tree_model
->internal
->GetDataViewModel();
2635 if (!wx_model
->IsVirtualListModel())
2638 if (wx_model
->IsContainer( item
))
2640 visible
= wx_model
->HasContainerColumns( item
) ||
2641 (cell
->GetOwner()->GetModelColumn() == 0);
2648 GValue gvalue
= { 0, };
2649 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2650 g_value_set_boolean( &gvalue
, visible
);
2651 g_object_set_property( G_OBJECT(renderer
), "visible", &gvalue
);
2652 g_value_unset( &gvalue
);
2659 wx_model
->GetValue( value
, item
, cell
->GetOwner()->GetModelColumn() );
2661 if (value
.GetType() != cell
->GetVariantType())
2663 wxLogError( wxT("Wrong type, required: %s but: %s"),
2664 value
.GetType().c_str(),
2665 cell
->GetVariantType().c_str() );
2668 cell
->SetValue( value
);
2671 // deal with attributes: if the renderer doesn't support them at all, we
2672 // don't even need to query the model for them
2673 if ( !cell
->GtkSupportsAttrs() )
2676 // it can support attributes so check if this item has any
2677 wxDataViewItemAttr attr
;
2678 if ( wx_model
->GetAttr( item
, cell
->GetOwner()->GetModelColumn(), attr
)
2679 || !cell
->GtkIsUsingDefaultAttrs() )
2681 bool usingDefaultAttrs
= !cell
->GtkSetAttr(attr
);
2682 cell
->GtkSetUsingDefaultAttrs(usingDefaultAttrs
);
2684 // else: no custom attributes specified and we're already using the default
2685 // ones -- nothing to do
2690 #include <wx/listimpl.cpp>
2691 WX_DEFINE_LIST(wxDataViewColumnList
)
2693 wxDataViewColumn::wxDataViewColumn( const wxString
&title
, wxDataViewRenderer
*cell
,
2694 unsigned int model_column
, int width
,
2695 wxAlignment align
, int flags
)
2696 : wxDataViewColumnBase( cell
, model_column
)
2698 Init( align
, flags
, width
);
2703 wxDataViewColumn::wxDataViewColumn( const wxBitmap
&bitmap
, wxDataViewRenderer
*cell
,
2704 unsigned int model_column
, int width
,
2705 wxAlignment align
, int flags
)
2706 : wxDataViewColumnBase( bitmap
, cell
, model_column
)
2708 Init( align
, flags
, width
);
2710 SetBitmap( bitmap
);
2713 void wxDataViewColumn::Init(wxAlignment align
, int flags
, int width
)
2715 m_isConnected
= false;
2717 GtkTreeViewColumn
*column
= gtk_tree_view_column_new();
2718 m_column
= (GtkWidget
*) column
;
2721 SetAlignment( align
);
2725 // Create container for icon and label
2726 GtkWidget
*box
= gtk_hbox_new( FALSE
, 1 );
2727 gtk_widget_show( box
);
2728 // gtk_container_set_border_width((GtkContainer*)box, 2);
2729 m_image
= gtk_image_new();
2730 gtk_box_pack_start(GTK_BOX(box
), m_image
, FALSE
, FALSE
, 1);
2731 m_label
= gtk_label_new("");
2732 gtk_box_pack_end( GTK_BOX(box
), GTK_WIDGET(m_label
), FALSE
, FALSE
, 1 );
2733 gtk_tree_view_column_set_widget( column
, box
);
2735 wxDataViewRenderer
* const colRenderer
= GetRenderer();
2736 GtkCellRenderer
* const cellRenderer
= colRenderer
->GetGtkHandle();
2738 colRenderer
->GtkPackIntoColumn(column
);
2740 gtk_tree_view_column_set_cell_data_func( column
, cellRenderer
,
2741 wxGtkTreeCellDataFunc
, (gpointer
) colRenderer
, NULL
);
2744 void wxDataViewColumn::OnInternalIdle()
2749 if (GTK_WIDGET_REALIZED(GetOwner()->m_treeview
))
2751 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2754 g_signal_connect(column
->button
, "button_press_event",
2755 G_CALLBACK (gtk_dataview_header_button_press_callback
), this);
2757 m_isConnected
= true;
2762 void wxDataViewColumn::SetOwner( wxDataViewCtrl
*owner
)
2764 wxDataViewColumnBase::SetOwner( owner
);
2766 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2768 gtk_tree_view_column_set_title( column
, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
2771 void wxDataViewColumn::SetTitle( const wxString
&title
)
2773 wxDataViewCtrl
*ctrl
= GetOwner();
2774 gtk_label_set_text( GTK_LABEL(m_label
), ctrl
? wxGTK_CONV_FONT(title
, ctrl
->GetFont())
2775 : wxGTK_CONV_SYS(title
) );
2777 gtk_widget_hide( m_label
);
2779 gtk_widget_show( m_label
);
2782 wxString
wxDataViewColumn::GetTitle() const
2784 return wxGTK_CONV_BACK_FONT(
2785 gtk_label_get_text( GTK_LABEL(m_label
) ),
2786 GetOwner()->GetFont()
2790 void wxDataViewColumn::SetBitmap( const wxBitmap
&bitmap
)
2792 wxDataViewColumnBase::SetBitmap( bitmap
);
2796 GtkImage
*gtk_image
= GTK_IMAGE(m_image
);
2798 GdkBitmap
*mask
= NULL
;
2799 if (bitmap
.GetMask())
2800 mask
= bitmap
.GetMask()->GetBitmap();
2802 if (bitmap
.HasPixbuf())
2804 gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image
),
2805 bitmap
.GetPixbuf());
2809 gtk_image_set_from_pixmap(GTK_IMAGE(gtk_image
),
2810 bitmap
.GetPixmap(), mask
);
2812 gtk_widget_show( m_image
);
2816 gtk_widget_hide( m_image
);
2820 void wxDataViewColumn::SetHidden( bool hidden
)
2822 gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column
), !hidden
);
2825 void wxDataViewColumn::SetResizeable( bool resizeable
)
2827 gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column
), resizeable
);
2830 void wxDataViewColumn::SetAlignment( wxAlignment align
)
2832 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2834 gfloat xalign
= 0.0;
2835 if (align
== wxALIGN_RIGHT
)
2837 if (align
== wxALIGN_CENTER_HORIZONTAL
||
2838 align
== wxALIGN_CENTER
)
2841 gtk_tree_view_column_set_alignment( column
, xalign
);
2843 if (m_renderer
&& m_renderer
->GetAlignment() == -1)
2844 m_renderer
->GtkUpdateAlignment();
2847 wxAlignment
wxDataViewColumn::GetAlignment() const
2849 gfloat xalign
= gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column
) );
2852 return wxALIGN_RIGHT
;
2854 return wxALIGN_CENTER_HORIZONTAL
;
2856 return wxALIGN_LEFT
;
2859 void wxDataViewColumn::SetSortable( bool sortable
)
2861 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2865 gtk_tree_view_column_set_sort_column_id( column
, GetModelColumn() );
2869 gtk_tree_view_column_set_sort_column_id( column
, -1 );
2870 gtk_tree_view_column_set_sort_indicator( column
, FALSE
);
2871 gtk_tree_view_column_set_clickable( column
, FALSE
);
2875 bool wxDataViewColumn::IsSortable() const
2877 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2878 return gtk_tree_view_column_get_clickable( column
);
2881 void wxDataViewColumn::SetAsSortKey( bool WXUNUSED(sort
) )
2883 // it might not make sense to have this function in wxHeaderColumn at
2884 // all in fact, changing of the sort order should only be done using the
2885 // associated control API
2886 wxFAIL_MSG( "not implemented" );
2889 bool wxDataViewColumn::IsSortKey() const
2891 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2892 return gtk_tree_view_column_get_sort_indicator( column
);
2895 bool wxDataViewColumn::IsResizeable() const
2897 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2898 return gtk_tree_view_column_get_resizable( column
);
2901 bool wxDataViewColumn::IsHidden() const
2903 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2904 return !gtk_tree_view_column_get_visible( column
);
2907 void wxDataViewColumn::SetSortOrder( bool ascending
)
2909 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2912 gtk_tree_view_column_set_sort_order( column
, GTK_SORT_ASCENDING
);
2914 gtk_tree_view_column_set_sort_order( column
, GTK_SORT_DESCENDING
);
2916 gtk_tree_view_column_set_sort_indicator( column
, TRUE
);
2919 bool wxDataViewColumn::IsSortOrderAscending() const
2921 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2923 return (gtk_tree_view_column_get_sort_order( column
) != GTK_SORT_DESCENDING
);
2926 void wxDataViewColumn::SetMinWidth( int width
)
2928 gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column
), width
);
2931 int wxDataViewColumn::GetMinWidth() const
2933 return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column
) );
2936 int wxDataViewColumn::GetWidth() const
2938 return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column
) );
2941 void wxDataViewColumn::SetWidth( int width
)
2946 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_FIXED
);
2948 // TODO find a better calculation
2949 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column
), wxDVC_DEFAULT_WIDTH
);
2951 // this is unpractical for large numbers of items and disables
2952 // user resizing, which is totally unexpected
2953 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_AUTOSIZE
);
2958 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_FIXED
);
2960 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column
), width
);
2964 void wxDataViewColumn::SetReorderable( bool reorderable
)
2966 gtk_tree_view_column_set_reorderable( GTK_TREE_VIEW_COLUMN(m_column
), reorderable
);
2969 bool wxDataViewColumn::IsReorderable() const
2971 return gtk_tree_view_column_get_reorderable( GTK_TREE_VIEW_COLUMN(m_column
) );
2974 //-----------------------------------------------------------------------------
2975 // wxGtkTreeModelNode
2976 //-----------------------------------------------------------------------------
2979 class wxGtkTreeModelChildWithPos
2987 int wxGtkTreeModelChildWithPosCmp( const void* data1
, const void* data2
, const void* user_data
)
2989 const wxGtkTreeModelChildWithPos
* child1
= (const wxGtkTreeModelChildWithPos
*) data1
;
2990 const wxGtkTreeModelChildWithPos
* child2
= (const wxGtkTreeModelChildWithPos
*) data2
;
2991 const wxDataViewCtrlInternal
*internal
= (const wxDataViewCtrlInternal
*) user_data
;
2992 int ret
= internal
->GetDataViewModel()->Compare( child1
->id
, child2
->id
,
2993 internal
->GetSortColumn(), (internal
->GetSortOrder() == GTK_SORT_DESCENDING
) );
2999 int LINKAGEMODE
wxGtkTreeModelChildPtrCmp( void*** data1
, void*** data2
)
3001 return gs_internal
->GetDataViewModel()->Compare( **data1
, **data2
,
3002 gs_internal
->GetSortColumn(), (gs_internal
->GetSortOrder() == GTK_SORT_ASCENDING
) );
3005 WX_DEFINE_ARRAY_PTR( void**, wxGtkTreeModelChildrenPtr
);
3008 void wxGtkTreeModelNode::Resort()
3010 size_t child_count
= GetChildCount();
3011 if (child_count
== 0)
3014 size_t node_count
= GetNodesCount();
3016 if (child_count
== 1)
3018 if (node_count
== 1)
3020 wxGtkTreeModelNode
*node
= m_nodes
.Item( 0 );
3026 gint
*new_order
= new gint
[child_count
];
3029 // m_children has the original *void
3030 // ptrs points to these
3031 wxGtkTreeModelChildrenPtr ptrs
;
3033 for (i
= 0; i
< child_count
; i
++)
3034 ptrs
.Add( &(m_children
[i
]) );
3036 gs_internal
= m_internal
;
3037 ptrs
.Sort( &wxGtkTreeModelChildPtrCmp
);
3039 wxGtkTreeModelChildren temp
;
3040 void** base_ptr
= &(m_children
[0]);
3041 // Transfer positions to new_order array and
3043 for (i
= 0; i
< child_count
; i
++)
3045 new_order
[i
] = ptrs
[i
] - base_ptr
;
3046 temp
.Add( *ptrs
[i
] );
3049 // Transfer IDs back to m_children
3051 WX_APPEND_ARRAY( temp
, m_children
);
3056 // Build up array with IDs and original positions
3057 wxGtkTreeModelChildWithPos
* temp
= new wxGtkTreeModelChildWithPos
[child_count
];
3059 for (i
= 0; i
< child_count
; i
++)
3062 temp
[i
].id
= m_children
[i
];
3064 // Sort array keeping original positions
3065 wxQsort( temp
, child_count
, sizeof(wxGtkTreeModelChildWithPos
),
3066 &wxGtkTreeModelChildWithPosCmp
, m_internal
);
3067 // Transfer positions to new_order array and
3068 // IDs to m_children
3070 for (i
= 0; i
< child_count
; i
++)
3072 new_order
[i
] = temp
[i
].pos
;
3073 m_children
.Add( temp
[i
].id
);
3082 wxGtkTreeModelChildren temp
;
3083 WX_APPEND_ARRAY( temp
, m_children
);
3085 gs_internal
= m_internal
;
3086 m_children
.Sort( &wxGtkTreeModelChildCmp
);
3089 for (pos
= 0; pos
< child_count
; pos
++)
3091 void *id
= m_children
.Item( pos
);
3092 int old_pos
= temp
.Index( id
);
3093 new_order
[pos
] = old_pos
;
3097 GtkTreeModel
*gtk_tree_model
= GTK_TREE_MODEL( m_internal
->GetGtkModel() );
3100 iter
.user_data
= GetItem().GetID();
3101 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
3103 GtkTreePath
*path
= m_internal
->get_path( &iter
);
3105 gtk_tree_model_rows_reordered( gtk_tree_model
, path
, &iter
, new_order
);
3107 gtk_tree_path_free (path
);
3109 delete [] new_order
;
3112 for (pos
= 0; pos
< node_count
; pos
++)
3114 wxGtkTreeModelNode
*node
= m_nodes
.Item( pos
);
3119 //-----------------------------------------------------------------------------
3120 // wxDataViewCtrlInternal
3121 //-----------------------------------------------------------------------------
3123 wxDataViewCtrlInternal::wxDataViewCtrlInternal( wxDataViewCtrl
*owner
,
3124 wxDataViewModel
*wx_model
, GtkWxTreeModel
*gtk_model
)
3127 m_wx_model
= wx_model
;
3128 m_gtk_model
= gtk_model
;
3130 m_sort_order
= GTK_SORT_ASCENDING
;
3132 m_dataview_sort_column
= NULL
;
3134 m_dragDataObject
= NULL
;
3135 m_dropDataObject
= NULL
;
3137 if (!m_wx_model
->IsVirtualListModel())
3141 wxDataViewCtrlInternal::~wxDataViewCtrlInternal()
3143 g_object_unref( m_gtk_model
);
3145 delete m_dragDataObject
;
3146 delete m_dropDataObject
;
3149 void wxDataViewCtrlInternal::InitTree()
3151 wxDataViewItem item
;
3152 m_root
= new wxGtkTreeModelNode( NULL
, item
, this );
3154 BuildBranch( m_root
);
3157 void wxDataViewCtrlInternal::BuildBranch( wxGtkTreeModelNode
*node
)
3159 if (node
->GetChildCount() == 0)
3161 wxDataViewItemArray children
;
3162 unsigned int count
= m_wx_model
->GetChildren( node
->GetItem(), children
);
3164 for (pos
= 0; pos
< count
; pos
++)
3166 wxDataViewItem child
= children
[pos
];
3168 if (m_wx_model
->IsContainer( child
))
3169 node
->AddNode( new wxGtkTreeModelNode( node
, child
, this ) );
3171 node
->AddLeave( child
.GetID() );
3173 // Don't send any events here
3180 bool wxDataViewCtrlInternal::EnableDragSource( const wxDataFormat
&format
)
3182 wxGtkString
atom_str( gdk_atom_name( format
) );
3183 m_dragSourceTargetEntryTarget
= wxCharBuffer( atom_str
);
3185 m_dragSourceTargetEntry
.target
= m_dragSourceTargetEntryTarget
.data();
3186 m_dragSourceTargetEntry
.flags
= 0;
3187 m_dragSourceTargetEntry
.info
= static_cast<guint
>(-1);
3189 gtk_tree_view_enable_model_drag_source( GTK_TREE_VIEW(m_owner
->GtkGetTreeView() ),
3190 GDK_BUTTON1_MASK
, &m_dragSourceTargetEntry
, 1, (GdkDragAction
) GDK_ACTION_COPY
);
3195 bool wxDataViewCtrlInternal::EnableDropTarget( const wxDataFormat
&format
)
3197 wxGtkString
atom_str( gdk_atom_name( format
) );
3198 m_dropTargetTargetEntryTarget
= wxCharBuffer( atom_str
);
3200 m_dropTargetTargetEntry
.target
= m_dropTargetTargetEntryTarget
.data();
3201 m_dropTargetTargetEntry
.flags
= 0;
3202 m_dropTargetTargetEntry
.info
= static_cast<guint
>(-1);
3204 gtk_tree_view_enable_model_drag_dest( GTK_TREE_VIEW(m_owner
->GtkGetTreeView() ),
3205 &m_dropTargetTargetEntry
, 1, (GdkDragAction
) GDK_ACTION_COPY
);
3210 gboolean
wxDataViewCtrlInternal::row_draggable( GtkTreeDragSource
*WXUNUSED(drag_source
),
3213 delete m_dragDataObject
;
3216 if (!get_iter( &iter
, path
)) return FALSE
;
3217 wxDataViewItem
item( (void*) iter
.user_data
);
3219 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG
, m_owner
->GetId() );
3220 event
.SetEventObject( m_owner
);
3221 event
.SetItem( item
);
3222 event
.SetModel( m_wx_model
);
3223 if (!m_owner
->HandleWindowEvent( event
))
3226 if (!event
.IsAllowed())
3229 wxDataObject
*obj
= event
.GetDataObject();
3233 m_dragDataObject
= obj
;
3239 wxDataViewCtrlInternal::drag_data_delete(GtkTreeDragSource
*WXUNUSED(drag_source
),
3240 GtkTreePath
*WXUNUSED(path
))
3245 gboolean
wxDataViewCtrlInternal::drag_data_get( GtkTreeDragSource
*WXUNUSED(drag_source
),
3246 GtkTreePath
*path
, GtkSelectionData
*selection_data
)
3249 if (!get_iter( &iter
, path
)) return FALSE
;
3250 wxDataViewItem
item( (void*) iter
.user_data
);
3252 if (!m_dragDataObject
->IsSupported( selection_data
->target
))
3255 size_t size
= m_dragDataObject
->GetDataSize( selection_data
->target
);
3259 void *buf
= malloc( size
);
3261 gboolean res
= FALSE
;
3262 if (m_dragDataObject
->GetDataHere( selection_data
->target
, buf
))
3266 gtk_selection_data_set( selection_data
, selection_data
->target
,
3267 8, (const guchar
*) buf
, size
);
3276 wxDataViewCtrlInternal::drag_data_received(GtkTreeDragDest
*WXUNUSED(drag_dest
),
3278 GtkSelectionData
*selection_data
)
3281 if (!get_iter( &iter
, path
)) return FALSE
;
3282 wxDataViewItem
item( (void*) iter
.user_data
);
3284 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP
, m_owner
->GetId() );
3285 event
.SetEventObject( m_owner
);
3286 event
.SetItem( item
);
3287 event
.SetModel( m_wx_model
);
3288 event
.SetDataFormat( selection_data
->target
);
3289 event
.SetDataSize( selection_data
->length
);
3290 event
.SetDataBuffer( selection_data
->data
);
3291 if (!m_owner
->HandleWindowEvent( event
))
3294 if (!event
.IsAllowed())
3301 wxDataViewCtrlInternal::row_drop_possible(GtkTreeDragDest
*WXUNUSED(drag_dest
),
3303 GtkSelectionData
*selection_data
)
3306 if (!get_iter( &iter
, path
)) return FALSE
;
3307 wxDataViewItem
item( (void*) iter
.user_data
);
3309 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE
, m_owner
->GetId() );
3310 event
.SetEventObject( m_owner
);
3311 event
.SetItem( item
);
3312 event
.SetModel( m_wx_model
);
3313 event
.SetDataFormat( selection_data
->target
);
3314 if (!m_owner
->HandleWindowEvent( event
))
3317 if (!event
.IsAllowed())
3323 // notifications from wxDataViewModel
3325 bool wxDataViewCtrlInternal::Cleared()
3327 GtkWidget
* tree_widget
= GetOwner()->GtkGetTreeView();
3328 gtk_tree_view_set_model( GTK_TREE_VIEW(tree_widget
), NULL
);
3329 gtk_tree_view_set_model( GTK_TREE_VIEW(tree_widget
), GTK_TREE_MODEL(m_gtk_model
) );
3340 void wxDataViewCtrlInternal::Resort()
3342 if (!m_wx_model
->IsVirtualListModel())
3346 bool wxDataViewCtrlInternal::ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3348 if (!m_wx_model
->IsVirtualListModel())
3350 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3351 wxASSERT_MSG(parent_node
,
3352 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3354 if (m_wx_model
->IsContainer( item
))
3355 parent_node
->AddNode( new wxGtkTreeModelNode( parent_node
, item
, this ) );
3357 parent_node
->AddLeave( item
.GetID() );
3363 bool wxDataViewCtrlInternal::ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3365 if (!m_wx_model
->IsVirtualListModel())
3367 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3368 wxASSERT_MSG(parent_node
,
3369 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3371 parent_node
->DeleteChild( item
.GetID() );
3377 bool wxDataViewCtrlInternal::ItemChanged( const wxDataViewItem
&item
)
3379 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, m_owner
->GetId() );
3380 event
.SetEventObject( m_owner
);
3381 event
.SetModel( m_owner
->GetModel() );
3382 event
.SetItem( item
);
3383 m_owner
->HandleWindowEvent( event
);
3388 bool wxDataViewCtrlInternal::ValueChanged( const wxDataViewItem
&item
, unsigned int col
)
3390 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, m_owner
->GetId() );
3391 event
.SetEventObject( m_owner
);
3392 event
.SetModel( m_owner
->GetModel() );
3393 event
.SetColumn( col
);
3394 event
.SetDataViewColumn( GetOwner()->GetColumn(col
) );
3395 event
.SetItem( item
);
3396 m_owner
->HandleWindowEvent( event
);
3403 GtkTreeModelFlags
wxDataViewCtrlInternal::get_flags()
3405 if (m_wx_model
->IsVirtualListModel())
3406 return GTK_TREE_MODEL_LIST_ONLY
;
3408 return GTK_TREE_MODEL_ITERS_PERSIST
;
3411 gboolean
wxDataViewCtrlInternal::get_iter( GtkTreeIter
*iter
, GtkTreePath
*path
)
3414 if (m_wx_model
->IsVirtualListModel())
3416 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3418 unsigned int i
= (unsigned int)gtk_tree_path_get_indices (path
)[0];
3420 if (i
>= wx_model
->GetCount())
3423 iter
->stamp
= m_gtk_model
->stamp
;
3424 // user_data is just the index +1
3425 iter
->user_data
= (gpointer
) (i
+1);
3431 int depth
= gtk_tree_path_get_depth( path
);
3433 wxGtkTreeModelNode
*node
= m_root
;
3436 for (i
= 0; i
< depth
; i
++)
3438 BuildBranch( node
);
3440 gint pos
= gtk_tree_path_get_indices (path
)[i
];
3441 if (pos
< 0) return FALSE
;
3442 if ((size_t)pos
>= node
->GetChildCount()) return FALSE
;
3444 void* id
= node
->GetChildren().Item( (size_t) pos
);
3448 iter
->stamp
= m_gtk_model
->stamp
;
3449 iter
->user_data
= id
;
3453 size_t count
= node
->GetNodes().GetCount();
3455 for (pos2
= 0; pos2
< count
; pos2
++)
3457 wxGtkTreeModelNode
*child_node
= node
->GetNodes().Item( pos2
);
3458 if (child_node
->GetItem().GetID() == id
)
3470 GtkTreePath
*wxDataViewCtrlInternal::get_path( GtkTreeIter
*iter
)
3472 GtkTreePath
*retval
= gtk_tree_path_new ();
3474 if (m_wx_model
->IsVirtualListModel())
3476 // user_data is just the index +1
3477 int i
= ( (wxUIntPtr
) iter
->user_data
) -1;
3478 gtk_tree_path_append_index (retval
, i
);
3482 void *id
= iter
->user_data
;
3484 wxGtkTreeModelNode
*node
= FindParentNode( iter
);
3487 int pos
= node
->GetChildren().Index( id
);
3489 gtk_tree_path_prepend_index( retval
, pos
);
3491 id
= node
->GetItem().GetID();
3492 node
= node
->GetParent();
3499 gboolean
wxDataViewCtrlInternal::iter_next( GtkTreeIter
*iter
)
3501 if (m_wx_model
->IsVirtualListModel())
3503 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3505 // user_data is just the index +1
3506 int n
= ( (wxUIntPtr
) iter
->user_data
) -1;
3510 iter
->user_data
= NULL
;
3514 if (n
>= (int) wx_model
->GetCount()-1)
3516 iter
->user_data
= NULL
;
3520 // user_data is just the index +1 (+2 because we need the next)
3521 iter
->user_data
= (gpointer
) (n
+2);
3525 wxGtkTreeModelNode
*parent
= FindParentNode( iter
);
3526 if( parent
== NULL
)
3528 iter
->user_data
= NULL
;
3532 int pos
= parent
->GetChildren().Index( iter
->user_data
);
3534 if (pos
== (int) parent
->GetChildCount()-1)
3536 iter
->user_data
= NULL
;
3540 iter
->user_data
= parent
->GetChildren().Item( pos
+1 );
3546 gboolean
wxDataViewCtrlInternal::iter_children( GtkTreeIter
*iter
, GtkTreeIter
*parent
)
3548 if (m_wx_model
->IsVirtualListModel())
3550 // this is a list, nodes have no children
3554 iter
->stamp
= m_gtk_model
->stamp
;
3555 iter
->user_data
= (gpointer
) 1;
3563 if (m_root
->GetChildCount() == 0) return FALSE
;
3564 iter
->stamp
= m_gtk_model
->stamp
;
3565 iter
->user_data
= (gpointer
) m_root
->GetChildren().Item( 0 );
3569 wxDataViewItem
item( (void*) parent
->user_data
);
3571 if (!m_wx_model
->IsContainer( item
))
3574 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3575 wxASSERT_MSG(parent_node
,
3576 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3578 BuildBranch( parent_node
);
3580 if (parent_node
->GetChildCount() == 0)
3583 iter
->stamp
= m_gtk_model
->stamp
;
3584 iter
->user_data
= (gpointer
) parent_node
->GetChildren().Item( 0 );
3590 gboolean
wxDataViewCtrlInternal::iter_has_child( GtkTreeIter
*iter
)
3592 if (m_wx_model
->IsVirtualListModel())
3594 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3597 return (wx_model
->GetCount() > 0);
3599 // this is a list, nodes have no children
3605 return (m_root
->GetChildCount() > 0);
3607 wxDataViewItem
item( (void*) iter
->user_data
);
3609 bool is_container
= m_wx_model
->IsContainer( item
);
3614 wxGtkTreeModelNode
*node
= FindNode( iter
);
3616 "Did you forget a call to ItemAdded()? The iterator is unknown to the wxGtkTreeModel");
3618 BuildBranch( node
);
3620 return (node
->GetChildCount() > 0);
3624 gint
wxDataViewCtrlInternal::iter_n_children( GtkTreeIter
*iter
)
3626 if (m_wx_model
->IsVirtualListModel())
3628 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3631 return (gint
) wx_model
->GetCount();
3638 return m_root
->GetChildCount();
3640 wxDataViewItem
item( (void*) iter
->user_data
);
3642 if (!m_wx_model
->IsContainer( item
))
3645 wxGtkTreeModelNode
*parent_node
= FindNode( iter
);
3646 wxASSERT_MSG(parent_node
,
3647 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3649 BuildBranch( parent_node
);
3651 return parent_node
->GetChildCount();
3655 gboolean
wxDataViewCtrlInternal::iter_nth_child( GtkTreeIter
*iter
, GtkTreeIter
*parent
, gint n
)
3657 if (m_wx_model
->IsVirtualListModel())
3659 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3667 if (n
>= (gint
) wx_model
->GetCount())
3670 iter
->stamp
= m_gtk_model
->stamp
;
3671 // user_data is just the index +1
3672 iter
->user_data
= (gpointer
) (n
+1);
3679 if (parent
) id
= (void*) parent
->user_data
;
3680 wxDataViewItem
item( id
);
3682 if (!m_wx_model
->IsContainer( item
))
3685 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3686 wxASSERT_MSG(parent_node
,
3687 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3689 BuildBranch( parent_node
);
3691 iter
->stamp
= m_gtk_model
->stamp
;
3692 iter
->user_data
= parent_node
->GetChildren().Item( n
);
3698 gboolean
wxDataViewCtrlInternal::iter_parent( GtkTreeIter
*iter
, GtkTreeIter
*child
)
3700 if (m_wx_model
->IsVirtualListModel())
3706 wxGtkTreeModelNode
*node
= FindParentNode( child
);
3710 iter
->stamp
= m_gtk_model
->stamp
;
3711 iter
->user_data
= (gpointer
) node
->GetItem().GetID();
3717 static wxGtkTreeModelNode
*
3718 wxDataViewCtrlInternal_FindNode( wxDataViewModel
* model
, wxGtkTreeModelNode
*treeNode
, const wxDataViewItem
&item
)
3724 list
.DeleteContents( true );
3725 wxDataViewItem
it( item
);
3729 wxDataViewItem
* pItem
= new wxDataViewItem( it
);
3730 list
.Insert( pItem
);
3731 it
= model
->GetParent( it
);
3734 wxGtkTreeModelNode
* node
= treeNode
;
3735 for( ItemList::compatibility_iterator n
= list
.GetFirst(); n
; n
= n
->GetNext() )
3737 if( node
&& node
->GetNodes().GetCount() != 0 )
3739 int len
= node
->GetNodes().GetCount();
3740 wxGtkTreeModelNodes nodes
= node
->GetNodes();
3742 for( ; j
< len
; j
++)
3744 if( nodes
[j
]->GetItem() == *(n
->GetData()))
3763 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindNode( GtkTreeIter
*iter
)
3768 wxDataViewItem
item( (void*) iter
->user_data
);
3772 wxGtkTreeModelNode
*result
= wxDataViewCtrlInternal_FindNode( m_wx_model
, m_root
, item
);
3777 wxLogDebug( "Not found %p", iter->user_data );
3781 // TODO: remove this code
3787 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindNode( const wxDataViewItem
&item
)
3792 wxGtkTreeModelNode
*result
= wxDataViewCtrlInternal_FindNode( m_wx_model
, m_root
, item
);
3797 wxLogDebug( "Not found %p", item.GetID() );
3801 // TODO: remove this code
3807 static wxGtkTreeModelNode
*
3808 wxDataViewCtrlInternal_FindParentNode( wxDataViewModel
* model
, wxGtkTreeModelNode
*treeNode
, const wxDataViewItem
&item
)
3814 list
.DeleteContents( true );
3818 wxDataViewItem
it( model
->GetParent( item
) );
3821 wxDataViewItem
* pItem
= new wxDataViewItem( it
);
3822 list
.Insert( pItem
);
3823 it
= model
->GetParent( it
);
3826 wxGtkTreeModelNode
* node
= treeNode
;
3827 for( ItemList::compatibility_iterator n
= list
.GetFirst(); n
; n
= n
->GetNext() )
3829 if( node
&& node
->GetNodes().GetCount() != 0 )
3831 int len
= node
->GetNodes().GetCount();
3832 wxGtkTreeModelNodes nodes
= node
->GetNodes();
3834 for( ; j
< len
; j
++)
3836 if( nodes
[j
]->GetItem() == *(n
->GetData()))
3851 //Examine whether the node is item's parent node
3852 int len
= node
->GetChildCount();
3853 for( int i
= 0; i
< len
; i
++ )
3855 if( node
->GetChildren().Item( i
) == item
.GetID() )
3861 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindParentNode( GtkTreeIter
*iter
)
3866 wxDataViewItem
item( (void*) iter
->user_data
);
3870 return wxDataViewCtrlInternal_FindParentNode( m_wx_model
, m_root
, item
);
3873 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindParentNode( const wxDataViewItem
&item
)
3878 return wxDataViewCtrlInternal_FindParentNode( m_wx_model
, m_root
, item
);
3881 //-----------------------------------------------------------------------------
3882 // wxDataViewCtrl signal callbacks
3883 //-----------------------------------------------------------------------------
3886 wxdataview_selection_changed_callback( GtkTreeSelection
* WXUNUSED(selection
), wxDataViewCtrl
*dv
)
3888 if (!GTK_WIDGET_REALIZED(dv
->m_widget
))
3891 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED
, dv
->GetId() );
3892 event
.SetItem( dv
->GetSelection() );
3893 event
.SetModel( dv
->GetModel() );
3894 dv
->HandleWindowEvent( event
);
3898 wxdataview_row_activated_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreePath
*path
,
3899 GtkTreeViewColumn
*WXUNUSED(column
), wxDataViewCtrl
*dv
)
3901 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED
, dv
->GetId() );
3904 dv
->GtkGetInternal()->get_iter( &iter
, path
);
3905 wxDataViewItem
item( (void*) iter
.user_data
);;
3906 event
.SetItem( item
);
3907 event
.SetModel( dv
->GetModel() );
3908 dv
->HandleWindowEvent( event
);
3912 wxdataview_test_expand_row_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
3913 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
3915 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING
, dv
->GetId() );
3917 wxDataViewItem
item( (void*) iter
->user_data
);;
3918 event
.SetItem( item
);
3919 event
.SetModel( dv
->GetModel() );
3920 dv
->HandleWindowEvent( event
);
3922 return !event
.IsAllowed();
3926 wxdataview_row_expanded_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
3927 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
3929 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED
, dv
->GetId() );
3931 wxDataViewItem
item( (void*) iter
->user_data
);;
3932 event
.SetItem( item
);
3933 event
.SetModel( dv
->GetModel() );
3934 dv
->HandleWindowEvent( event
);
3938 wxdataview_test_collapse_row_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
3939 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
3941 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING
, dv
->GetId() );
3943 wxDataViewItem
item( (void*) iter
->user_data
);;
3944 event
.SetItem( item
);
3945 event
.SetModel( dv
->GetModel() );
3946 dv
->HandleWindowEvent( event
);
3948 return !event
.IsAllowed();
3952 wxdataview_row_collapsed_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
3953 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
3955 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED
, dv
->GetId() );
3957 wxDataViewItem
item( (void*) iter
->user_data
);;
3958 event
.SetItem( item
);
3959 event
.SetModel( dv
->GetModel() );
3960 dv
->HandleWindowEvent( event
);
3963 //-----------------------------------------------------------------------------
3965 //-----------------------------------------------------------------------------
3967 void wxDataViewCtrl::AddChildGTK(wxWindowGTK
* child
)
3969 GtkWidget
* treeview
= GtkGetTreeView();
3971 // Insert widget in GtkTreeView
3972 if (GTK_WIDGET_REALIZED(treeview
))
3973 gtk_widget_set_parent_window( child
->m_widget
,
3974 gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview
) ) );
3975 gtk_widget_set_parent( child
->m_widget
, treeview
);
3979 void gtk_dataviewctrl_size_callback( GtkWidget
*WXUNUSED(widget
),
3980 GtkAllocation
*WXUNUSED(gtk_alloc
),
3981 wxDataViewCtrl
*win
)
3983 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3986 wxWindow
*child
= node
->GetData();
3989 gtk_widget_size_request( child
->m_widget
, &req
);
3991 GtkAllocation alloc
;
3992 alloc
.x
= child
->m_x
;
3993 alloc
.y
= child
->m_y
;
3994 alloc
.width
= child
->m_width
;
3995 alloc
.height
= child
->m_height
;
3996 gtk_widget_size_allocate( child
->m_widget
, &alloc
);
3998 node
= node
->GetNext();
4003 //-----------------------------------------------------------------------------
4004 // "motion_notify_event"
4005 //-----------------------------------------------------------------------------
4008 gtk_dataview_motion_notify_callback( GtkWidget
*WXUNUSED(widget
),
4009 GdkEventMotion
*gdk_event
,
4010 wxDataViewCtrl
*dv
)
4012 if (gdk_event
->is_hint
)
4016 GdkModifierType state
;
4017 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
4022 GtkTreePath
*path
= NULL
;
4023 GtkTreeViewColumn
*column
= NULL
;
4026 if (gtk_tree_view_get_path_at_pos(
4027 GTK_TREE_VIEW(dv
->GtkGetTreeView()),
4028 (int) gdk_event
->x
, (int) gdk_event
->y
,
4037 dv
->GtkGetInternal()->get_iter( &iter
, path
);
4039 gtk_tree_path_free( path
);
4047 //-----------------------------------------------------------------------------
4048 // "button_press_event"
4049 //-----------------------------------------------------------------------------
4052 gtk_dataview_button_press_callback( GtkWidget
*WXUNUSED(widget
),
4053 GdkEventButton
*gdk_event
,
4054 wxDataViewCtrl
*dv
)
4056 if ((gdk_event
->button
== 3) && (gdk_event
->type
== GDK_BUTTON_PRESS
))
4058 GtkTreePath
*path
= NULL
;
4059 GtkTreeViewColumn
*column
= NULL
;
4062 if (gtk_tree_view_get_path_at_pos(
4063 GTK_TREE_VIEW(dv
->GtkGetTreeView()),
4064 (int) gdk_event
->x
, (int) gdk_event
->y
,
4073 dv
->GtkGetInternal()->get_iter( &iter
, path
);
4075 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU
, dv
->GetId() );
4076 wxDataViewItem
item( (void*) iter
.user_data
);;
4077 event
.SetItem( item
);
4078 event
.SetModel( dv
->GetModel() );
4079 bool ret
= dv
->HandleWindowEvent( event
);
4080 gtk_tree_path_free( path
);
4089 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl
, wxDataViewCtrlBase
)
4091 wxDataViewCtrl::~wxDataViewCtrl()
4094 GetModel()->RemoveNotifier( m_notifier
);
4098 // remove the model from the GtkTreeView before it gets destroyed by the
4099 // wxDataViewCtrlBase's dtor
4100 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview
), NULL
);
4105 void wxDataViewCtrl::Init()
4110 m_cols
.DeleteContents( true );
4113 bool wxDataViewCtrl::Create(wxWindow
*parent
, wxWindowID id
,
4114 const wxPoint
& pos
, const wxSize
& size
,
4115 long style
, const wxValidator
& validator
)
4117 if (!PreCreation( parent
, pos
, size
) ||
4118 !CreateBase( parent
, id
, pos
, size
, style
, validator
))
4120 wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
4124 m_widget
= gtk_scrolled_window_new (NULL
, NULL
);
4125 g_object_ref(m_widget
);
4127 GTKScrolledWindowSetBorder(m_widget
, style
);
4129 m_treeview
= gtk_tree_view_new();
4130 gtk_container_add (GTK_CONTAINER (m_widget
), m_treeview
);
4132 g_signal_connect (m_treeview
, "size_allocate",
4133 G_CALLBACK (gtk_dataviewctrl_size_callback
), this);
4136 if (!gtk_check_version(2,6,0))
4138 bool fixed
= (style
& wxDV_VARIABLE_LINE_HEIGHT
) == 0;
4139 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), fixed
);
4143 if (style
& wxDV_MULTIPLE
)
4145 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4146 gtk_tree_selection_set_mode( selection
, GTK_SELECTION_MULTIPLE
);
4149 gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview
), (style
& wxDV_NO_HEADER
) == 0 );
4152 if (!gtk_check_version(2,10,0))
4154 GtkTreeViewGridLines grid
= GTK_TREE_VIEW_GRID_LINES_NONE
;
4156 if ((style
& wxDV_HORIZ_RULES
) != 0 &&
4157 (style
& wxDV_VERT_RULES
) != 0)
4158 grid
= GTK_TREE_VIEW_GRID_LINES_BOTH
;
4159 else if (style
& wxDV_VERT_RULES
)
4160 grid
= GTK_TREE_VIEW_GRID_LINES_VERTICAL
;
4161 else if (style
& wxDV_HORIZ_RULES
)
4162 grid
= GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
;
4164 if (grid
!= GTK_TREE_VIEW_GRID_LINES_NONE
)
4165 gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview
), grid
);
4169 gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview
), (style
& wxDV_ROW_LINES
) != 0 );
4171 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget
),
4172 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
4173 gtk_widget_show (m_treeview
);
4175 m_parent
->DoAddChild( this );
4179 GtkEnableSelectionEvents();
4181 g_signal_connect_after (m_treeview
, "row-activated",
4182 G_CALLBACK (wxdataview_row_activated_callback
), this);
4184 g_signal_connect (m_treeview
, "test-collapse-row",
4185 G_CALLBACK (wxdataview_test_collapse_row_callback
), this);
4187 g_signal_connect_after (m_treeview
, "row-collapsed",
4188 G_CALLBACK (wxdataview_row_collapsed_callback
), this);
4190 g_signal_connect (m_treeview
, "test-expand-row",
4191 G_CALLBACK (wxdataview_test_expand_row_callback
), this);
4193 g_signal_connect_after (m_treeview
, "row-expanded",
4194 G_CALLBACK (wxdataview_row_expanded_callback
), this);
4196 g_signal_connect (m_treeview
, "motion_notify_event",
4197 G_CALLBACK (gtk_dataview_motion_notify_callback
), this);
4199 g_signal_connect (m_treeview
, "button_press_event",
4200 G_CALLBACK (gtk_dataview_button_press_callback
), this);
4205 void wxDataViewCtrl::OnInternalIdle()
4207 wxWindow::OnInternalIdle();
4209 unsigned int cols
= GetColumnCount();
4211 for (i
= 0; i
< cols
; i
++)
4213 wxDataViewColumn
*col
= GetColumn( i
);
4214 col
->OnInternalIdle();
4218 bool wxDataViewCtrl::AssociateModel( wxDataViewModel
*model
)
4226 if (!wxDataViewCtrlBase::AssociateModel( model
))
4230 if (!gtk_check_version(2,6,0))
4232 bool fixed
= (((GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT
) == 0) || (model
->IsVirtualListModel()));
4233 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), fixed
);
4237 GtkWxTreeModel
*gtk_model
= wxgtk_tree_model_new();
4238 m_internal
= new wxDataViewCtrlInternal( this, model
, gtk_model
);
4239 gtk_model
->internal
= m_internal
;
4241 m_notifier
= new wxGtkDataViewModelNotifier( gtk_model
, model
, this );
4243 model
->AddNotifier( m_notifier
);
4245 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview
), GTK_TREE_MODEL(gtk_model
) );
4247 // unref in wxDataViewCtrlInternal
4248 // g_object_unref( gtk_model );
4253 bool wxDataViewCtrl::EnableDragSource( const wxDataFormat
&format
)
4255 return m_internal
->EnableDragSource( format
);
4258 bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat
&format
)
4260 return m_internal
->EnableDropTarget( format
);
4263 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn
*col
)
4265 if (!wxDataViewCtrlBase::AppendColumn(col
))
4268 m_cols
.Append( col
);
4271 if (!gtk_check_version(2,6,0))
4273 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4274 GTK_TREE_VIEW_COLUMN_FIXED
)
4275 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4279 gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview
),
4280 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) );
4285 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn
*col
)
4287 if (!wxDataViewCtrlBase::PrependColumn(col
))
4290 m_cols
.Insert( col
);
4293 if (!gtk_check_version(2,6,0))
4295 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4296 GTK_TREE_VIEW_COLUMN_FIXED
)
4297 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4301 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview
),
4302 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()), 0 );
4307 bool wxDataViewCtrl::InsertColumn( unsigned int pos
, wxDataViewColumn
*col
)
4309 if (!wxDataViewCtrlBase::InsertColumn(pos
,col
))
4312 m_cols
.Insert( pos
, col
);
4315 if (!gtk_check_version(2,6,0))
4317 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4318 GTK_TREE_VIEW_COLUMN_FIXED
)
4319 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4323 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview
),
4324 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()), pos
);
4329 unsigned int wxDataViewCtrl::GetColumnCount() const
4331 return m_cols
.GetCount();
4334 wxDataViewColumn
* wxDataViewCtrl::GetColumn( unsigned int pos
) const
4336 GtkTreeViewColumn
*gtk_col
= gtk_tree_view_get_column( GTK_TREE_VIEW(m_treeview
), pos
);
4340 wxDataViewColumnList::const_iterator iter
;
4341 for (iter
= m_cols
.begin(); iter
!= m_cols
.end(); ++iter
)
4343 wxDataViewColumn
*col
= *iter
;
4344 if (GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) == gtk_col
)
4353 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn
*column
)
4355 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview
),
4356 GTK_TREE_VIEW_COLUMN(column
->GetGtkHandle()) );
4358 m_cols
.DeleteObject( column
);
4363 bool wxDataViewCtrl::ClearColumns()
4365 wxDataViewColumnList::iterator iter
;
4366 for (iter
= m_cols
.begin(); iter
!= m_cols
.end(); ++iter
)
4368 wxDataViewColumn
*col
= *iter
;
4369 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview
),
4370 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) );
4378 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn
*column
) const
4380 GtkTreeViewColumn
*gtk_column
= GTK_TREE_VIEW_COLUMN(column
->GetConstGtkHandle());
4382 GList
*list
= gtk_tree_view_get_columns( GTK_TREE_VIEW(m_treeview
) );
4384 gint pos
= g_list_index( list
, (gconstpointer
) gtk_column
);
4386 g_list_free( list
);
4391 wxDataViewColumn
*wxDataViewCtrl::GetSortingColumn() const
4393 return m_internal
->GetDataViewSortColumn();
4396 void wxDataViewCtrl::Expand( const wxDataViewItem
& item
)
4399 iter
.user_data
= item
.GetID();
4400 GtkTreePath
*path
= m_internal
->get_path( &iter
);
4401 gtk_tree_view_expand_row( GTK_TREE_VIEW(m_treeview
), path
, false );
4402 gtk_tree_path_free( path
);
4405 void wxDataViewCtrl::Collapse( const wxDataViewItem
& item
)
4408 iter
.user_data
= item
.GetID();
4409 GtkTreePath
*path
= m_internal
->get_path( &iter
);
4410 gtk_tree_view_collapse_row( GTK_TREE_VIEW(m_treeview
), path
);
4411 gtk_tree_path_free( path
);
4414 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem
& item
) const
4417 iter
.user_data
= item
.GetID();
4418 GtkTreePath
*path
= m_internal
->get_path( &iter
);
4419 bool res
= gtk_tree_view_row_expanded( GTK_TREE_VIEW(m_treeview
), path
);
4420 gtk_tree_path_free( path
);
4425 wxDataViewItem
wxDataViewCtrl::GetSelection() const
4427 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4429 if (m_windowStyle
& wxDV_MULTIPLE
)
4431 // Report the first one
4432 GtkTreeModel
*model
;
4433 GList
*list
= gtk_tree_selection_get_selected_rows( selection
, &model
);
4437 GtkTreePath
*path
= (GtkTreePath
*) list
->data
;
4439 m_internal
->get_iter( &iter
, path
);
4442 g_list_foreach( list
, (GFunc
) gtk_tree_path_free
, NULL
);
4443 g_list_free( list
);
4445 return wxDataViewItem( (void*) iter
.user_data
);
4451 if (gtk_tree_selection_get_selected( selection
, NULL
, &iter
))
4453 wxDataViewItem
item( (void*) iter
.user_data
);
4458 return wxDataViewItem(0);
4461 int wxDataViewCtrl::GetSelections( wxDataViewItemArray
& sel
) const
4465 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4466 if (HasFlag(wxDV_MULTIPLE
))
4468 GtkTreeModel
*model
;
4469 GList
*list
= gtk_tree_selection_get_selected_rows( selection
, &model
);
4474 GtkTreePath
*path
= (GtkTreePath
*) list
->data
;
4477 m_internal
->get_iter( &iter
, path
);
4479 sel
.Add( wxDataViewItem( (void*) iter
.user_data
) );
4481 list
= g_list_next( list
);
4486 g_list_foreach( list
, (GFunc
) gtk_tree_path_free
, NULL
);
4487 g_list_free( list
);
4493 GtkTreeModel
*model
;
4495 gboolean has_selection
= gtk_tree_selection_get_selected( selection
, &model
, &iter
);
4498 sel
.Add( wxDataViewItem( (void*) iter
.user_data
) );
4506 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray
& sel
)
4508 GtkDisableSelectionEvents();
4510 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4512 gtk_tree_selection_unselect_all( selection
);
4514 wxDataViewItem last_parent
;
4517 for (i
= 0; i
< sel
.GetCount(); i
++)
4519 wxDataViewItem item
= sel
[i
];
4520 wxDataViewItem parent
= GetModel()->GetParent( item
);
4523 if (parent
!= last_parent
)
4524 ExpandAncestors(item
);
4526 last_parent
= parent
;
4529 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4530 iter
.user_data
= (gpointer
) item
.GetID();
4531 gtk_tree_selection_select_iter( selection
, &iter
);
4534 GtkEnableSelectionEvents();
4537 void wxDataViewCtrl::Select( const wxDataViewItem
& item
)
4539 ExpandAncestors(item
);
4541 GtkDisableSelectionEvents();
4543 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4546 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4547 iter
.user_data
= (gpointer
) item
.GetID();
4548 gtk_tree_selection_select_iter( selection
, &iter
);
4550 GtkEnableSelectionEvents();
4553 void wxDataViewCtrl::Unselect( const wxDataViewItem
& item
)
4555 GtkDisableSelectionEvents();
4557 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4560 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4561 iter
.user_data
= (gpointer
) item
.GetID();
4562 gtk_tree_selection_unselect_iter( selection
, &iter
);
4564 GtkEnableSelectionEvents();
4567 bool wxDataViewCtrl::IsSelected( const wxDataViewItem
& item
) const
4569 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4572 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4573 iter
.user_data
= (gpointer
) item
.GetID();
4575 return gtk_tree_selection_iter_is_selected( selection
, &iter
);
4578 void wxDataViewCtrl::SelectAll()
4580 GtkDisableSelectionEvents();
4582 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4584 gtk_tree_selection_select_all( selection
);
4586 GtkEnableSelectionEvents();
4589 void wxDataViewCtrl::UnselectAll()
4591 GtkDisableSelectionEvents();
4593 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4595 gtk_tree_selection_unselect_all( selection
);
4597 GtkEnableSelectionEvents();
4600 void wxDataViewCtrl::EnsureVisible(const wxDataViewItem
& item
,
4601 const wxDataViewColumn
*WXUNUSED(column
))
4603 ExpandAncestors(item
);
4606 iter
.user_data
= (gpointer
) item
.GetID();
4607 GtkTreePath
*path
= m_internal
->get_path( &iter
);
4608 gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview
), path
, NULL
, false, 0.0, 0.0 );
4609 gtk_tree_path_free( path
);
4612 void wxDataViewCtrl::HitTest(const wxPoint
& WXUNUSED(point
),
4613 wxDataViewItem
& item
,
4614 wxDataViewColumn
*& column
) const
4616 item
= wxDataViewItem(0);
4621 wxDataViewCtrl::GetItemRect(const wxDataViewItem
& WXUNUSED(item
),
4622 const wxDataViewColumn
*WXUNUSED(column
)) const
4627 void wxDataViewCtrl::DoSetExpanderColumn()
4629 gtk_tree_view_set_expander_column( GTK_TREE_VIEW(m_treeview
),
4630 GTK_TREE_VIEW_COLUMN( GetExpanderColumn()->GetGtkHandle() ) );
4633 void wxDataViewCtrl::DoSetIndent()
4637 void wxDataViewCtrl::GtkDisableSelectionEvents()
4639 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4640 g_signal_handlers_disconnect_by_func( selection
,
4641 (gpointer
) (wxdataview_selection_changed_callback
), this);
4644 void wxDataViewCtrl::GtkEnableSelectionEvents()
4646 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4647 g_signal_connect_after (selection
, "changed",
4648 G_CALLBACK (wxdataview_selection_changed_callback
), this);
4651 // ----------------------------------------------------------------------------
4652 // visual attributes stuff
4653 // ----------------------------------------------------------------------------
4657 wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
4659 return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new
);
4662 void wxDataViewCtrl::DoApplyWidgetStyle(GtkRcStyle
*style
)
4664 wxDataViewCtrlBase::DoApplyWidgetStyle(style
);
4665 gtk_widget_modify_style(m_treeview
, style
);
4668 #endif // !wxUSE_GENERICDATAVIEWCTRL
4670 #endif // wxUSE_DATAVIEWCTRL